dsh-theme-gallery 0.4.1 → 0.6.0

package/lib/client.js

@@ -82,6 +82,9 @@ window.__ModuleLoader__.load({
     // module seed (`dsh-client-store`) or the shell (`react/jsx-runtime`).
     const { defineStore } = require('@deepseek-ai/dsh-client-store')
     const { jsx, jsxs } = require('react/jsx-runtime')
+    // 设置分节组件用：把 pinned store 订阅成 React 视图（useSyncExternalStore，
+    // React 18+；dsh-pet 的分节同样直接消费 react）。本插件其余部分仍零 hooks。
+    const { useSyncExternalStore } = require('react')
 
     /** Panel id shared by the sidebar icon and the main-column page. */
     const PANEL_ID = 'theme-gallery'
@@ -146,6 +149,9 @@ window.__ModuleLoader__.load({
       'meng-hai-you-yu': 80,
       'hu-po-mao-mi': 76,
       'hu-zi-a-huang': 75,
+      'pet-family': 74,
+      'mood-greeting': 73,
+      'menu-collapse': 72,
     }
 
     /**
@@ -215,6 +221,45 @@ window.__ModuleLoader__.load({
     /** 所选配色方案记在这里。与皮肤 id 一样，**绝不**写进 `ui-theme.preference`。 */
     const SCHEME_KEY = 'theme-gallery:palette'
 
+    /* ═══════════════════ 宠物挂件卡（宠物家族 × 7）═══════════════════
+     *
+     * 这张卡**不是主题**：它不进 `lib/themes/`、不被 `contribute()` 注册进主题服务、
+     * 官方「设置 → 通用 → 外观」不会多出这一项，点它也**不切主题** —— 只开关/挑选挂件。
+     * 因此它天然能与任何皮肤（包括山青婷彩 / 梦海游鱼）同时开启，也不消耗主题写入预算。
+     * 卡片数据只在面板里合成（见 `petWidgetCardTheme`），挂件本体画在
+     * `#dsh-theme-pet` 固定层，锚定对话输入框 —— 不配 `ambient`，不碰侧栏素材区。
+     * 二期：卡内是 7 只宠物的头像选择行（`petPickerElement`），点头像换宠物并放它出场。
+     */
+
+    /**
+     * 挂件卡的 id、标题与 tooltip 文案。
+     *
+     * 卡片正面**不渲染** description（与「纯色/拼色」卡同一条分支，见 `ThemeCard`）：
+     * 卡面是标题、状态徽标、当前宠物与它的道具图案，再加一行头像选择，这段文案只作
+     * 悬停提示（title）。schema 对主题 JSON 的 description 非空约束管不到它 —— 它
+     * 本来就不是主题 JSON。
+     */
+    const PET_WIDGET = {
+      id: 'pet-family',
+      label: '宠物挂件 · 七只小伙伴',
+      description: '七只小宠物轮流陪聊：点头像换一只并放它出场，点卡身空白处仅开关。'
+        + '挂件不改变当前主题皮肤；移到宠物身上可改名、戳一戳；拖动宠物或它的道具，'
+        + '它会跑向道具。它还会在你想事情时说悄悄话、在模型生成时为你加油。',
+    }
+
+    /** 挂件的启停 / 名字 / 位置记在这里。与皮肤 id 同一条铁律：绝不写 `ui-theme.preference`。 */
+    const PET_KEY = 'theme-gallery:pet'
+
+    /**
+     * 宠物的显示缩放。注册表 `size` 是逻辑坐标（与 viewBox 1:1，全部几何以它推），
+     * 实机验收反馈整体偏小 —— 屏幕显示统一放大 15%，宠物与道具同缩放。
+     * 放大只发生在**消费端**（petDisplaySize / petPropDisplaySize 两个助手）：
+     * 注册表数据与 viewBox 一个数字都不动（check-pet-registry 的 P3 钉的就是 1:1）。
+     * 声明在这里（而非宠物运行区）是因为面板卡 petCardSceneHTML 也要读它 ——
+     * TDZ 审计要求 const 声明在第一个读取者之前。
+     */
+    const PET_SCALE = 1.15
+
     /**
      * 按 id 取一套配色方案。
      * @param id - 方案 id。
@@ -599,7 +644,7 @@ window.__ModuleLoader__.load({
      * package.json, and the release workflow fails when re-running the embed step
      * changes a tracked file.
      */
-    const BUNDLED_VERSION = '0.4.1'
+    const BUNDLED_VERSION = '0.6.0'
 
     /**
      * Themes this package contributes, inlined from lib/themes/*.json.
@@ -2835,6 +2880,419 @@ window.__ModuleLoader__.load({
         "source": "蓝 8-2 藏青（深蓝）+ 金银 8-0 赤金 + 精白 + 红 0-0 粉红 + 绿 2-14 翡翠色"
       }
     ]
+
+    const BUNDLED_MOOD_LINES = {
+      "$comment": "心情问候语库（标题栏跑马灯）。出处：40 条种子复制自作者自己的「更新管理平台」站点（装修管理-心情问候语，2026-09-27 抓取，seq 1-40）；seq 101+ 为插件新增。分类沿用站点五类：morning 早安 / day 白天 / night 夜深 / general 通用 / holiday 节假日。节日区间为 MM-DD（去年份，每年复用）。红线：禁止负面、消极或敏感言论——embed-themes.mjs 建期黑名单校验，命中即构建失败。单条 text 不超过 100 字符。",
+      "version": 1,
+      "lines": [
+        {
+          "id": "m001",
+          "seq": 1,
+          "category": "morning",
+          "text": "寻必寻见，想必到达"
+        },
+        {
+          "id": "m002",
+          "seq": 2,
+          "category": "morning",
+          "text": "晨光不负赶路人，新的一天从心安开始"
+        },
+        {
+          "id": "m003",
+          "seq": 3,
+          "category": "morning",
+          "text": "今天也要做自己的太阳，无需凭借谁的光"
+        },
+        {
+          "id": "m004",
+          "seq": 4,
+          "category": "morning",
+          "text": "万物皆有裂痕，那是光照进来的地方"
+        },
+        {
+          "id": "m005",
+          "seq": 5,
+          "category": "morning",
+          "text": "早安，愿你所遇皆温柔，所行皆坦途"
+        },
+        {
+          "id": "m006",
+          "seq": 6,
+          "category": "morning",
+          "text": "把昨天的疲惫留在梦里，把今天的期待装进行囊"
+        },
+        {
+          "id": "m007",
+          "seq": 7,
+          "category": "morning",
+          "text": "山高路远，看世界，也找自己"
+        },
+        {
+          "id": "m008",
+          "seq": 8,
+          "category": "morning",
+          "text": "每一个清晨，都是世界温柔的重新开始"
+        },
+        {
+          "id": "m009",
+          "seq": 9,
+          "category": "day",
+          "text": "你对我来说真的很重要"
+        },
+        {
+          "id": "m010",
+          "seq": 10,
+          "category": "day",
+          "text": "心若无所求，有风无风皆自由"
+        },
+        {
+          "id": "m011",
+          "seq": 11,
+          "category": "day",
+          "text": "慢慢来，比较快"
+        },
+        {
+          "id": "m012",
+          "seq": 12,
+          "category": "day",
+          "text": "生活的答案，都藏在认真过好的今天里"
+        },
+        {
+          "id": "m013",
+          "seq": 13,
+          "category": "day",
+          "text": "保持热爱，奔赴山海"
+        },
+        {
+          "id": "m014",
+          "seq": 14,
+          "category": "day",
+          "text": "心中有丘壑，眉目作山河"
+        },
+        {
+          "id": "m015",
+          "seq": 15,
+          "category": "day",
+          "text": "世界盛大，欢迎回家"
+        },
+        {
+          "id": "m016",
+          "seq": 16,
+          "category": "day",
+          "text": "别慌，月亮也正在大海的某处迷茫"
+        },
+        {
+          "id": "m017",
+          "seq": 17,
+          "category": "day",
+          "text": "与其追风去，不如等风来；等风来，不如乘风起"
+        },
+        {
+          "id": "m018",
+          "seq": 18,
+          "category": "day",
+          "text": "认真生活的人，生活从不亏待"
+        },
+        {
+          "id": "m019",
+          "seq": 19,
+          "category": "night",
+          "text": "我来到你待过的星空，算不算相逢"
+        },
+        {
+          "id": "m020",
+          "seq": 20,
+          "category": "night",
+          "text": "夜色温柔，愿你好梦"
+        },
+        {
+          "id": "m021",
+          "seq": 21,
+          "category": "night",
+          "text": "晚风吹人醒，万事藏于心"
+        },
+        {
+          "id": "m022",
+          "seq": 22,
+          "category": "night",
+          "text": "星光不问赶路人，时光不负有心人"
+        },
+        {
+          "id": "m023",
+          "seq": 23,
+          "category": "night",
+          "text": "今晚的月色替我说晚安"
+        },
+        {
+          "id": "m024",
+          "seq": 24,
+          "category": "night",
+          "text": "熬过漫长黑夜，才配拥有满天星辰"
+        },
+        {
+          "id": "m025",
+          "seq": 25,
+          "category": "night",
+          "text": "愿所有的疲惫，都被这个夜晚温柔收留"
+        },
+        {
+          "id": "m026",
+          "seq": 26,
+          "category": "night",
+          "text": "深夜的坚持，是明天惊喜的伏笔"
+        },
+        {
+          "id": "m027",
+          "seq": 27,
+          "category": "holiday",
+          "text": "盛世华诞，与国同庆；山河远阔，人间烟火",
+          "holiday": {
+            "from": "10-01",
+            "to": "10-08"
+          }
+        },
+        {
+          "id": "m028",
+          "seq": 28,
+          "category": "holiday",
+          "text": "新年快乐，愿新岁胜旧年，万事尽可期",
+          "holiday": {
+            "from": "01-01",
+            "to": "01-03"
+          }
+        },
+        {
+          "id": "m029",
+          "seq": 29,
+          "category": "holiday",
+          "text": "新春吉祥，灯火可亲，岁岁常安",
+          "holiday": {
+            "from": "02-05",
+            "to": "02-12"
+          }
+        },
+        {
+          "id": "m030",
+          "seq": 30,
+          "category": "holiday",
+          "text": "清明时节，追思故人，也惜眼前春光",
+          "holiday": {
+            "from": "04-04",
+            "to": "04-06"
+          }
+        },
+        {
+          "id": "m031",
+          "seq": 31,
+          "category": "holiday",
+          "text": "劳动节快乐，向每一位认真生活的人致敬",
+          "holiday": {
+            "from": "05-01",
+            "to": "05-05"
+          }
+        },
+        {
+          "id": "m032",
+          "seq": 32,
+          "category": "holiday",
+          "text": "粽叶飘香，端午安康",
+          "holiday": {
+            "from": "06-09",
+            "to": "06-11"
+          }
+        },
+        {
+          "id": "m033",
+          "seq": 33,
+          "category": "holiday",
+          "text": "但愿人长久，千里共婵娟",
+          "holiday": {
+            "from": "09-15",
+            "to": "09-16"
+          }
+        },
+        {
+          "id": "m034",
+          "seq": 34,
+          "category": "holiday",
+          "text": "举国同庆，家和人安，愿岁并谢，与友长兮",
+          "holiday": {
+            "from": "10-01",
+            "to": "10-08"
+          }
+        },
+        {
+          "id": "m035",
+          "seq": 35,
+          "category": "general",
+          "text": "愿你眼中总有光芒，活成你想要的模样"
+        },
+        {
+          "id": "m036",
+          "seq": 36,
+          "category": "general",
+          "text": "万事顺遂，毫无蹉跎"
+        },
+        {
+          "id": "m037",
+          "seq": 37,
+          "category": "general",
+          "text": "所有的美好，都在赶来的路上"
+        },
+        {
+          "id": "m038",
+          "seq": 38,
+          "category": "general",
+          "text": "心里有光，慢一点又何妨"
+        },
+        {
+          "id": "m039",
+          "seq": 39,
+          "category": "general",
+          "text": "平安喜乐，得偿所愿"
+        },
+        {
+          "id": "m040",
+          "seq": 40,
+          "category": "general",
+          "text": "岁月不扰，余生静好"
+        },
+        {
+          "id": "m101",
+          "seq": 101,
+          "category": "morning",
+          "text": "清晨的风，是今天寄来的第一封信"
+        },
+        {
+          "id": "m102",
+          "seq": 102,
+          "category": "morning",
+          "text": "新的一天：把小事做好，把心情调亮"
+        },
+        {
+          "id": "m103",
+          "seq": 103,
+          "category": "morning",
+          "text": "太阳照常升起，你也照常了不起"
+        },
+        {
+          "id": "m104",
+          "seq": 104,
+          "category": "morning",
+          "text": "今天的你，比昨天多一点点勇敢"
+        },
+        {
+          "id": "m105",
+          "seq": 105,
+          "category": "morning",
+          "text": "晨光已就位，慢慢来，别着急"
+        },
+        {
+          "id": "m106",
+          "seq": 106,
+          "category": "day",
+          "text": "慢慢走，路上有花"
+        },
+        {
+          "id": "m107",
+          "seq": 107,
+          "category": "day",
+          "text": "把日子过成自己喜欢的样子"
+        },
+        {
+          "id": "m108",
+          "seq": 108,
+          "category": "day",
+          "text": "今天的风很温柔，很适合认真生活"
+        },
+        {
+          "id": "m109",
+          "seq": 109,
+          "category": "day",
+          "text": "一步一步，都是向上的路"
+        },
+        {
+          "id": "m110",
+          "seq": 110,
+          "category": "day",
+          "text": "保持微笑，好运正在排队"
+        },
+        {
+          "id": "m111",
+          "seq": 111,
+          "category": "night",
+          "text": "夜深了，把烦恼调成静音"
+        },
+        {
+          "id": "m112",
+          "seq": 112,
+          "category": "night",
+          "text": "星星已就位，陪你收工"
+        },
+        {
+          "id": "m113",
+          "seq": 113,
+          "category": "night",
+          "text": "今晚适合早点休息，明天见"
+        },
+        {
+          "id": "m114",
+          "seq": 114,
+          "category": "night",
+          "text": "愿你被月光温柔以待"
+        },
+        {
+          "id": "m115",
+          "seq": 115,
+          "category": "night",
+          "text": "辛苦了，今天也好好完成了"
+        },
+        {
+          "id": "m116",
+          "seq": 116,
+          "category": "general",
+          "text": "慢慢来，一切都会如期而至"
+        },
+        {
+          "id": "m117",
+          "seq": 117,
+          "category": "general",
+          "text": "生活明朗，万物可爱"
+        },
+        {
+          "id": "m118",
+          "seq": 118,
+          "category": "general",
+          "text": "你走的每一步，都算数"
+        },
+        {
+          "id": "m119",
+          "seq": 119,
+          "category": "general",
+          "text": "所求皆如愿，所行化坦途"
+        },
+        {
+          "id": "m120",
+          "seq": 120,
+          "category": "holiday",
+          "text": "致每一位闪闪发光的她，节日快乐",
+          "holiday": {
+            "from": "03-08",
+            "to": "03-08"
+          }
+        },
+        {
+          "id": "m121",
+          "seq": 121,
+          "category": "holiday",
+          "text": "愿你我童心未泯，简单快乐",
+          "holiday": {
+            "from": "06-01",
+            "to": "06-01"
+          }
+        }
+      ]
+    }
     PALETTE_SCHEMES = Array.isArray(BUNDLED_PALETTES) ? BUNDLED_PALETTES : []
 
     /**
@@ -3195,9 +3653,20 @@ window.__ModuleLoader__.load({
     const zh = {
       title: '主题皮肤',
       hint: '点一下即切换，选中会记入设置',
-      count: '{count} 款皮肤（另有内置浅色/深色两张卡）',
+      count: '{count} 款皮肤（另有内置浅色/深色、宠物挂件、心情问候与菜单折叠五张卡）',
       current: '当前',
       applied: '已应用',
+      petOn: '已开启',
+      petOff: '已关闭',
+      menuCollapsed: '已折叠',
+      menuShown: '侧栏显示中',
+      menuPillLabel: '侧栏入口',
+      menuHint: '开启后，左侧栏不再显示「主题皮肤」入口；设置 → 通用设置（agent预设 下方）里有轻量入口，可一键打开面板或恢复侧栏显示。默认关闭。',
+      sectionHint: '换皮肤、调挂件与问候语都在主区全屏面板完成，效果看得见；这里是一键入口。',
+      openPanel: '打开主题皮肤面板',
+      restoreSidebar: '恢复侧栏入口',
+      sectionSkinLabel: '当前皮肤：',
+      sectionSidebarLabel: '侧栏入口：',
       empty: '正在读取官方主题注册表…',
       // The diagnostics below the cards are a FEATURE — a live reading of the active skin —
       // and a wall of monospace text reads as a fault unless the panel says otherwise.
@@ -3207,9 +3676,20 @@ window.__ModuleLoader__.load({
     const en = {
       title: 'Theme skins',
       hint: 'Click to switch; the choice is remembered',
-      count: '{count} skins (+ built-in light/dark cards)',
+      count: '{count} skins (+ built-in light/dark, pet-widget, mood-greeting and menu-collapse cards)',
       current: 'Current',
       applied: 'Applied',
+      petOn: 'On',
+      petOff: 'Off',
+      menuCollapsed: 'Collapsed',
+      menuShown: 'In sidebar',
+      menuPillLabel: 'Sidebar entry',
+      menuHint: 'When on, the sidebar no longer shows this entry; Settings → General (below the Agent preset) has a lightweight entry to open the panel or restore the sidebar. Off by default.',
+      sectionHint: 'Skins, the pet and the greeting live in the full main-area panel where the effect is visible; this is a one-click entry.',
+      openPanel: 'Open the theme panel',
+      restoreSidebar: 'Show the sidebar entry',
+      sectionSkinLabel: 'Current skin: ',
+      sectionSidebarLabel: 'Sidebar entry: ',
       empty: 'Reading the theme registry…',
       diagNote: 'The lines below are intentional diagnostics of the live skin state, '
         + 'not an error report; only lines starting with ⚠ mean the scenery is not working',
@@ -3261,6 +3741,33 @@ window.__ModuleLoader__.load({
       '.tg-badge{font-size:11px;padding:1px 7px;border-radius:999px;',
       'background:var(--dsw-alias-brand-primary);color:var(--dsw-alias-label-primary-foreground)}',
       '.tg-desc{font-size:12px;color:var(--dsw-alias-label-secondary);line-height:1.5}',
+      /* 菜单折叠卡的路径提示（卡面正文）：与 .tg-hint（页头）无关，这是卡内元素。 */
+      '.tg-path{font-size:12px;color:var(--dsw-alias-label-secondary);line-height:1.55}',
+      /* 菜单折叠卡的胶囊行容器：胶囊行（复用 .tg-mood-row 的排布）+ 路径提示上下排。 */
+      '.tg-menu-body{display:flex;flex-direction:column;gap:8px;align-items:stretch}',
+      /* ── the lightweight settings-section entry (form A, user-approved) ───────
+         设置弹窗里的轻量分节：报状态 + 一键跳转主区面板 + 折叠时给恢复按钮。
+         容器是弹窗内容列（宽度不由我们定），所以全部用自适应宽度 + 垂直节奏，
+         不放网格 —— 完整面板在弹窗里既会挤也没意义（方案 A 的结论）。
+         排版（用户返工 2026-09-27）：读数块（label 左值右）+ 主次分明的按钮组
+         （主按钮 = 品牌色整宽跳转，次按钮 = 描边恢复）。 */
+      '.tg-section{display:flex;flex-direction:column;gap:14px;padding:6px 2px 2px}',
+      '.tg-section-title{font-size:15px;font-weight:600}',
+      '.tg-section-hint{font-size:12px;color:var(--dsw-alias-label-secondary);line-height:1.65}',
+      '.tg-section-facts{display:flex;flex-direction:column;gap:8px;padding:10px 12px;'
+        + 'border:1px solid var(--dsw-alias-border-l3);border-radius:10px}',
+      '.tg-section-row{display:flex;align-items:center;justify-content:space-between;gap:12px;'
+        + 'font-size:12.5px;color:var(--dsw-alias-label-secondary)}',
+      '.tg-section-value{color:var(--dsw-alias-label-primary);font-weight:600;text-align:right}',
+      '.tg-section-actions{display:flex;flex-direction:column;gap:8px}',
+      '.tg-section-open{width:100%;padding:9px 14px;border:none;border-radius:10px;'
+        + 'background:var(--dsw-alias-brand-primary);color:var(--dsw-alias-label-primary-foreground);'
+        + 'font-size:13px;font-weight:600;cursor:pointer}',
+      '.tg-section-open:hover{filter:brightness(1.08)}',
+      '.tg-section-restore{width:100%;padding:9px 14px;border:1px solid var(--dsw-alias-border-l3);'
+        + 'border-radius:10px;background:transparent;color:var(--dsw-alias-label-primary);'
+        + 'font-size:12.5px;cursor:pointer}',
+      '.tg-section-restore:hover{background:var(--dsw-alias-interactive-bg-hover)}',
       '.tg-strip{display:flex;height:6px;border-radius:999px;overflow:hidden;border:.5px solid var(--dsw-alias-border-l3)}',
       '.tg-strip span{flex:1}',
       /* ── the PALETTE PICKER card (15 clickable colour buttons) ────────────────
@@ -3308,6 +3815,62 @@ window.__ModuleLoader__.load({
       'font-size:11px;line-height:1.3;background:var(--dsw-alias-bg-base);',
       'color:var(--dsw-alias-label-primary);border:.5px solid var(--dsw-alias-border-l3);',
       'box-shadow:0 2px 8px rgba(0,0,0,.18)}',
+      /* ── the PET-FAMILY card (宠物挂件 · 七只小伙伴) ────────────────────────
+         卡面放标题、状态徽标、当前宠物与道具的图案，再加一行 7 颗头像（`petPickerElement`）
+         —— description 只作 tooltip（与配色卡同一条"不渲染 desc"分支）。卡身是 div
+         （内含头像按钮，button 套 button 非法）：点卡身 = 开关挂件，点头像 = 换宠物。 */
+      '.tg-pet-card{justify-content:space-between}',
+      '.tg-pet-body{display:flex;flex-direction:column;gap:6px}',
+      '.tg-pet-art{display:flex;align-items:flex-end;gap:14px;padding:6px 2px 2px;min-height:48px}',
+      '.tg-pet-art svg{display:block}',
+      '.tg-petrow{display:flex;gap:6px;flex-wrap:wrap;padding:2px}',
+      '.tg-petswatch{display:inline-flex;align-items:center;justify-content:center;width:34px;height:34px;'
+        + 'padding:2px;border:none;border-radius:9px;cursor:pointer;background:var(--dsw-alias-bg-layer-2)}',
+      '.tg-petswatch:hover{background:var(--dsw-alias-bg-layer-3)}',
+      '.tg-petswatch:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}',
+      '.tg-petswatch[aria-pressed="true"]{background:var(--dsw-alias-state-business-primary);box-shadow:0 0 0 2px var(--dsw-alias-state-business-primary) inset}',
+      '.tg-petswatch svg{display:block}',
+      /* 挂件"关着"的徽标：中性色，与亮着的"已应用"/"已开启"品牌徽标区分开。 */
+      '.tg-badge-off{background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-tertiary)}',
+      /* ── 心情问候卡：胶囊开关 + 三组设置 chips ───────────────────────────
+         卡身是 div（内含按钮），点卡身与点开关等效（toggleMood）；
+         chip 点亮态走品牌 token，与头像选择行同一视觉语言。 */
+      '.tg-mood-body{display:flex;flex-direction:column;gap:8px;padding:4px 2px 2px}',
+      '.tg-mood-row{display:flex;align-items:center;gap:6px;flex-wrap:wrap}',
+      '.tg-mood-row-label{flex:none;font-size:11px;color:var(--dsw-alias-label-tertiary)}',
+      /* ── 心情问候卡（用户二轮返工重设计）：分段选择器（segmented）替代散排 pill——
+         一组内相连、共享圆角、选中段"浮起"，视觉整齐得多；区域四档放不下一行，用 2×2 网格。 */
+      '.tg-mood-body{display:flex;flex-direction:column;gap:10px;padding:4px 2px 2px}',
+      '.tg-mood-row{display:flex;align-items:center;gap:8px}',
+      '.tg-mood-row-label{flex:none;width:26px;font-size:11px;color:var(--dsw-alias-label-tertiary)}',
+      /* 胶囊开关（一轮返工的版本保留）：胶囊与文字分离，圆球滑块滑到端点。 */
+      '.tg-mood-switch{display:inline-flex;align-items:center;gap:8px;height:24px;border:none;'
+        + 'background:none;padding:0;cursor:pointer;font:inherit;font-size:12px;'
+        + 'color:var(--dsw-alias-label-secondary)}',
+      '.tg-mood-pill{position:relative;flex:none;width:40px;height:22px;border-radius:999px;'
+        + 'background:var(--dsw-alias-bg-layer-3);box-shadow:inset 0 0 0 1px var(--dsw-alias-border-l3);'
+        + 'transition:background .18s var(--ds-ease-in-out)}',
+      '.tg-mood-pill::after{content:"";position:absolute;top:2px;left:2px;width:18px;height:18px;'
+        + 'border-radius:50%;background:var(--dsw-alias-label-primary);'
+        + 'box-shadow:0 1px 3px rgba(0,0,0,.2);transition:transform .18s var(--ds-ease-in-out)}',
+      '.tg-mood-switch[aria-checked="true"] .tg-mood-pill{background:var(--dsw-alias-state-business-primary);'
+        + 'box-shadow:none}',
+      '.tg-mood-switch[aria-checked="true"] .tg-mood-pill::after{transform:translateX(18px);background:#fff}',
+      '.tg-mood-switch:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);'
+        + 'outline-offset:2px;border-radius:12px}',
+      /* 分段选择器：槽用 layer-3，选中段是浮起的"卡片底"小块 + 主文字色。 */
+      '.tg-mood-seg{flex:1;display:inline-flex;gap:2px;background:var(--dsw-alias-bg-layer-3);'
+        + 'border-radius:9px;padding:2px;box-sizing:border-box}',
+      '.tg-mood-zone{flex:1;display:grid;grid-template-columns:1fr 1fr;gap:2px;'
+        + 'background:var(--dsw-alias-bg-layer-3);border-radius:9px;padding:2px;box-sizing:border-box}',
+      '.tg-mood-chip{height:20px;padding:0 6px;border:none;border-radius:7px;background:none;'
+        + 'color:var(--dsw-alias-label-tertiary);font:inherit;font-size:11px;cursor:pointer;'
+        + 'white-space:nowrap;overflow:hidden;text-overflow:ellipsis}',
+      '.tg-mood-seg .tg-mood-chip{flex:1;min-width:0}',
+      '.tg-mood-chip:hover{color:var(--dsw-alias-label-secondary)}',
+      '.tg-mood-chip[aria-pressed="true"]{background:var(--dsw-alias-bg-base);'
+        + 'color:var(--dsw-alias-label-primary);box-shadow:0 1px 2px rgba(0,0,0,.12)}',
+      '.tg-mood-chip:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}',
     ].join('')
 
     /**
@@ -3323,6 +3886,9 @@ window.__ModuleLoader__.load({
         init: () => ({
           ids: [], labels: {}, descriptions: {}, swatches: {}, cardRows: {},
           scheme: '', selected: 'system', status: '', revision: -1,
+          petEnabled: false, petKind: 'ban-ban',
+          moodOn: true, moodSpeed: 'medium', moodDirection: 'ltr', moodZone: 'center',
+          menuCollapsed: false,
         }),
         actions: {
           sync: (draft, themes, selected, revision) => {
@@ -3386,6 +3952,49 @@ window.__ModuleLoader__.load({
            * @param id - the scheme id.
            */
           markScheme: (draft, id) => { draft.scheme = String(id) },
+          /**
+           * 记录宠物挂件的开与关，给挂件卡的徽标与 aria-pressed 用。
+           *
+           * 与 `markScheme` 同一条理由：挂件状态不是主题，混进主题列表会让计数口径失真，
+           * 所以单独放一个字段，由 `publish()` 从 localStorage 读出后写进来。
+           * @param draft - store draft。
+           * @param on - 挂件是否已开启。
+           */
+          markPet: (draft, on) => { draft.petEnabled = on === true },
+          /**
+           * 记住挂件当前是哪只宠物（头像选择行的点亮态与卡面图案都读它）。
+           *
+           * 与 `markPet` 同一条理由：宠物选择不是主题，单独一个字段，由 `publish()`
+           * 从 localStorage 读出后写进来。**测试桩的 action 表必须跟着长**（规则 8：
+           * 桩少一个 action，publish 就抛错、整个挂载被 guard 拦下）。
+           * @param draft - store 草稿。
+           * @param id - 宠物 id（PET_KINDS 之一）。
+           */
+          markPetKind: (draft, id) => { draft.petKind = String(id) },
+          /**
+           * 记录心情问候的开关与三组设置（速度/方向/区域），给第 14 张卡的
+           * 胶囊开关、chip 点亮态与 aria-pressed 用。
+           *
+           * 与 `markPet` 同一条理由：问候状态不是主题，单独字段，由 `publish()`
+           * 从 localStorage 读出后写进来。**测试桩的 action 表必须跟着长**（规则 8）。
+           * @param draft - store 草稿。
+           * @param state - `readMoodState()` 的消毒结果。
+           */
+          markMood: (draft, state) => {
+            draft.moodOn = state.on === true
+            draft.moodSpeed = String(state.speed)
+            draft.moodDirection = String(state.direction)
+            draft.moodZone = String(state.zone)
+          },
+          /**
+           * 记录菜单折叠的开关状态，给折叠卡的徽标与 aria-pressed 用。
+           *
+           * 与 markPet/markMood 同一条理由：折叠状态不是主题，单独字段，由 `publish()`
+           * 从 localStorage 读出后写进来。**测试桩的 action 表必须跟着长**（规则 8）。
+           * @param draft - store 草稿。
+           * @param on - 侧栏入口是否已折叠。
+           */
+          markMenuCollapse: (draft, on) => { draft.menuCollapsed = on === true },
         },
       })
     }
@@ -3465,25 +4074,197 @@ window.__ModuleLoader__.load({
       })
     }
 
+    /**
+     * 挂件卡面上的当前宠物与它的道具（静态装饰，markup 与运行时舞台同源 —— 都出自
+     * PET_KINDS 注册表，结构上不可能漂移）。
+     *
+     * 卡面在面板里由 jsx 渲染，HTML 经 React 的正规注入通道 dangerouslySetInnerHTML
+     * 进来：内容是插件自己的静态注册表字符串，没有任何用户输入，注入面为零。
+     * @param kindId - 当前宠物 id（store 里的 petKind）。
+     * @returns 卡面图案。
+     */
+    function petCardSceneHTML(kindId) {
+      const kind = petKindById(kindId)
+      // 卡面图案与舞台同源同比例：舞台显示尺寸（已含 PET_SCALE）再缩到 0.72。
+      // 道具缩 0.9 与舞台一致 —— 卡面是舞台的缩影，不是注册表的直译。
+      const scale = 0.72
+      const pet = `<svg viewBox="${kind.viewBox}" width="${Math.round(petDisplaySize(kind).w * scale)}"`
+        + ` height="${Math.round(petDisplaySize(kind).h * scale)}" aria-hidden="true">${kind.art.side}</svg>`
+      const prop = `<svg viewBox="${kind.propViewBox}" width="${Math.round(petPropDisplaySize(kind).w * 0.9)}"`
+        + ` height="${Math.round(petPropDisplaySize(kind).h * 0.9)}" aria-hidden="true">${kind.propArt}</svg>`
+      return pet + prop
+    }
+
+    /** 卡面图案的元素形态（排版交给 .tg-pet-art 的 flex）。 */
+    function petCardArt(kindId) {
+      return jsx('span', {
+        className: 'tg-pet-art',
+        dangerouslySetInnerHTML: { __html: petCardSceneHTML(kindId) },
+      })
+    }
+
+    /** 头像素描（选择行里那颗小圆头像）。 */
+    function petFaceHTML(kind, edge) {
+      return `<svg viewBox="${kind.faceViewBox}" width="${edge}" height="${edge}" aria-hidden="true">${kind.faceArt}</svg>`
+    }
+
+    /**
+     * 挂件卡上的头像选择行：每只宠物一颗头（7 个 button，绝不能套进 button 卡身 ——
+     * 所以挂件卡的卡身是 div，与配色卡同一条规则）。
+     * @param selectedKind - 当前宠物 id（点亮那一颗）。
+     * @param onPick - 点头像的回调（参数是宠物 id）。
+     * @returns 选择行元素。
+     */
+    function petPickerElement(selectedKind, onPick) {
+      return jsx('span', {
+        className: 'tg-petrow',
+        children: PET_KINDS.map((kind, index) => jsx('button', {
+          type: 'button',
+          className: 'tg-petswatch',
+          'aria-pressed': kind.id === selectedKind,
+          title: `${kind.home} · ${kind.species}`,
+          // 与配色格同一条规矩：必须拦冒泡，否则"点了头像"先执行、随后被卡身的
+          // 开关处理器覆盖回去（配色卡踩过的坑，见 schemeSwatch 的注释）。
+          onClick: (event) => {
+            if (event !== undefined && typeof event.stopPropagation === 'function') event.stopPropagation()
+            onPick(kind.id)
+          },
+          dangerouslySetInnerHTML: { __html: petFaceHTML(kind, 26) },
+        }, index)),
+      })
+    }
+
+    /** 方向的两档文案（卡面 chips 与自检行共用）。 */
+    const MOOD_DIR_LABELS = { ltr: '自左至右', rtl: '自右至左' }
+
+    /**
+     * 心情问候卡的卡面控件：胶囊开关（role="switch"）+ 三组设置 chips。
+     *
+     * ── 为什么点什么都必须拦冒泡 ─────────────────────────────────────────────
+     *
+     * 卡身自己的 onClick = 开关问候；不拦冒泡的话，"点慢速"会先写速度、随后被
+     * 卡身的开关处理器覆盖成一次 toggle —— 配色卡色格踩过的同一个坑
+     * （schemeSwatch 注释里的原话）。事件参数要容错：jsx 桩调用处理器时不给事件。
+     * @param props - `{ mood, onToggleMood, onSetMood, t }`：消毒后的状态、开关回调、
+     *                设置回调、字典（取 已开启/已关闭 文案）。
+     * @returns 卡面控件元素。
+     */
+    function moodControlsElement({ mood, onToggleMood, onSetMood, dict }) {
+      const swallowEvent = (event) => {
+        if (event !== undefined && typeof event.stopPropagation === 'function') event.stopPropagation()
+      }
+      const chip = (label, pressed, title, onPick) => jsx('button', {
+        type: 'button',
+        className: 'tg-mood-chip',
+        'aria-pressed': pressed,
+        title,
+        onClick: (event) => { swallowEvent(event); onPick() },
+        children: label,
+      })
+      return jsxs('div', {
+        className: 'tg-mood-body',
+        children: [
+          jsxs('div', {
+            className: 'tg-mood-row',
+            children: [
+              // 胶囊（圆球滑块）+ 状态文字分离 —— 用户返工：去掉「标题栏问候」、
+              // 胶囊两端全半圆、开/关时圆球滑到一侧顶端。
+              jsxs('button', {
+                type: 'button',
+                className: 'tg-mood-switch',
+                role: 'switch',
+                'aria-checked': mood.on,
+                title: '开或关标题栏的滚动问候（与点卡身等效）',
+                onClick: (event) => { swallowEvent(event); onToggleMood() },
+                children: [
+                  jsx('span', { className: 'tg-mood-pill', 'aria-hidden': 'true' }),
+                  jsx('span', { className: 'tg-mood-state', children: mood.on ? dict('petOn') : dict('petOff') }),
+                ],
+              }),
+            ],
+          }),
+          jsx('div', {
+            className: 'tg-mood-row',
+            children: [
+              jsx('span', { className: 'tg-mood-row-label', children: '速度' }),
+              jsx('span', {
+                className: 'tg-mood-seg',
+                children: Object.keys(MOOD_SPEEDS).map((id) => chip(
+                  MOOD_SPEED_LABELS[id],
+                  mood.speed === id,
+                  `滚动速度：${MOOD_SPEED_LABELS[id]}`,
+                  () => { onSetMood({ speed: id }) },
+                )),
+              }),
+            ],
+          }),
+          jsx('div', {
+            className: 'tg-mood-row',
+            children: [
+              jsx('span', { className: 'tg-mood-row-label', children: '方向' }),
+              jsx('span', {
+                className: 'tg-mood-seg',
+                children: Object.keys(MOOD_DIR_LABELS).map((id) => chip(
+                  MOOD_DIR_LABELS[id],
+                  mood.direction === id,
+                  `滚动方向：${MOOD_DIR_LABELS[id]}`,
+                  () => { onSetMood({ direction: id }) },
+                )),
+              }),
+            ],
+          }),
+          jsx('div', {
+            className: 'tg-mood-row',
+            children: [
+              jsx('span', { className: 'tg-mood-row-label', children: '区域' }),
+              // 四档一行放不下（卡片 ~217px）：2×2 网格，选中态与分段选择器同一语言。
+              jsx('span', {
+                className: 'tg-mood-zone',
+                children: Object.keys(MOOD_ZONE_GEOMETRY).map((id) => chip(
+                  MOOD_ZONE_LABELS[id],
+                  mood.zone === id,
+                  `位置区域：${MOOD_ZONE_LABELS[id]}`,
+                  () => { onSetMood({ zone: id }) },
+                )),
+              }),
+            ],
+          }),
+        ],
+      })
+    }
+
     /**
      * Render one card.
      *
-     * Three layouts share the card: the default token strip, the palette picker (a
-     * theme that declares `card.rows`), and — for the picker — no description body,
-     * because the swatches already fill it. The description still becomes the tooltip
-     * (`title`), which is what the schema says the field is for.
+     * Four layouts share the card: the default token strip, the palette picker (a
+     * theme that declares `card.rows`), the pet-widget toggle card, and — for the
+     * picker and the widget — no description body. The description still becomes
+     * the tooltip (`title`), which is what the schema says the field is for.
+     *
+     * The pet-widget card is NOT a theme: clicking it never touches the theme
+     * service, it toggles the widget (`onTogglePet`), and its badge shows the
+     * widget's on/off state instead of "applied". Like the picker flag, the
+     * widget flag is read off the DATA (the id table), never off a rendered
+     * element — the jsx stub returns null while React returns elements, so an
+     * element-identity test silently takes the wrong branch in every test.
      *
      * A picker card is a `div`, not a `button`: it CONTAINS 15 buttons, and nesting
      * buttons inside a button is invalid markup that browsers silently re-parent.
+     * The pet-family card is a `div` for the same reason (7 portrait buttons).
      * @param props - id, label, description, swatches, rows, selected, applied,
-     *                selectedScheme, onSelect, onPickScheme.
+     *                selectedScheme, onSelect, onPickScheme, onTogglePet, petEnabled,
+     *                petKind, onPickPet, t.
      * @returns the card element.
      */
     function ThemeCard(props) {
       const {
         id, label, description, swatches, rows, selected, applied,
-        selectedScheme, onSelect, onPickScheme, t,
+        selectedScheme, onSelect, onPickScheme, onTogglePet, petEnabled, petKind, onPickPet,
+        mood, onToggleMood, onSetMood, menuCollapsed, onToggleMenuCollapse, t,
       } = props
+      const isWidget = id === PET_WIDGET.id
+      const isMood = id === MOOD_WIDGET.id
+      const isMenuCollapse = id === MENU_COLLAPSE_WIDGET.id
       // ── WHY THE FLAG, AND NOT `blocks !== null` ──────────────────────────────
       //
       // Whether this card is a picker has to be read off the DATA, not off the rendered
@@ -3500,24 +4281,93 @@ window.__ModuleLoader__.load({
       // the whole panel — the silent-failure shape this project keeps paying for.
       const shape = cardRowShape({ card: { rows } }, PALETTE_SCHEMES)
       const hasPicker = shape !== undefined
+      // 挂件/问候/折叠卡的徽标永远在场（它就是"开关状态"的读数）；其余卡保持原样：选中才亮。
+      const badgeText = (isWidget || isMood)
+        ? ((isWidget ? petEnabled === true : mood?.on === true) ? t('petOn') : t('petOff'))
+        : isMenuCollapse
+          ? (menuCollapsed === true ? t('menuCollapsed') : t('menuShown'))
+          : applied
       const head = jsxs('div', {
         className: 'tg-card-top',
         children: [
           jsx('span', { className: 'tg-name', children: label || id }),
-          selected ? jsx('span', { className: 'tg-badge', children: applied }) : null,
+          (selected || isWidget || isMood || isMenuCollapse)
+            ? jsx('span', {
+              className: (isWidget && petEnabled !== true) || (isMood && mood?.on !== true)
+                  || (isMenuCollapse && menuCollapsed !== true)
+                ? 'tg-badge tg-badge-off'
+                : 'tg-badge',
+              children: badgeText,
+            })
+            : null,
         ],
       })
       const body = hasPicker
         ? cardPickerElement(shape, selectedScheme, onPickScheme, PALETTE_SCHEMES)
-        : swatches.length > 0
-          ? jsx('span', {
-            className: 'tg-strip',
-            children: swatches.map((colour, index) => jsx('span', { style: { background: colour } }, index)),
+        : isWidget
+          ? jsxs('div', {
+            className: 'tg-pet-body',
+            children: [
+              petCardArt(petKind || DEFAULT_PET_KIND.id),
+              petPickerElement(petKind || DEFAULT_PET_KIND.id, onPickPet),
+            ],
           })
-          : null
-      // The picker fills the card, so it prints no body copy; `description` stays the
-      // tooltip, which is what the schema says the field is for.
-      const desc = !hasPicker && description
+          : isMood
+            ? moodControlsElement({
+              mood: {
+                on: mood?.on === true,
+                speed: mood?.speed ?? 'medium',
+                direction: mood?.direction ?? 'ltr',
+                zone: mood?.zone ?? 'center',
+              },
+              onToggleMood,
+              onSetMood,
+              dict: t,
+            })
+            : isMenuCollapse
+              ? jsxs('div', {
+                className: 'tg-menu-body',
+                children: [
+                  // 胶囊滑块（用户 2026-09-27 加）：开关状态一眼可见，label 说明它管什么。
+                  // 样式/结构与心情卡的胶囊同款（类名有意复用 —— 视觉绝对一致，零新 CSS）；
+                  // 点击拦冒泡 —— 卡身也响应点击，不拦会翻转两次。
+                  jsxs('div', {
+                    className: 'tg-mood-row',
+                    children: [
+                      jsx('span', { className: 'tg-mood-row-label', children: t('menuPillLabel') }),
+                      jsxs('button', {
+                        type: 'button',
+                        className: 'tg-mood-switch',
+                        role: 'switch',
+                        'aria-checked': menuCollapsed === true,
+                        title: '开=收起侧栏的「主题皮肤」入口；关=恢复显示（与点卡身等效）',
+                        onClick: (event) => {
+                          if (event !== undefined && typeof event.stopPropagation === 'function') event.stopPropagation()
+                          onToggleMenuCollapse()
+                        },
+                        children: [
+                          jsx('span', { className: 'tg-mood-pill', 'aria-hidden': 'true' }),
+                          jsx('span', {
+                            className: 'tg-mood-state',
+                            children: menuCollapsed === true ? t('menuCollapsed') : t('menuShown'),
+                          }),
+                        ],
+                      }),
+                    ],
+                  }),
+                  jsx('span', { className: 'tg-path', children: t('menuHint') }),
+                ],
+              })
+              : swatches.length > 0
+                ? jsx('span', {
+                  className: 'tg-strip',
+                  children: swatches.map((colour, index) => jsx('span', { style: { background: colour } }, index)),
+                })
+                : null
+      // The picker fills the card and the widget/mood/menu cards draw their own controls,
+      // so none of them prints body copy; `description` stays the tooltip, which is
+      // what the schema says the field is for.
+      const desc = !hasPicker && !isWidget && !isMood && !isMenuCollapse && description
         ? jsx('span', { className: 'tg-desc', children: description })
         : null
       if (hasPicker) {
@@ -3534,6 +4384,43 @@ window.__ModuleLoader__.load({
           children: [head, body, desc],
         })
       }
+      if (isWidget) {
+        // 挂件卡是 div 而不是 button：卡里现在装着 7 颗头像按钮，button 套 button 是
+        // 非法标记（浏览器会静默重排），与配色卡同一条规则。点卡身 = 开关挂件，
+        // **绝不**调用 setTheme —— 这是它与任何皮肤同时开启的前提；点头像 = 换宠物
+        // （selectPetWidget，见挂载体）。开关状态由徽标文字（已开启/已关闭）表达，
+        // "选中的是哪只"由头像的 aria-pressed 表达。
+        return jsxs('div', {
+          className: 'tg-card tg-pet-card',
+          onClick: () => { onTogglePet() },
+          title: description || label,
+          children: [head, body, desc],
+        })
+      }
+      if (isMood) {
+        // 心情问候卡与挂件卡同一条规矩：div 卡身（内含胶囊开关与 chips 按钮）、
+        // 点卡身 = 开关问候（toggleMood），**绝不**调用 setTheme；开关状态由徽标与
+        // 胶囊开关的 aria-checked 表达，三组设置的点亮态由各 chip 的 aria-pressed 表达。
+        return jsxs('div', {
+          className: 'tg-card tg-mood-card',
+          onClick: () => { onToggleMood() },
+          title: description || label,
+          children: [head, body, desc],
+        })
+      }
+      if (isMenuCollapse) {
+        // 菜单折叠卡：卡身是 **div**（与挂件卡/问候卡同构）——卡内现在装着胶囊按钮
+        // （button 套 button 非法，浏览器会静默重排）。点卡身 = 开关折叠（保留），
+        // 开关语义由**胶囊的 role="switch" + aria-checked** 与徽标表达；**绝不**调用
+        // setTheme —— 折叠只改侧栏入口显隐、零主题写入。卡面正文是路径提示 +
+        // 胶囊行（用户要求把找回路径写在卡上、胶囊让状态一眼可见）。
+        return jsxs('div', {
+          className: 'tg-card tg-menu-card',
+          onClick: () => { onToggleMenuCollapse() },
+          title: description || label,
+          children: [head, body, desc],
+        })
+      }
       return jsxs('button', {
         type: 'button',
         className: 'tg-card',
@@ -6049,7 +6936,7 @@ window.__ModuleLoader__.load({
         // (「切到内置主题后装饰层保留」) — do not "fix" it by clearing the layer here.
         removeAllAmbientSeats()
         if (record) noteAmbientAttempt({ kind, column: true, band: '无装饰' })
-        ambientReport = { found: true, kind: '(none)', note: '该主题无装饰' }
+        ambientReport = { found: true, kind: '(none)', note: '该主题无装饰', css: ambientStylesheetReady() }
         return
       }
 
@@ -6569,100 +7456,2813 @@ window.__ModuleLoader__.load({
       })
     }
 
-    /**
-     * Report whether the accent token layer actually reached the theme snapshot.
-     *
-     * ── WHY THIS READING IS NEEDED ───────────────────────────────────────────
-     *
-     * `syncAccent` stacks three tokens (`button-ghost-active-fill` / `-border` / `-hover`) with
-     * `ctx.theme.overrideTokens`. Whether that layer works had **never been verified**, and one
-     * earlier attempt to verify it used the wrong evidence: the active workspace FOLDER icon
-     * turns the accent colour, which was taken as proof — but that icon is painted by the skin's
-     * own `--dsw-alias-state-business-primary` token and has nothing to do with the layer.
-     *
-     * The service makes this checkable without any guesswork: `composeActive` folds every
-     * override layer into `snapshot.active.tokens` before publishing, so the composed value is
-     * readable straight off `getTheme()`.
+    /* ═══════════════════ 宠物挂件运行时（宠物家族 × 7）═══════════════════
      *
-     * ── WHAT CAN AND CANNOT PROVE IT ─────────────────────────────────────────
+     * 与侧栏素材（ambient）完全独立的第二层装饰：画在自己的固定层里，锚定**对话输入框**
+     * （阅读态已验证的 composer 定位法），地面线 = 输入框下缘。规则照抄ambient 的教训：
      *
-     * The composed VALUE is the only channel that carries information, and only when it differs
-     * from what the skin declares for that same token:
+     *  · 幂等判据（廉价指纹）在**一切 DOM 写入之前**（规则 3）；
+     *  · 移动循环复用工厂级单帧助手 `step()`（本文件 requestAnimationFrame 只此一处），
+     *    且只在跑动中自续，停下即断 —— 没有任何常驻定时器（闲聊是单个可取消句柄，见后）；
+     *  · 脚印 / 气泡都有**数量上限**与超时回收，绝不无界增长；
+     *  · 不写主题服务：开关、宠物、名字、位置全部存 localStorage，绝不碰 preference；
+     *  · 容器 pointer-events:none，只有宠物与它的道具可交互 —— 绝不挡输入框的点击。
      *
-     *  • both bundled skins already ship `button-ghost-active-*` in their own palettes, AND the
-     *    palette layer supplies them too — so the token COUNT is 67 either way. An earlier
-     *    comment here claimed a count that "does not move" disproves the layer; for these skins
-     *    it cannot move, so the claim was wrong and the count is reported for context only;
-     *  • 梦海游鱼 declares `#2B74B5` for that token but its accent is `#FFD166`, so reading back
-     *    `#FFD166` proves the accent layer composed OVER the palette — the palette alone cannot
-     *    produce it;
-     *  • 山青婷彩's accent is `#E88BB0` and it declares `#E88BB0` for the same token, so its
-     *    reading is identical whether or not the layer is there. That is a property of the SKIN,
-     *    not of the layer, and the verdict below says so instead of implying the reading proved
-     *    something.
+     * ── 二期（宠物家族）───────────────────────────────────────────────────────
      *
-     * The verdict is therefore computed, never asserted: it compares the composed value with the
-     * skin's declared value and with the accent the layer was built from.
-     * @returns the reading, as one segment of the panel line.
+     * "这只宠物长什么样、跑多快、说什么话"全部在下面的 PET_KINDS 注册表里，框架零硬编码：
+     * 美术常量只存 <svg> 内部内容（不含标签本身），由 petSvg/petPropSvg 统一包裹 ——
+     * 舞台、面板卡面、预览页三处共用同一份字符串，结构上不可能漂移。
+     * 活性机制（闲聊 / 打字回头 / 生成中加油）见本区后半（petNoteInteraction 起）。
      */
-    function describeAccentLayer() {
-      try {
-        const theme = ctx?.theme
-        if (theme === undefined) return '激活层[无 theme 服务]'
-        const snapshot = theme.getTheme()
-        const active = snapshot?.active
-        const tokens = active?.tokens ?? {}
-        const TOKEN = '--dsw-alias-button-ghost-active-border'
-        const composed = tokens[TOKEN]
-        const definition = typeof active?.id === 'string' ? bundledTheme(active.id) : undefined
-        const declared = declaredToken(definition, TOKEN)
-        const accent = definition?.accent
-        const layers = snapshot?.overrides === undefined
-          ? '(服务未暴露)'
-          : String(snapshot.overrides.size ?? snapshot.overrides.length ?? '?')
-        // Computed, not assumed — see the note above. `不可分辨` is a real answer: it says this
-        // skin's own value coincides with its accent, so this reading proves nothing either way.
-        const verdict = accent === undefined
-          ? '非本包皮肤(无法判断)'
-          : accent === declared
-            ? '不可分辨(强调色=皮肤自备值)'
-            : composed === accent
-              ? '生效(强调色压过自备值)'
-              : composed === declared
-                ? '未生效(仍是自备值)'
-                : `未知(既非强调色也非自备值)`
-        return `激活层[id=${active?.id ?? '?'}`
-          + ` 层数=${layers}`
-          + ` token数=${Object.keys(tokens).length}(自备同名令牌，不构成判据)`
-          + ` ${TOKEN.replace('--dsw-alias-', '')}=${composed === undefined ? '(缺失)' : String(composed)}`
-          + ` 自备=${declared === undefined ? '(无)' : String(declared)}`
-          + ` 强调色=${accent ?? '(无)'}`
-          + ` 判据=${verdict}]`
-      } catch (error) {
-        return `激活层[读取失败: ${String(error && error.message ? error.message : error)}]`
-      }
-    }
 
+    /** 挂件舞台的 id；也是清扫跨热重载残留节点的依据。 */
+    const PET_STAGE_ID = 'dsh-theme-pet'
+
+    /** 跨物种一致的安全预算：脚印枚数 / 脚印寿命 / 同场气泡数。 */
+    const PET_TRAIL_MAX = 14
+    const PET_TRAIL_FADE_MS = 3500
+    const PET_BUBBLE_MAX = 3
+    /** hop 步态：一跳的水平长度与最高抬升（px）。 */
+    const PET_HOP_LEN_PX = 34
+    const PET_HOP_LIFT_PX = 9
     /**
-     * Render the main-column gallery page.
+     * 视口回退时的地面线抬高量（px）。锚点（输入框）在屏上时地面线贴它的下缘；
+     * 主题面板页等 composer 隐藏的场合走视口回退，宠物直接贴窗口底缘会被裁掉一截
+     * （实机验收反馈）—— 抬高一段让整只宠物完整落地。
+     */
+    const PET_FALLBACK_GROUND_GAP = 48
+
+    /* ── 美术常量（<svg> 内部内容；斑斑是一期资产拆分，形状与色值零改动）────── */
+
+    const PET_BAN_SIDE = ''
+      + '<path class="dsh-pet-tail" d="M15 36 Q4 31 6.5 21" stroke="#A9744F" stroke-width="5" fill="none" stroke-linecap="round" style="transform-origin:14px 36px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="19" y="41" width="7" height="13" rx="3" fill="#C79A6B" style="transform-origin:22px 42px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="41" y="41" width="7" height="13" rx="3" fill="#C79A6B" style="transform-origin:44px 42px"/>'
+      + '<ellipse cx="32" cy="35" rx="17.5" ry="13.5" fill="#F5E7CE"/>'
+      + '<ellipse cx="25" cy="31.5" rx="7" ry="5" fill="#C79A6B" opacity=".9"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="25" y="42" width="7" height="13" rx="3" fill="#F5E7CE" style="transform-origin:28px 43px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="37" y="42" width="7" height="13" rx="3" fill="#FBF3E4" style="transform-origin:40px 43px"/>'
+      + '<circle cx="46" cy="18" r="12.5" fill="#F5E7CE"/>'
+      + '<circle cx="51.5" cy="9.5" r="5.2" fill="#C79A6B"/>'
+      + '<ellipse cx="40" cy="10.5" rx="6" ry="8.6" fill="#A9744F" transform="rotate(-20 40 10.5)"/>'
+      + '<ellipse cx="55" cy="22.5" rx="6.2" ry="5" fill="#FBF3E4"/>'
+      + '<circle cx="58.6" cy="20.6" r="2.2" fill="#4A372F"/>'
+      + '<circle cx="49" cy="16" r="1.9" fill="#3B2B23" class="dsh-pet-eye"/>'
+      + '<path d="M54.5 27 q2.2 2 4.4 .4" stroke="#4A372F" stroke-width="1.2" fill="none" stroke-linecap="round"/>'
+
+    const PET_BAN_FRONT = ''
+      + '<path d="M50 40 q7 -3 6 -9" stroke="#A9744F" stroke-width="4.6" fill="none" stroke-linecap="round"/>'
+      + '<ellipse cx="24" cy="12" rx="5.6" ry="9" fill="#A9744F" transform="rotate(-17 24 12)"/>'
+      + '<ellipse cx="40" cy="12" rx="5.6" ry="9" fill="#A9744F" transform="rotate(17 40 12)"/>'
+      + '<circle cx="32" cy="19" r="13" fill="#F5E7CE"/>'
+      + '<circle cx="38.5" cy="10.5" r="5" fill="#C79A6B"/>'
+      + '<circle cx="27" cy="17.5" r="1.9" fill="#3B2B23" class="dsh-pet-eye"/>'
+      + '<circle cx="37" cy="17.5" r="1.9" fill="#3B2B23" class="dsh-pet-eye"/>'
+      + '<ellipse cx="32" cy="24.5" rx="7" ry="5.4" fill="#FBF3E4"/>'
+      + '<circle cx="32" cy="22.4" r="2.2" fill="#4A372F"/>'
+      + '<ellipse cx="32" cy="28.4" rx="2.9" ry="2.4" fill="#7C4A3A"/>'
+      + '<ellipse cx="32" cy="41.5" rx="14" ry="10.5" fill="#F5E7CE"/>'
+      + '<ellipse cx="32" cy="44" rx="8" ry="6.2" fill="#FBF3E4"/>'
+      + '<ellipse cx="22.5" cy="38" rx="4.6" ry="3.6" fill="#C79A6B" opacity=".9"/>'
+      + '<ellipse cx="25" cy="51" rx="4.2" ry="3.1" fill="#FBF3E4"/>'
+      + '<ellipse cx="39" cy="51" rx="4.2" ry="3.1" fill="#FBF3E4"/>'
+
+    const PET_BAN_PROP = ''
+      + '<circle cx="13" cy="12" r="9.5" fill="#E06A4E"/>'
+      + '<path d="M5 8.5 Q13 4 21 8.5" stroke="#B84A33" stroke-width="1.6" fill="none" stroke-linecap="round"/>'
+      + '<path d="M4.5 14 Q13 10 21.5 14" stroke="#B84A33" stroke-width="1.6" fill="none" stroke-linecap="round"/>'
+      + '<path d="M8 18.6 Q13 15 18 18.6" stroke="#B84A33" stroke-width="1.4" fill="none" stroke-linecap="round"/>'
+      + '<path d="M21.6 11 q5 1.4 3.8 6.4" stroke="#B84A33" stroke-width="1.5" fill="none" stroke-linecap="round"/>'
+      + '<ellipse cx="9.6" cy="7.4" rx="2.6" ry="1.5" fill="#FFFFFF" opacity=".3" transform="rotate(-24 9.6 7.4)"/>'
+
+    const PET_BAN_FACE = ''
+      + '<ellipse cx="8.5" cy="7.5" rx="3.4" ry="5" fill="#A9744F" transform="rotate(-18 8.5 7.5)"/>'
+      + '<ellipse cx="19.5" cy="7.5" rx="3.4" ry="5" fill="#A9744F" transform="rotate(18 19.5 7.5)"/>'
+      + '<circle cx="14" cy="15.5" r="9.6" fill="#F5E7CE"/>'
+      + '<circle cx="17.5" cy="9.6" r="3.6" fill="#C79A6B"/>'
+      + '<circle cx="10.4" cy="14.5" r="1.5" fill="#3B2B23" class="dsh-pet-eye"/>'
+      + '<circle cx="17.6" cy="14.5" r="1.5" fill="#3B2B23" class="dsh-pet-eye"/>'
+      + '<ellipse cx="14" cy="19" rx="4.6" ry="3.4" fill="#FBF3E4"/>'
+      + '<circle cx="14" cy="17.8" r="1.6" fill="#4A372F"/>'
+      + '<path d="M12.6 21.4 q1.4 1.2 2.8 0" stroke="#4A372F" stroke-width="1" fill="none" stroke-linecap="round"/>'
+
+    const PET_BAN_TRAIL = ''
+      + '<g fill="#8F969C"><ellipse cx="6" cy="7.6" rx="3.1" ry="2.5"/>'
+      + '<circle cx="2.7" cy="3.7" r="1.35"/><circle cx="5" cy="2.3" r="1.35"/>'
+      + '<circle cx="7.3" cy="2.3" r="1.35"/><circle cx="9.5" cy="3.8" r="1.35"/></g>'
+
+    const PET_JU_SIDE = ''
+      + '<path class="dsh-pet-tail" d="M14 36 Q2 28 7 13" stroke="#F2A65A" stroke-width="5" fill="none" stroke-linecap="round" style="transform-origin:14px 36px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="18" y="40" width="7" height="12" rx="3" fill="#E0A060" style="transform-origin:21px 41px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="40" y="40" width="7" height="12" rx="3" fill="#F2A65A" style="transform-origin:43px 41px"/>'
+      + '<ellipse cx="29" cy="36" rx="17" ry="12.5" fill="#F2A65A"/>'
+      + '<path d="M17 34 q7 -9 15 -9" stroke="#D98032" stroke-width="2.2" fill="none" stroke-linecap="round"/>'
+      + '<path d="M26 28 q7 -7 14 -6" stroke="#D98032" stroke-width="2.2" fill="none" stroke-linecap="round"/>'
+      + '<path d="M35 27 q6 -5 11 -2" stroke="#D98032" stroke-width="2.2" fill="none" stroke-linecap="round"/>'
+      + '<ellipse cx="40" cy="39" rx="6.5" ry="5" fill="#FBE8CC"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="24" y="41" width="7" height="11" rx="3" fill="#F2A65A" style="transform-origin:27px 42px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="35" y="41" width="7" height="11" rx="3" fill="#F2A65A" style="transform-origin:38px 42px"/>'
+      + '<ellipse cx="27.5" cy="51.4" rx="3" ry="1.8" fill="#FBE8CC"/>'
+      + '<ellipse cx="38.5" cy="51.4" rx="3" ry="1.8" fill="#FBE8CC"/>'
+      + '<circle cx="45" cy="19" r="11" fill="#F2A65A"/>'
+      + '<path d="M36 13 L33.5 4 L43.5 8 Z" fill="#F2A65A"/>'
+      + '<path d="M37.4 11.6 L36.2 6.6 L41.4 9 Z" fill="#E79B72"/>'
+      // 后耳：两只耳尖对称朝外上，基边两点都落在头圆上（实机验收"一个耳朵位置
+      // 不对"——旧后耳的基点浮在头缘外 4.6 单位，看起来悬空长错了地方）。
+      + '<path d="M48.5 9 L55.5 3.5 L54.5 12 Z" fill="#F2A65A"/>'
+      + '<path d="M50.3 9.6 L54.4 5.6 L53.9 10.7 Z" fill="#E79B72"/>'
+      + '<path d="M42 8.5 l1.6 3.6" stroke="#D98032" stroke-width="1.6" fill="none" stroke-linecap="round"/>'
+      + '<path d="M46 8 l.6 3.8" stroke="#D98032" stroke-width="1.6" fill="none" stroke-linecap="round"/>'
+      + '<path d="M49.6 8.8 l-.6 3.4" stroke="#D98032" stroke-width="1.6" fill="none" stroke-linecap="round"/>'
+      + '<circle cx="49.5" cy="16.5" r="1.9" fill="#3F3A36" class="dsh-pet-eye"/>'
+      // 嘴：小鼻三角贴脸前缘 + 从鼻下勾回的嘴弧 + 脸侧两根短须，与正面像同款
+      // （实机验收"嘴巴像是鸟嘴"——旧版是一个凸出脸缘的实心三角，读成喙）。
+      + '<path d="M54.8 19.9 l2.5 .9 l-1.9 1.9 z" fill="#C96F5E"/>'
+      + '<path d="M56.4 23.2 q-1.5 1.5 -3.1 .8" stroke="#B98A5F" stroke-width="1" fill="none" stroke-linecap="round"/>'
+      + '<path d="M51.6 20.6 l5.3 -1.1 M52.1 22.7 l5.3 .5" stroke="#B98A5F" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+      + '<path d="M18 27 Q26 20.5 36 19" stroke="#F8C48C" stroke-width="2" fill="none" stroke-linecap="round" opacity=".8"/>'
+
+    const PET_JU_FRONT = ''
+      + '<path d="M45 46 q9 -2 8 -9" stroke="#F2A65A" stroke-width="4.6" fill="none" stroke-linecap="round"/>'
+      + '<path d="M21 10 L18.5 1.5 L27.5 5.5 Z" fill="#F2A65A"/>'
+      + '<path d="M22 8.6 L20.6 4.2 L25.8 6.4 Z" fill="#E79B72"/>'
+      + '<path d="M41 10 L43.5 1.5 L34.5 5.5 Z" fill="#F2A65A"/>'
+      + '<path d="M40 8.6 L41.4 4.2 L36.2 6.4 Z" fill="#E79B72"/>'
+      + '<ellipse cx="31" cy="42" rx="13.5" ry="9.5" fill="#F2A65A"/>'
+      + '<ellipse cx="31" cy="43" rx="8" ry="6.5" fill="#FBE8CC"/>'
+      + '<path d="M20 40 q-2 4 1 7" stroke="#D98032" stroke-width="1.8" fill="none" stroke-linecap="round"/>'
+      + '<path d="M42 40 q2 4 -1 7" stroke="#D98032" stroke-width="1.8" fill="none" stroke-linecap="round"/>'
+      + '<ellipse cx="25" cy="50.6" rx="3.4" ry="2.4" fill="#F2A65A"/>'
+      + '<ellipse cx="37" cy="50.6" rx="3.4" ry="2.4" fill="#F2A65A"/>'
+      + '<circle cx="31" cy="17" r="12" fill="#F2A65A"/>'
+      + '<path d="M27 6.5 l1.2 3.2" stroke="#D98032" stroke-width="1.5" fill="none" stroke-linecap="round"/>'
+      + '<path d="M31 5.8 l.4 3.4" stroke="#D98032" stroke-width="1.5" fill="none" stroke-linecap="round"/>'
+      + '<path d="M35 6.5 l-.8 3.2" stroke="#D98032" stroke-width="1.5" fill="none" stroke-linecap="round"/>'
+      + '<circle cx="26" cy="16" r="2" fill="#3F3A36" class="dsh-pet-eye"/>'
+      + '<circle cx="36" cy="16" r="2" fill="#3F3A36" class="dsh-pet-eye"/>'
+      + '<path d="M29.8 20 l2.4 0 l-1.2 1.8 z" fill="#C96F5E"/>'
+      + '<path d="M31 21.8 q-1.6 2 -3.4 1" stroke="#B98A5F" stroke-width="1" fill="none" stroke-linecap="round"/>'
+      + '<path d="M31 21.8 q1.6 2 3.4 1" stroke="#B98A5F" stroke-width="1" fill="none" stroke-linecap="round"/>'
+      + '<path d="M20 18 l-6 -1.6 M20 20.5 l-6 .4 M42 18 l6 -1.6 M42 20.5 l6 .4" stroke="#B98A5F" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+
+    const PET_JU_PROP = ''
+      + '<path d="M17 9 l5 -3.5 l-1.4 3.5 l1.4 3.5 z" fill="#D99A3F"/>'
+      + '<ellipse cx="10" cy="9" rx="8" ry="4" fill="#E8B15C"/>'
+      + '<path d="M7 6.4 q1 2.6 0 5.2" stroke="#D99A3F" stroke-width="1.1" fill="none" stroke-linecap="round"/>'
+      + '<path d="M11 6 q1 2.8 0 5.6" stroke="#D99A3F" stroke-width="1.1" fill="none" stroke-linecap="round"/>'
+      + '<circle cx="4.6" cy="8.2" r="1" fill="#5B4632"/>'
+
+    const PET_JU_FACE = ''
+      + '<path d="M8 9 L5.5 2.5 L13 5.5 Z" fill="#F2A65A"/>'
+      + '<path d="M8.6 7.9 L7.3 4.5 L11.6 6.2 Z" fill="#E79B72"/>'
+      + '<path d="M20 9 L22.5 2.5 L15 5.5 Z" fill="#F2A65A"/>'
+      + '<path d="M19.4 7.9 L20.7 4.5 L16.4 6.2 Z" fill="#E79B72"/>'
+      + '<circle cx="14" cy="15" r="9.8" fill="#F2A65A"/>'
+      + '<path d="M11.5 6.8 l.9 2.8 M14 6.4 l.3 3 M16.5 6.8 l-.7 2.8" stroke="#D98032" stroke-width="1.4" fill="none" stroke-linecap="round"/>'
+      + '<circle cx="10.4" cy="14.5" r="1.5" fill="#3F3A36" class="dsh-pet-eye"/>'
+      + '<circle cx="17.6" cy="14.5" r="1.5" fill="#3F3A36" class="dsh-pet-eye"/>'
+      + '<path d="M13 18 l2 0 l-1 1.5 z" fill="#C96F5E"/>'
+      + '<path d="M14 19.6 q-1.2 1.4 -2.4 .7 M14 19.6 q1.2 1.4 2.4 .7" stroke="#B98A5F" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+      + '<path d="M6.5 16.5 l-4 -1 M6.8 18.4 l-4 .5 M21.5 16.5 l4 -1 M21.2 18.4 l4 .5" stroke="#B98A5F" stroke-width=".8" fill="none" stroke-linecap="round"/>'
+
+    const PET_JU_TRAIL = ''
+      + '<g fill="#A98F7A"><ellipse cx="5.5" cy="6.8" rx="2.7" ry="2.1"/>'
+      + '<circle cx="2.4" cy="3.3" r="1.15"/><circle cx="4.6" cy="2" r="1.15"/>'
+      + '<circle cx="6.6" cy="2" r="1.15"/><circle cx="8.6" cy="3.4" r="1.15"/></g>'
+
+    const PET_TU_SIDE = ''
+      + '<circle cx="7.5" cy="36" r="4.5" fill="#FFFFFF"/>'
+      + '<ellipse cx="20" cy="42" rx="7.5" ry="6" fill="#EFE6D8"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="26" y="42" width="5.5" height="10" rx="2.7" fill="#FBF6EF" style="transform-origin:28.7px 43px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="34" y="42" width="5.5" height="10" rx="2.7" fill="#F4EADF" style="transform-origin:36.7px 43px"/>'
+      + '<ellipse cx="26" cy="38" rx="16" ry="12.5" fill="#FBF6EF"/>'
+      + '<ellipse cx="28" cy="42" rx="9" ry="6" fill="#F4EADF" opacity=".7"/>'
+      + '<path class="dsh-pet-ear" d="M37 5 Q30 6 31 16 Q31.5 24 35 24 Q38.5 24 38.5 16 Q38.5 8 37 5 Z" fill="#FBF6EF" style="transform-origin:37px 6px"/>'
+      + '<path d="M34.6 9.5 Q32.6 11 33 17 Q33.3 21.5 35 21.5 Q36.7 21.5 36.7 16.5 Q36.6 11.5 34.6 9.5 Z" fill="#F2C9C4"/>'
+      + '<circle cx="40" cy="23" r="10.5" fill="#FBF6EF"/>'
+      + '<path d="M33 17 Q37 12.5 43 12" stroke="#FFFFFF" stroke-width="2" fill="none" stroke-linecap="round" opacity=".9"/>'
+      + '<circle cx="44.5" cy="21.5" r="1.8" fill="#4A4038" class="dsh-pet-eye"/>'
+      + '<path d="M49.5 23.8 l2.4 .6 l-1.7 1.7 z" fill="#EFA8A0"/>'
+      + '<path d="M50.6 26.2 q-1.2 1.4 -2.8 .8" stroke="#C9A9A0" stroke-width="1" fill="none" stroke-linecap="round"/>'
+      + '<circle cx="46.5" cy="25" r="1.6" fill="#F6CFC9" opacity=".85"/>'
+
+    const PET_TU_FRONT = ''
+      + '<path class="dsh-pet-ear" d="M9 6 Q3 8 4.5 17 Q5.6 23.5 9 23 Q12 22.6 11.6 15 Q11.2 8.6 9 6 Z" fill="#FBF6EF" style="transform-origin:9px 7px"/>'
+      + '<path d="M7.4 10.5 Q5.8 12 6.4 17 Q6.9 21 8.8 20.8 Q10.4 20.6 10.2 15.4 Q10 11.5 7.4 10.5 Z" fill="#F2C9C4"/>'
+      + '<path class="dsh-pet-ear" d="M49 6 Q55 8 53.5 17 Q52.4 23.5 49 23 Q46 22.6 46.4 15 Q46.8 8.6 49 6 Z" fill="#FBF6EF" style="transform-origin:49px 7px"/>'
+      + '<path d="M50.6 10.5 Q52.2 12 51.6 17 Q51.1 21 49.2 20.8 Q47.6 20.6 47.8 15.4 Q48 11.5 50.6 10.5 Z" fill="#F2C9C4"/>'
+      + '<ellipse cx="29" cy="41" rx="12.5" ry="10" fill="#FBF6EF"/>'
+      + '<ellipse cx="29" cy="42" rx="7.5" ry="6.5" fill="#FFFFFF"/>'
+      + '<ellipse cx="24.5" cy="36" rx="2.6" ry="2" fill="#F4EADF"/>'
+      + '<ellipse cx="33.5" cy="36" rx="2.6" ry="2" fill="#F4EADF"/>'
+      + '<ellipse cx="24" cy="50.6" rx="2.8" ry="2.2" fill="#FBF6EF"/>'
+      + '<ellipse cx="34" cy="50.6" rx="2.8" ry="2.2" fill="#FBF6EF"/>'
+      + '<circle cx="29" cy="17" r="11.5" fill="#FBF6EF"/>'
+      + '<circle cx="24" cy="16" r="1.9" fill="#4A4038" class="dsh-pet-eye"/>'
+      + '<circle cx="34" cy="16" r="1.9" fill="#4A4038" class="dsh-pet-eye"/>'
+      + '<path d="M28 20 l2 0 l-1 1.6 z" fill="#EFA8A0"/>'
+      + '<path d="M29 21.6 q-1.4 1.6 -2.8 .8 M29 21.6 q1.4 1.6 2.8 .8" stroke="#C9A9A0" stroke-width="1" fill="none" stroke-linecap="round"/>'
+      + '<rect x="27.2" y="22.6" width="1.7" height="2.2" rx=".6" fill="#FFFFFF"/>'
+      + '<rect x="29.9" y="22.6" width="1.7" height="2.2" rx=".6" fill="#FFFFFF"/>'
+      + '<circle cx="20.5" cy="19.5" r="1.8" fill="#F6CFC9"/>'
+      + '<circle cx="37.5" cy="19.5" r="1.8" fill="#F6CFC9"/>'
+
+    const PET_TU_PROP = ''
+      + '<path d="M12 8 q-2.5 -5 -6 -6 q2 5 6 6 z" fill="#67B35F"/>'
+      + '<path d="M13 8 q2.5 -5 6 -6 q-2 5 -6 6 z" fill="#4E9B4A"/>'
+      + '<path d="M12 7 Q16 10 15 15 Q14 20 12 21 Q10 20 9 15 Q8 10 12 7 Z" fill="#EF8A3C"/>'
+      + '<path d="M10 11.5 q2 1 4 0 M9.7 15 q2.3 1 4.6 0" stroke="#D9702A" stroke-width="1.1" fill="none" stroke-linecap="round"/>'
+
+    const PET_TU_FACE = ''
+      + '<path d="M6.5 8 Q3.5 12 5 17 Q6 20 8 19 Q9.8 18 9.4 13 Q9 9 6.5 8 Z" fill="#FBF6EF"/>'
+      + '<path d="M6.9 10.5 Q5.9 13 6.7 16.4 Q7.4 18.2 8.3 17.8 Q9.2 17.4 9 13.6 Q8.8 11 6.9 10.5 Z" fill="#F2C9C4"/>'
+      + '<path d="M21.5 8 Q24.5 12 23 17 Q22 20 20 19 Q18.2 18 18.6 13 Q19 9 21.5 8 Z" fill="#FBF6EF"/>'
+      + '<path d="M21.1 10.5 Q22.1 13 21.3 16.4 Q20.6 18.2 19.7 17.8 Q18.8 17.4 19 13.6 Q19.2 11 21.1 10.5 Z" fill="#F2C9C4"/>'
+      + '<circle cx="14" cy="14" r="9.6" fill="#FBF6EF"/>'
+      + '<circle cx="10.3" cy="13.5" r="1.5" fill="#4A4038" class="dsh-pet-eye"/>'
+      + '<circle cx="17.7" cy="13.5" r="1.5" fill="#4A4038" class="dsh-pet-eye"/>'
+      + '<path d="M13 16.6 l2 0 l-1 1.5 z" fill="#EFA8A0"/>'
+      + '<rect x="12.8" y="18.4" width="1.2" height="1.7" rx=".5" fill="#FFFFFF"/>'
+      + '<rect x="14.4" y="18.4" width="1.2" height="1.7" rx=".5" fill="#FFFFFF"/>'
+      + '<circle cx="7.6" cy="16.4" r="1.5" fill="#F6CFC9"/>'
+      + '<circle cx="20.4" cy="16.4" r="1.5" fill="#F6CFC9"/>'
+
+    const PET_TU_TRAIL = ''
+      + '<g fill="#C9BCA8"><circle cx="3" cy="4.5" r="1.3"/><circle cx="7" cy="3.5" r="1.3"/></g>'
+
+    const PET_KE_SIDE = ''
+      + '<path d="M9.6 44 l-4.5 3 l5.2 .8 z" fill="#26303C"/>'
+      + '<ellipse cx="20" cy="54.5" rx="4.6" ry="2.4" fill="#F5A623"/>'
+      + '<ellipse cx="30" cy="54.5" rx="4.6" ry="2.4" fill="#E8961B"/>'
+      + '<ellipse cx="26" cy="33" rx="17" ry="21" fill="#2E3A48"/>'
+      + '<ellipse cx="30" cy="38" rx="11.5" ry="14" fill="#FDFDFB"/>'
+      + '<path class="dsh-pet-wing" d="M12 24 Q6 32 10 42 Q14 40 15.5 31 Q15 25 12 24 Z" fill="#26303C" style="transform-origin:12px 25px"/>'
+      + '<path d="M18 14 Q24 9.5 31 11" stroke="#3E4E60" stroke-width="2.4" fill="none" stroke-linecap="round" opacity=".9"/>'
+      + '<circle cx="33.5" cy="22" r="2" fill="#242C36" class="dsh-pet-eye"/>'
+      + '<circle cx="34.2" cy="21.3" r=".6" fill="#FFFFFF"/>'
+      + '<path d="M42 24 l7 2.2 l-7 2.6 z" fill="#F5A623"/>'
+
+    const PET_KE_FRONT = ''
+      + '<ellipse cx="19" cy="55" rx="4.4" ry="2.3" fill="#F5A623"/>'
+      + '<ellipse cx="33" cy="55" rx="4.4" ry="2.3" fill="#F5A623"/>'
+      + '<ellipse cx="26" cy="34" rx="17" ry="21" fill="#2E3A48"/>'
+      + '<ellipse cx="26" cy="39" rx="12" ry="14.5" fill="#FDFDFB"/>'
+      + '<path class="dsh-pet-wing" d="M9 26 Q3 34 7.5 44 Q12 42 13 32 Q12.4 26 9 26 Z" fill="#26303C" style="transform-origin:9px 27px"/>'
+      + '<path class="dsh-pet-wing" d="M43 26 Q49 34 44.5 44 Q40 42 39 32 Q39.6 26 43 26 Z" fill="#26303C" style="transform-origin:43px 27px"/>'
+      + '<path d="M16 13 Q22 8.5 29 10" stroke="#3E4E60" stroke-width="2.2" fill="none" stroke-linecap="round" opacity=".9"/>'
+      + '<circle cx="20" cy="23" r="2" fill="#242C36" class="dsh-pet-eye"/>'
+      + '<circle cx="32" cy="23" r="2" fill="#242C36" class="dsh-pet-eye"/>'
+      + '<circle cx="20.7" cy="22.3" r=".6" fill="#FFFFFF"/>'
+      + '<circle cx="32.7" cy="22.3" r=".6" fill="#FFFFFF"/>'
+      + '<path d="M22.5 27.5 l7 0 l-3.5 4.4 z" fill="#F5A623"/>'
+
+    const PET_KE_PROP = ''
+      + '<path d="M18 7 l4.4 -3 l-1 3 l1 3 z" fill="#C7D6E0"/>'
+      + '<path d="M2 7 Q8 2.5 15 5.5 Q18.5 7 18.5 7 Q18.5 7 15 8.5 Q8 11.5 2 7 Z" fill="#9FB6C6"/>'
+      + '<path d="M4 5.8 Q10 2.8 16 5.8" stroke="#7C96A8" stroke-width="1.4" fill="none" stroke-linecap="round"/>'
+      + '<circle cx="4.8" cy="6.4" r=".9" fill="#33424E"/>'
+
+    const PET_KE_FACE = ''
+      + '<circle cx="14" cy="15" r="10" fill="#2E3A48"/>'
+      + '<ellipse cx="9.5" cy="14" rx="4" ry="4.6" fill="#FDFDFB"/>'
+      + '<ellipse cx="18.5" cy="14" rx="4" ry="4.6" fill="#FDFDFB"/>'
+      + '<path d="M9 7.5 Q12 5.6 15 6.4" stroke="#3E4E60" stroke-width="1.6" fill="none" stroke-linecap="round" opacity=".9"/>'
+      + '<circle cx="9.5" cy="14" r="1.5" fill="#242C36" class="dsh-pet-eye"/>'
+      + '<circle cx="18.5" cy="14" r="1.5" fill="#242C36" class="dsh-pet-eye"/>'
+      + '<circle cx="10" cy="13.5" r=".5" fill="#FFFFFF"/>'
+      + '<circle cx="19" cy="13.5" r=".5" fill="#FFFFFF"/>'
+      + '<path d="M12 18.5 l4 0 l-2 2.6 z" fill="#F5A623"/>'
+
+    const PET_KE_TRAIL = ''
+      + '<g fill="#8FA3B0"><ellipse cx="6" cy="7.6" rx="3.1" ry="2.5"/>'
+      + '<circle cx="2.7" cy="3.7" r="1.35"/><circle cx="5" cy="2.3" r="1.35"/>'
+      + '<circle cx="7.3" cy="2.3" r="1.35"/><circle cx="9.5" cy="3.8" r="1.35"/></g>'
+
+    const PET_SHU_SIDE = ''
+      + '<circle cx="6.2" cy="26" r="1.6" fill="#E3C9A4"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="12" y="31" width="4" height="5.5" rx="2" fill="#D9BE97" style="transform-origin:14px 32px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="22" y="31" width="4" height="5.5" rx="2" fill="#E3C9A4" style="transform-origin:24px 32px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="29" y="31" width="4" height="5.5" rx="2" fill="#E3C9A4" style="transform-origin:31px 32px"/>'
+      + '<ellipse cx="21" cy="24" rx="16" ry="11" fill="#F0DCC0"/>'
+      + '<ellipse cx="21" cy="18.5" rx="13" ry="5.5" fill="#E3C9A4" opacity=".8"/>'
+      + '<ellipse class="dsh-pet-belly" cx="20" cy="28" rx="9" ry="4.5" fill="#F9EDD8" style="transform-origin:20px 28px"/>'
+      + '<path d="M12 17.5 Q17 13.5 23 13.5" stroke="#F9EDD8" stroke-width="2" fill="none" stroke-linecap="round" opacity=".9"/>'
+      + '<circle cx="31.5" cy="12.5" r="2.8" fill="#E3C9A4"/>'
+      + '<circle cx="31.7" cy="12.6" r="1.5" fill="#EFB9A8"/>'
+      + '<circle cx="29.5" cy="15.5" r="1.7" fill="#3F3630" class="dsh-pet-eye"/>'
+      + '<ellipse cx="33.5" cy="22" rx="5" ry="4.2" fill="#F6E6CE"/>'
+      + '<circle cx="38.8" cy="18.5" r="1.1" fill="#E2A69B"/>'
+      + '<path d="M37.4 20.6 q1.2 1 2.4 .2" stroke="#C89F82" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+      + '<path d="M36.5 19.5 l5.5 -1 M36.8 20.6 l5.5 .6" stroke="#C9AD8C" stroke-width=".8" fill="none" stroke-linecap="round"/>'
+
+    const PET_SHU_FRONT = ''
+      + '<ellipse cx="23" cy="26" rx="14" ry="10.5" fill="#F0DCC0"/>'
+      + '<ellipse cx="23" cy="28" rx="8.5" ry="6.5" fill="#F9EDD8"/>'
+      + '<ellipse cx="18.5" cy="36" rx="2.6" ry="1.8" fill="#E3C9A4"/>'
+      + '<ellipse cx="27.5" cy="36" rx="2.6" ry="1.8" fill="#E3C9A4"/>'
+      + '<circle cx="13.5" cy="19" r="6.5" fill="#F6E6CE"/>'
+      + '<circle cx="32.5" cy="19" r="6.5" fill="#F6E6CE"/>'
+      + '<circle cx="23" cy="17" r="9.5" fill="#F0DCC0"/>'
+      + '<circle cx="16.5" cy="9" r="2.6" fill="#E3C9A4"/>'
+      + '<circle cx="16.6" cy="9.1" r="1.3" fill="#EFB9A8"/>'
+      + '<circle cx="29.5" cy="9" r="2.6" fill="#E3C9A4"/>'
+      + '<circle cx="29.4" cy="9.1" r="1.3" fill="#EFB9A8"/>'
+      + '<circle cx="19" cy="15.5" r="1.7" fill="#3F3630" class="dsh-pet-eye"/>'
+      + '<circle cx="27" cy="15.5" r="1.7" fill="#3F3630" class="dsh-pet-eye"/>'
+      + '<circle cx="23" cy="19.2" r="1.1" fill="#E2A69B"/>'
+      + '<path d="M23 20.3 q-1.2 1.2 -2.3 .6 M23 20.3 q1.2 1.2 2.3 .6" stroke="#C89F82" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+      + '<rect x="21.7" y="21.4" width="1.9" height="2.4" rx=".7" fill="#FFFFFF"/>'
+      + '<rect x="24.4" y="21.4" width="1.9" height="2.4" rx=".7" fill="#FFFFFF"/>'
+      + '<ellipse cx="19.5" cy="29" rx="2.4" ry="2" fill="#E3C9A4"/>'
+      + '<ellipse cx="26.5" cy="29" rx="2.4" ry="2" fill="#E3C9A4"/>'
+      + '<ellipse cx="23" cy="28" rx="2" ry="1.3" fill="#4A4038"/>'
+      + '<circle cx="24.6" cy="27.6" r=".7" fill="#F7F2E8"/>'
+
+    const PET_SHU_PROP = ''
+      + '<path d="M3 7 Q7 2.5 13 4.5 Q17 6 17 7 Q17 8 13 9.5 Q7 11.5 3 7 Z" fill="#4A4038"/>'
+      + '<path d="M7 4.2 l0 5.6 M10.5 3.8 l0 6.2 M14 4.8 l0 4.4" stroke="#2E2A26" stroke-width="1.1" fill="none" stroke-linecap="round"/>'
+      + '<ellipse cx="16.8" cy="7" rx="1.5" ry="1.1" fill="#F7F2E8"/>'
+
+    const PET_SHU_FACE = ''
+      + '<circle cx="8.5" cy="8.5" r="2.5" fill="#E3C9A4"/>'
+      + '<circle cx="8.6" cy="8.6" r="1.2" fill="#EFB9A8"/>'
+      + '<circle cx="19.5" cy="8.5" r="2.5" fill="#E3C9A4"/>'
+      + '<circle cx="19.4" cy="8.6" r="1.2" fill="#EFB9A8"/>'
+      + '<circle cx="14" cy="15.5" r="9.8" fill="#F0DCC0"/>'
+      + '<circle cx="7.2" cy="18" r="3.8" fill="#F6E6CE"/>'
+      + '<circle cx="20.8" cy="18" r="3.8" fill="#F6E6CE"/>'
+      + '<circle cx="10.5" cy="14.5" r="1.5" fill="#3F3630" class="dsh-pet-eye"/>'
+      + '<circle cx="17.5" cy="14.5" r="1.5" fill="#3F3630" class="dsh-pet-eye"/>'
+      + '<circle cx="14" cy="17.6" r="1" fill="#E2A69B"/>'
+      + '<rect x="12.6" y="18.8" width="1.3" height="1.9" rx=".5" fill="#FFFFFF"/>'
+      + '<rect x="14.2" y="18.8" width="1.3" height="1.9" rx=".5" fill="#FFFFFF"/>'
+
+    const PET_SHU_TRAIL = ''
+      + '<g fill="#B9A88C"><circle cx="2.5" cy="3.2" r="1.1"/><circle cx="5.6" cy="2.6" r="1.1"/></g>'
+
+    const PET_HU_SIDE = ''
+      + '<g class="dsh-pet-tail" style="transform-origin:16px 34px">'
+      + '<path d="M16 34 Q4 26 6.5 14 Q8 8 13 10 Q20 13 21.5 24 Q22 31 16 34 Z" fill="#D9663D"/>'
+      + '<path d="M7 14 Q8.2 9.6 12 10.4 Q10.8 14.4 8.6 17.4 Q7.2 16 7 14 Z" fill="#FBF3E8"/></g>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="18" y="38" width="6" height="12" rx="3" fill="#8A4A2F" style="transform-origin:21px 39px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="40" y="38" width="6" height="12" rx="3" fill="#8A4A2F" style="transform-origin:43px 39px"/>'
+      + '<path d="M14 30 Q20 20 34 21 Q46 22 50 30 Q47 37 36 37.5 Q22 38 14 30 Z" fill="#D9663D"/>'
+      + '<ellipse cx="22" cy="32" rx="6.5" ry="5.5" fill="#C25832" opacity=".9"/>'
+      + '<ellipse cx="46" cy="31" rx="6" ry="6.5" fill="#FBF3E8"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="24" y="38" width="5.5" height="12" rx="2.7" fill="#D9663D" style="transform-origin:26.7px 39px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="35" y="38" width="5.5" height="12" rx="2.7" fill="#D9663D" style="transform-origin:37.7px 39px"/>'
+      + '<ellipse cx="27" cy="49.6" rx="2.8" ry="1.7" fill="#8A4A2F"/>'
+      + '<ellipse cx="37.6" cy="49.6" rx="2.8" ry="1.7" fill="#8A4A2F"/>'
+      + '<path d="M20 26 Q30 20.5 40 22" stroke="#E8845C" stroke-width="2.4" fill="none" stroke-linecap="round" opacity=".9"/>'
+      + '<path d="M44.5 11.5 L43 2 L51 7.5 Z" fill="#D9663D"/>'
+      + '<path d="M43 2 L47 5.6 L45.9 8.4 Z" fill="#4A372F"/>'
+      + '<circle cx="51" cy="17" r="9.5" fill="#D9663D"/>'
+      + '<path d="M49.5 10 L51 2 L56.5 8.5 Z" fill="#D9663D"/>'
+      + '<path d="M51 2 L54.8 6.8 L52.9 9 Z" fill="#4A372F"/>'
+      + '<circle cx="51.5" cy="15.5" r="1.8" fill="#3A2E28" class="dsh-pet-eye"/>'
+      + '<path d="M56 15 Q63 16.5 63.5 19.5 Q60 22 55.6 21 Z" fill="#FBF3E8"/>'
+      + '<circle cx="63" cy="18.6" r="1.5" fill="#3A2E28"/>'
+      + '<path d="M57 20.8 q2.4 1.4 4.6 -.2" stroke="#8A4A2F" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+
+    const PET_HU_FRONT = ''
+      + '<path d="M52 42 Q62 38 61 28 Q57 30.5 54.5 36 Q53 39.5 52 42 Z" fill="#D9663D"/>'
+      + '<path d="M61 28 Q58.6 29.6 57 33.4 Q59.6 32.6 61 28 Z" fill="#FBF3E8"/>'
+      + '<ellipse cx="31" cy="40" rx="13" ry="10" fill="#D9663D"/>'
+      + '<ellipse cx="31" cy="40" rx="7" ry="7.5" fill="#FBF3E8"/>'
+      + '<rect x="25.5" y="44" width="5" height="7" rx="2.5" fill="#8A4A2F"/>'
+      + '<rect x="33" y="44" width="5" height="7" rx="2.5" fill="#8A4A2F"/>'
+      + '<path d="M22.5 9 L19.5 1 L27.5 5 Z" fill="#D9663D"/>'
+      + '<path d="M19.5 1 L23.6 4.7 L22.2 8 Z" fill="#4A372F"/>'
+      + '<path d="M39.5 9 L42.5 1 L34.5 5 Z" fill="#D9663D"/>'
+      + '<path d="M42.5 1 L38.4 4.7 L39.8 8 Z" fill="#4A372F"/>'
+      + '<path d="M20.5 14 l-4.5 -1.5 l3 5 z" fill="#D9663D"/>'
+      + '<path d="M41.5 14 l4.5 -1.5 l-3 5 z" fill="#D9663D"/>'
+      + '<circle cx="31" cy="16" r="11" fill="#D9663D"/>'
+      + '<ellipse cx="31" cy="20.5" rx="6" ry="4.6" fill="#FBF3E8"/>'
+      + '<circle cx="26" cy="15" r="1.9" fill="#3A2E28" class="dsh-pet-eye"/>'
+      + '<circle cx="36" cy="15" r="1.9" fill="#3A2E28" class="dsh-pet-eye"/>'
+      + '<ellipse cx="31" cy="18.6" rx="1.5" ry="1.2" fill="#3A2E28"/>'
+      + '<path d="M31 19.8 q-1.5 1.6 -3 .8 M31 19.8 q1.5 1.6 3 .8" stroke="#8A4A2F" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+
+    const PET_HU_PROP = ''
+      + '<rect x="9.2" y="0.5" width="1.6" height="3" rx=".8" fill="#5E3D22"/>'
+      + '<path d="M10 3 Q15.5 7 15 13 Q14.5 19.5 10 21.5 Q5.5 19.5 5 13 Q4.5 7 10 3 Z" fill="#9C6B3F"/>'
+      + '<path d="M7 8 q3 1.6 6 0 M6.4 12 q3.6 1.8 7.2 0 M6.8 16 q3.2 1.7 6.4 0 M8.4 5 q1.6 1.2 3.2 0" stroke="#7C5230" stroke-width="1.2" fill="none" stroke-linecap="round"/>'
+
+    const PET_HU_FACE = ''
+      + '<path d="M8 8 L5.5 1 L12 4.5 Z" fill="#D9663D"/>'
+      + '<path d="M5.5 1 L9 3.9 L7.6 6.4 Z" fill="#4A372F"/>'
+      + '<path d="M20 8 L22.5 1 L16 4.5 Z" fill="#D9663D"/>'
+      + '<path d="M22.5 1 L19 3.9 L20.4 6.4 Z" fill="#4A372F"/>'
+      + '<circle cx="14" cy="15" r="9.8" fill="#D9663D"/>'
+      + '<ellipse cx="14" cy="19.5" rx="5.4" ry="4.2" fill="#FBF3E8"/>'
+      + '<circle cx="10" cy="14" r="1.5" fill="#3A2E28" class="dsh-pet-eye"/>'
+      + '<circle cx="18" cy="14" r="1.5" fill="#3A2E28" class="dsh-pet-eye"/>'
+      + '<ellipse cx="14" cy="17.8" rx="1.3" ry="1" fill="#3A2E28"/>'
+      + '<path d="M14 18.8 q-1.3 1.4 -2.6 .7 M14 18.8 q1.3 1.4 2.6 .7" stroke="#8A4A2F" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+
+    const PET_HU_TRAIL = ''
+      + '<g fill="#8F7A66"><ellipse cx="5.5" cy="6.6" rx="2.3" ry="1.9"/>'
+      + '<circle cx="2.7" cy="3.5" r="1.05"/><circle cx="5" cy="2.3" r="1.05"/>'
+      + '<circle cx="7.3" cy="2.3" r="1.05"/><circle cx="9.3" cy="3.7" r="1.05"/></g>'
+
+    const PET_XIONG_SIDE = ''
+      // 熊猫的黑色分布（实机验收"完全不像是熊猫"后的重画）：黑耳 / 大黑眼斑 /
+      // 黑肩带连前肢 / 黑后臀连后腿，脸与身体中段是白 —— 旧版身体上下各一条
+      // 孤立黑边（像被黑布勒住的白身体），观感不是熊猫。眼睛用黑斑里的白点
+      // （旧版棕色眼在黑斑里看不清，眼斑读不出来）。
+      + '<ellipse cx="15.5" cy="40" rx="9.5" ry="11" fill="#2E2A28"/>'
+      + '<ellipse cx="30" cy="37" rx="16.5" ry="12.5" fill="#FAFAF7"/>'
+      + '<ellipse cx="42" cy="34" rx="6.5" ry="9.5" fill="#2E2A28"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-b" x="16" y="38" width="7.5" height="13" rx="3.7" fill="#2E2A28" style="transform-origin:19.7px 39px"/>'
+      + '<rect class="dsh-pet-leg dsh-pet-leg-a" x="38.5" y="38" width="7.5" height="13" rx="3.7" fill="#2E2A28" style="transform-origin:42.2px 39px"/>'
+      + '<ellipse class="dsh-pet-belly" cx="29" cy="42" rx="9" ry="7.5" fill="#FFFFFF" style="transform-origin:29px 42px"/>'
+      + '<circle cx="38.5" cy="7" r="4.2" fill="#2E2A28"/>'
+      + '<circle cx="53" cy="7" r="4.2" fill="#2E2A28"/>'
+      + '<circle cx="45.5" cy="17" r="11.5" fill="#FAFAF7"/>'
+      + '<ellipse cx="41" cy="15" rx="4.4" ry="5.6" fill="#2E2A28" transform="rotate(-18 41 15)"/>'
+      + '<ellipse cx="51.5" cy="14.5" rx="4.4" ry="5.6" fill="#2E2A28" transform="rotate(14 51.5 14.5)"/>'
+      + '<circle cx="41.5" cy="15.8" r="1.5" fill="#FFFFFF" class="dsh-pet-eye"/>'
+      + '<circle cx="51" cy="15.2" r="1.5" fill="#FFFFFF" class="dsh-pet-eye"/>'
+      + '<ellipse cx="46.8" cy="21.8" rx="2" ry="1.5" fill="#2E2A28"/>'
+      + '<path d="M46.8 23.3 q-1.4 1.6 -3 1 M46.8 23.3 q1.2 1.6 2.6 .8" stroke="#6B6560" stroke-width="1" fill="none" stroke-linecap="round"/>'
+
+    const PET_XIONG_FRONT = ''
+      // 正面：头下加黑色肩领（熊猫脖子处本就是黑肩带，头身连接也由它承载——
+      // 白头直接坐在白身上会"头身分离"，琥珀猫咪那次的教训），手臂加粗成
+      // 圆肩短臂，眼斑放大让"黑眼圈"这个第一辨识特征读得出来。
+      + '<circle cx="16" cy="8.5" r="4.6" fill="#2E2A28"/>'
+      + '<circle cx="42" cy="8.5" r="4.6" fill="#2E2A28"/>'
+      + '<ellipse cx="29" cy="39.5" rx="15.5" ry="11.5" fill="#FAFAF7"/>'
+      + '<ellipse cx="29" cy="30" rx="11" ry="5" fill="#2E2A28"/>'
+      + '<path d="M16.5 32 q-4.5 9 1 15.5 q7 -1.5 8.5 -8 Q24 33.5 16.5 32 Z" fill="#2E2A28"/>'
+      + '<path d="M41.5 32 q4.5 9 -1 15.5 q-7 -1.5 -8.5 -8 Q34 33.5 41.5 32 Z" fill="#2E2A28"/>'
+      + '<ellipse cx="21.5" cy="51" rx="5.4" ry="3" fill="#2E2A28"/>'
+      + '<ellipse cx="36.5" cy="51" rx="5.4" ry="3" fill="#2E2A28"/>'
+      + '<ellipse class="dsh-pet-belly" cx="29" cy="41" rx="8.5" ry="6.5" fill="#FFFFFF" style="transform-origin:29px 41px"/>'
+      + '<circle cx="29" cy="16.5" r="12.5" fill="#FAFAF7"/>'
+      + '<ellipse cx="22.5" cy="14.8" rx="4.8" ry="6" fill="#2E2A28" transform="rotate(-16 22.5 14.8)"/>'
+      + '<ellipse cx="35.5" cy="14.8" rx="4.8" ry="6" fill="#2E2A28" transform="rotate(16 35.5 14.8)"/>'
+      + '<circle cx="23" cy="15.6" r="1.55" fill="#FFFFFF" class="dsh-pet-eye"/>'
+      + '<circle cx="35" cy="15.6" r="1.55" fill="#FFFFFF" class="dsh-pet-eye"/>'
+      + '<ellipse cx="29" cy="20.8" rx="2.1" ry="1.6" fill="#2E2A28"/>'
+      + '<path d="M29 22.4 q-1.4 1.6 -2.8 .9 M29 22.4 q1.4 1.6 2.8 .9" stroke="#6B6560" stroke-width="1" fill="none" stroke-linecap="round"/>'
+
+    const PET_XIONG_PROP = ''
+      + '<path d="M10 3 Q9 .8 7.4 .6 Q9.6 -.2 10.9 1.4 Q10.7 2.4 10 3 Z" fill="#67B35F"/>'
+      + '<path d="M10 3 Q15 8 14 14 Q13 20.5 10 22.5 Q7 20.5 6 14 Q5 8 10 3 Z" fill="#D9C08A"/>'
+      + '<path d="M7.6 8.4 q2.4 1.6 4.8 0 M7 13 q3 1.8 6 0 M7.8 17.6 q2.2 1.5 4.4 0 M8.8 5.2 q1.2 1 2.4 0" stroke="#B99C63" stroke-width="1.3" fill="none" stroke-linecap="round"/>'
+
+    const PET_XIONG_FACE = ''
+      + '<circle cx="7.5" cy="7" r="3.8" fill="#2E2A28"/>'
+      + '<circle cx="20.5" cy="7" r="3.8" fill="#2E2A28"/>'
+      + '<circle cx="14" cy="15.5" r="10" fill="#FAFAF7"/>'
+      + '<ellipse cx="9.6" cy="14.3" rx="4.2" ry="5.2" fill="#2E2A28" transform="rotate(-15 9.6 14.3)"/>'
+      + '<ellipse cx="18.4" cy="14.3" rx="4.2" ry="5.2" fill="#2E2A28" transform="rotate(15 18.4 14.3)"/>'
+      + '<circle cx="9.9" cy="14.8" r="1.4" fill="#FFFFFF" class="dsh-pet-eye"/>'
+      + '<circle cx="18.1" cy="14.8" r="1.4" fill="#FFFFFF" class="dsh-pet-eye"/>'
+      + '<ellipse cx="14" cy="18.8" rx="1.8" ry="1.4" fill="#2E2A28"/>'
+      + '<path d="M14 20.2 q-1.3 1.4 -2.6 .8 M14 20.2 q1.3 1.4 2.6 .8" stroke="#6B6560" stroke-width=".9" fill="none" stroke-linecap="round"/>'
+
+    const PET_XIONG_TRAIL = ''
+      + '<g fill="#57534E"><ellipse cx="7" cy="8" rx="3.6" ry="2.8"/>'
+      + '<circle cx="2.6" cy="4" r="1.15"/><circle cx="4.8" cy="2.6" r="1.15"/>'
+      + '<circle cx="7" cy="2.2" r="1.15"/><circle cx="9.2" cy="2.7" r="1.15"/>'
+      + '<circle cx="11.2" cy="4.2" r="1.15"/></g>'
+
+    /**
+     * 宠物注册表 —— 二期的核心数据。顺序 = 面板头像行顺序 = 预览页顺序；
+     * `ban-ban` 永远第一（缺省宠物）。全部字段是**数据**，不许出现函数。
      *
-     * `usePanelInfo` comes from the layout's GlobalStandardProps, so the page can
-     * render nothing when another panel is selected without the shell having to
-     * mount and unmount it.
-     * @param props - composed slot props.
-     * @returns the page element tree.
+     * · `motion`：run（平滑直线）/ hop（抛物线蹦跳，起伏由运行时驱动）/ waddle（左右摇步）。
+     * · `place`：未被拖过时的缺省摆位（视口右/下缘偏移；语义同一期）。
+     * · `react.lines`：戳一下的两声；`cheer/done`：生成中加油 / 完成庆祝；`chat`：闲聊。
      */
-    function ThemeGalleryPage({ t, setTheme, pickScheme, useStore, usePanelInfo }) {
-      const info = usePanelInfo((s) => s.activePanelId)
-      const ids = useStore((s) => s.ids)
-      const labels = useStore((s) => s.labels)
-      const descriptions = useStore((s) => s.descriptions)
-      const swatches = useStore((s) => s.swatches)
-      const cardRows = useStore((s) => s.cardRows)
-      const scheme = useStore((s) => s.scheme)
-      const selected = useStore((s) => s.selected)
-      const status = useStore((s) => s.status)
-      // The layout keeps this page registered whatever the selection is, so it
+    const PET_KINDS = [
+      {
+        id: 'ban-ban', species: '小奶狗', home: '斑斑',
+        viewBox: '0 0 64 56', size: { w: 64, h: 56 },
+        art: { side: PET_BAN_SIDE, front: PET_BAN_FRONT },
+        propViewBox: '0 0 26 22', propSize: { w: 26, h: 22 }, propArt: PET_BAN_PROP,
+        faceViewBox: '0 0 28 28', faceArt: PET_BAN_FACE,
+        trail: { art: PET_BAN_TRAIL, w: 12, h: 11, everyPx: 26, side: 5 },
+        motion: 'run', speed: 130,
+        react: { lines: ['汪！', '汪汪！'], ms: 1450 },
+        cheer: '汪汪！加油！', done: '汪汪！完成啦！',
+        chat: [
+          '汪…斑斑在看着你写代码～',
+          '要不要休息一下？斑斑可以陪你玩毛线团！',
+          '汪！今天的代码也写得棒棒的！',
+          '（歪头）这个 bug 闻起来有线索的味道…',
+        ],
+        place: { pet: { dx: -100, dy: -56 }, prop: { dx: -132, dy: -22 } },
+      },
+      {
+        id: 'da-ju', species: '橘猫', home: '大橘',
+        viewBox: '0 0 62 54', size: { w: 62, h: 54 },
+        art: { side: PET_JU_SIDE, front: PET_JU_FRONT },
+        propViewBox: '0 0 24 18', propSize: { w: 24, h: 18 }, propArt: PET_JU_PROP,
+        faceViewBox: '0 0 28 28', faceArt: PET_JU_FACE,
+        trail: { art: PET_JU_TRAIL, w: 11, h: 10, everyPx: 22, side: 4 },
+        motion: 'run', speed: 140,
+        react: { lines: ['喵～？', '喵喵！'], ms: 1350 },
+        cheer: '喵！在跑了在跑了！', done: '喵～搞定，可以吸猫了',
+        chat: [
+          '喵～敲键盘的手不可以摸鱼，但是可以摸猫',
+          '代码写累了？本橘允许你吸三分钟猫',
+          '喵呜…小鱼干和 commit，都再来一点嘛',
+          '本橘监工中，摸鱼是会被记小本本的哦',
+        ],
+        place: { pet: { dx: -96, dy: -54 }, prop: { dx: -130, dy: -18 } },
+      },
+      {
+        id: 'xue-qiu', species: '垂耳兔', home: '雪球',
+        viewBox: '0 0 58 56', size: { w: 58, h: 56 },
+        art: { side: PET_TU_SIDE, front: PET_TU_FRONT },
+        propViewBox: '0 0 24 22', propSize: { w: 24, h: 22 }, propArt: PET_TU_PROP,
+        faceViewBox: '0 0 28 28', faceArt: PET_TU_FACE,
+        trail: { art: PET_TU_TRAIL, w: 10, h: 8, everyPx: 34, side: 0 },
+        motion: 'hop', speed: 150,
+        react: { lines: ['哼哼！', '蹦！'], ms: 1250 },
+        cheer: '加油加油！蹦！', done: '写完啦！蹦蹦庆祝！',
+        chat: [
+          '胡萝卜含量：0。兔兔有点失望…',
+          '蹦蹦跳跳，bug 全都跑掉！',
+          '兔兔在呢，慢慢想，不着急～',
+          '耳朵告诉你：这一版写得不错哦！',
+        ],
+        place: { pet: { dx: -92, dy: -56 }, prop: { dx: -124, dy: -22 } },
+      },
+      {
+        id: 'bo-bo', species: '小企鹅', home: '波波',
+        viewBox: '0 0 52 58', size: { w: 52, h: 58 },
+        art: { side: PET_KE_SIDE, front: PET_KE_FRONT },
+        propViewBox: '0 0 24 14', propSize: { w: 24, h: 14 }, propArt: PET_KE_PROP,
+        faceViewBox: '0 0 28 28', faceArt: PET_KE_FACE,
+        trail: { art: PET_KE_TRAIL, w: 12, h: 10, everyPx: 30, side: 6 },
+        motion: 'waddle', speed: 110,
+        react: { lines: ['嘎！', '嘎嘎！'], ms: 1300 },
+        cheer: '嘎！冲鸭！', done: '嘎！收工，鱼干时间！',
+        chat: [
+          '嘎！南极的网速都没这么慢过…',
+          '扑通扑通，为你打 call！',
+          '企鹅不怕冷，你的代码也要不惧重构！',
+          '鱼给你留着，记得吃饭呀～',
+        ],
+        place: { pet: { dx: -86, dy: -58 }, prop: { dx: -118, dy: -14 } },
+      },
+      {
+        id: 'nuo-mi', species: '仓鼠', home: '糯米',
+        viewBox: '0 0 46 38', size: { w: 46, h: 38 },
+        art: { side: PET_SHU_SIDE, front: PET_SHU_FRONT },
+        propViewBox: '0 0 20 14', propSize: { w: 20, h: 14 }, propArt: PET_SHU_PROP,
+        faceViewBox: '0 0 28 28', faceArt: PET_SHU_FACE,
+        trail: { art: PET_SHU_TRAIL, w: 8, h: 6, everyPx: 14, side: 3 },
+        motion: 'run', speed: 170,
+        react: { lines: ['吱！', '吱吱！'], ms: 1100 },
+        cheer: '吱吱吱！跑起来！', done: '吱！存进颊囊啦！',
+        chat: [
+          '吱吱！瓜子分你一半，bug 也分你一半！',
+          '仓鼠球蓄力中…能量 +1',
+          '颊囊已清空，可以继续装需求了！',
+          '吱…今天的代码香香的，像葵花籽',
+        ],
+        place: { pet: { dx: -78, dy: -38 }, prop: { dx: -108, dy: -14 } },
+      },
+      {
+        id: 'a-chi', species: '小狐狸', home: '阿赤',
+        viewBox: '0 0 66 52', size: { w: 66, h: 52 },
+        art: { side: PET_HU_SIDE, front: PET_HU_FRONT },
+        propViewBox: '0 0 20 24', propSize: { w: 20, h: 24 }, propArt: PET_HU_PROP,
+        faceViewBox: '0 0 28 28', faceArt: PET_HU_FACE,
+        trail: { art: PET_HU_TRAIL, w: 11, h: 10, everyPx: 24, side: 4 },
+        motion: 'run', speed: 155,
+        react: { lines: ['咕？', '咕咕！'], ms: 1250 },
+        cheer: '咕！冲！', done: '咕～漂亮！收工！',
+        chat: [
+          '咕？这条路径，狐狸觉得可疑哦',
+          '悄悄告诉你：尾巴比代码先跑完～',
+          '森林法则第一条：先写测试！',
+          '咕～松果给你，创意也给你！',
+        ],
+        place: { pet: { dx: -100, dy: -52 }, prop: { dx: -138, dy: -24 } },
+      },
+      {
+        id: 'tuan-tuan', species: '熊猫', home: '团团',
+        viewBox: '0 0 60 56', size: { w: 60, h: 56 },
+        art: { side: PET_XIONG_SIDE, front: PET_XIONG_FRONT },
+        propViewBox: '0 0 20 24', propSize: { w: 20, h: 24 }, propArt: PET_XIONG_PROP,
+        faceViewBox: '0 0 28 28', faceArt: PET_XIONG_FACE,
+        trail: { art: PET_XIONG_TRAIL, w: 14, h: 12, everyPx: 34, side: 6 },
+        motion: 'waddle', speed: 95,
+        react: { lines: ['嘿嘿！', '抱抱！'], ms: 1500 },
+        cheer: '嘿嘿，冲呀！', done: '嘿嘿，完成！干饭！',
+        chat: [
+          '嘿嘿…竹子要一口一口吃，代码要一行一行写',
+          '团团营业中，干饭与陪写两不误～',
+          '黑眼圈是天生的，你的可不能熬出来！',
+          '抱住竹笋，也抱住今天的 KPI！',
+        ],
+        place: { pet: { dx: -94, dy: -56 }, prop: { dx: -128, dy: -24 } },
+      },
+    ]
+
+    /** id → 注册表项；不认识的 id 一律回落第一只（缺省宠物）。 */
+    const PET_KIND_BY_ID = new Map(PET_KINDS.map((kind) => [kind.id, kind]))
+
+    /** 缺省宠物 = 注册表第一只（ban-ban）。切换逻辑与兜底逻辑都以它为准。 */
+    const DEFAULT_PET_KIND = PET_KINDS[0]
+
+    /** 宠物的显示尺寸（px）—— 注册表 size × PET_SCALE。消费尺寸一律走这里。 */
+    function petDisplaySize(kind) {
+      return { w: kind.size.w * PET_SCALE, h: kind.size.h * PET_SCALE }
+    }
+
+    /** 道具的显示尺寸（px）。与宠物同一缩放：道具不同步放大就会显得相对变小。 */
+    function petPropDisplaySize(kind) {
+      return { w: kind.propSize.w * PET_SCALE, h: kind.propSize.h * PET_SCALE }
+    }
+
+    /** 按注册表包裹一件姿势/道具/头像（<svg> 内部内容 → 完整 svg 字符串）。 */
+    function petKindById(id) {
+      return PET_KIND_BY_ID.get(id) ?? DEFAULT_PET_KIND
+    }
+
+    /**
+     * 包一层姿势 svg。cls 是 dsh-pet-side / dsh-pet-front（正反面由 CSS 切换显示）。
+     * 只做拼接、不读任何运行态 —— 面板卡面与预览页都能单独调用它。
+     */
+    function petSvg(kind, pose, cls) {
+      return `<svg class="${cls}" viewBox="${kind.viewBox}" aria-hidden="true">${kind.art[pose]}</svg>`
+    }
+
+    /** 道具 svg（无类名：道具没有姿势切换）。 */
+    function petPropSvg(kind) {
+      return `<svg viewBox="${kind.propViewBox}" aria-hidden="true">${kind.propArt}</svg>`
+    }
+
+    /**
+     * 挂件状态的缺省值：默认关；名字按注册表逐只给（names 是 kind → 名字的表，
+     * 每只宠物各自记住自己的名字）；没拖过时按**当前宠物**的 place 摆位。
+     */
+    const PET_DEFAULTS = {
+      on: false,
+      kind: DEFAULT_PET_KIND.id,
+      names: Object.fromEntries(PET_KINDS.map((kind) => [kind.id, kind.home])),
+      placed: false,
+      pet: { ...DEFAULT_PET_KIND.place.pet },
+      prop: { ...DEFAULT_PET_KIND.place.prop },
+    }
+
+    /** 读到不认识的 kind 时置位（自检行要用），下一次成功读取时清掉。 */
+    let stateKindFallback = false
+
+    /**
+     * 挂件运行态。`enabled` 是 localStorage 的内存镜像：resync 每帧都会进来，
+     * 不能每次都读一遍 localStorage。`mode` = idle（待机）/ run（跑向道具）/
+     * drag（被拖住）/ react（面对用户的反应）。
+     *
+     * 坐标语义（相对舞台左上角的 px）：x/y 是宠物的**左上角**；propX 是道具的
+     * **中心 x**、propY 是它的上缘。dir 是水平朝向：1 = 朝右（美术原方向），-1 = 朝左
+     * （镜像）—— 缺省朝左，因为缺省摆位里道具就在宠物左侧，它一出生就该看着玩具。
+     * hop 步态：hopFrac 是 0..1 的相位，lift 是当前视觉抬升（只影响显示，不动逻辑坐标）。
+     */
+    const petRun = {
+      enabled: false, mode: 'idle', dir: -1, kindId: '',
+      x: 0, y: 0, propX: 0, propY: 0, groundY: 0,
+      hopFrac: 0, lift: 0,
+      dragDX: 0, dragDY: 0, dragging: null,
+      trailDist: 0, trailSide: 1, lastAt: 0, anchorKey: '', reactWasRunning: false,
+      working: false, firstSyncAt: 0, everWorked: false,
+    }
+    /** 舞台与关键子节点的引用；null = 未挂载。 */
+    let petStage = null
+    const petRefs = { actor: null, prop: null, flip: null, figure: null, tag: null, name: null, input: null }
+    /** 活着的脚印 / 气泡数量（有上限）。 */
+    let petTrailCount = 0
+    let petBubbleCount = 0
+    /** react/cheer 的短时定时器；卸载时统一清掉，避免对已拆除的节点说话。 */
+    let petTimers = []
+    /** 本次模块实例的属主戳：热重载后旧实例留下的舞台会被清扫（ambient 同款做法）。 */
+    const PET_OWNER = `p${Date.now()}`
+
+    /**
+     * 读取并消毒挂件状态。
+     *
+     * localStorage 里的东西不可信：换版本、手改、损坏的 JSON 都可能遇到。宁可回到缺省，
+     * 也不把一个 `undefined` 画进 transform。旧形状（一期：name/dog/ball 标量键）在这里
+     * **原地迁移**：dog→pet、ball→prop、name→names['ban-ban']，用户实机已在一期存过
+     * 数据，升级不该让他重新摆位、重新起名。
+     * @returns `{ on, kind, names, placed, pet: {dx,dy}, prop: {dx,dy} }`。
+     */
+    function readPetState() {
+      const defaults = () => ({
+        on: PET_DEFAULTS.on,
+        kind: PET_DEFAULTS.kind,
+        names: { ...PET_DEFAULTS.names },
+        placed: PET_DEFAULTS.placed,
+        pet: { ...PET_DEFAULTS.pet },
+        prop: { ...PET_DEFAULTS.prop },
+      })
+      try {
+        const raw = window.localStorage?.getItem(PET_KEY)
+        if (typeof raw !== 'string' || raw === '') return defaults()
+        const parsed = JSON.parse(raw)
+        if (parsed === null || typeof parsed !== 'object') return defaults()
+        const out = defaults()
+        const num = (value, fallback) =>
+          (typeof value === 'number' && Number.isFinite(value) ? value : fallback)
+        const offset = (value, fallback) => {
+          const obj = value !== null && typeof value === 'object' ? value : {}
+          return { dx: num(obj.dx, fallback.dx), dy: num(obj.dy, fallback.dy) }
+        }
+        // kind：不认识的（含被手改成乱码）一律回落缺省宠物，并留痕给自检行。
+        stateKindFallback = false
+        if (typeof parsed.kind === 'string' && PET_KIND_BY_ID.has(parsed.kind)) {
+          out.kind = parsed.kind
+        } else if (typeof parsed.kind === 'string' && parsed.kind !== '') {
+          stateKindFallback = true
+        }
+        const kind = petKindById(out.kind)
+        // 名字表：按宠物各自记忆；当前宠物保证有名字（缺 → 注册表的 home）。
+        if (parsed.names !== null && typeof parsed.names === 'object') {
+          for (const key of Object.keys(out.names)) {
+            const value = parsed.names[key]
+            if (typeof value === 'string' && value.trim() !== '') {
+              out.names[key] = value.trim().slice(0, 10)
+            }
+          }
+        }
+        // 一期迁移：顶层 name 只属于斑斑；dog/ball 是 pet/prop 的旧键名。
+        if (typeof parsed.name === 'string' && parsed.name.trim() !== '') {
+          out.names['ban-ban'] = parsed.name.trim().slice(0, 10)
+        }
+        if (typeof out.names[kind.id] !== 'string' || out.names[kind.id] === '') {
+          out.names[kind.id] = kind.home
+        }
+        out.on = parsed.on === true
+        out.placed = parsed.placed === true
+        const petOffset = parsed.pet !== undefined ? parsed.pet : parsed.dog
+        const propOffset = parsed.prop !== undefined ? parsed.prop : parsed.ball
+        out.pet = offset(petOffset, kind.place.pet)
+        out.prop = offset(propOffset, kind.place.prop)
+        return out
+      } catch {
+        return defaults()
+      }
+    }
+
+    /**
+     * 合并写回挂件状态。写失败只记录 —— localStorage 被禁用时挂件仍可在本次会话里玩。
+     * @param patch - 要合并进状态的部分字段。
+     */
+    function savePetState(patch) {
+      try {
+        window.localStorage?.setItem(PET_KEY, JSON.stringify({ ...readPetState(), ...patch }))
+      } catch (error) {
+        console.error('[theme-gallery] could not save the pet state:', error)
+      }
+    }
+
+    /** 挂件现在是否开着（给卡片徽标与同步判据用）。 */
+    function petWidgetOn() {
+      return readPetState().on
+    }
+
+    /**
+     * 挂件卡的"伪主题"形态。
+     *
+     * 面板卡片完全从主题注册表推导，而挂件不是主题 —— 所以给它一张**只在面板里存在**
+     * 的卡片数据：走同一条排序与渲染管线（CARD_ORDER 序号、tooltip、禁用逻辑与其他卡
+     * 一致），却不会被注册进主题服务（BUNDLED_THEMES 里没有它），官方外观列表也就
+     * 多不出这一项。
+     * @returns 只带卡片字段的对象（没有 tokens，默认色带为空）。
+     */
+    function petWidgetCardTheme() {
+      return {
+        id: PET_WIDGET.id,
+        label: PET_WIDGET.label,
+        description: PET_WIDGET.description,
+        colorScheme: 'light',
+        tokens: {},
+      }
+    }
+
+    /**
+     * 心情问候卡的卡片数据（petWidgetCardTheme 同构）：只在面板里存在的非主题卡，
+     * 走同一条排序与渲染管线（CARD_ORDER 73、tooltip），不注册进主题服务，
+     * 官方外观列表不会多出这一项。
+     * @returns 只带卡片字段的对象（没有 tokens，默认色带为空）。
+     */
+    function moodCardTheme() {
+      return {
+        id: MOOD_WIDGET.id,
+        label: MOOD_WIDGET.label,
+        description: MOOD_WIDGET.description,
+        colorScheme: 'light',
+        tokens: {},
+      }
+    }
+
+    /**
+     * 菜单折叠卡的卡片数据（moodCardTheme 同构）：只在面板里存在的非主题卡，
+     * 走同一条排序与渲染管线（CARD_ORDER 72、tooltip），不注册进主题服务，
+     * 官方外观列表不会多出这一项。
+     * @returns 只带卡片字段的对象（没有 tokens，默认色带为空）。
+     */
+    function menuCollapseCardTheme() {
+      return {
+        id: MENU_COLLAPSE_WIDGET.id,
+        label: MENU_COLLAPSE_WIDGET.label,
+        description: MENU_COLLAPSE_WIDGET.description,
+        colorScheme: 'light',
+        tokens: {},
+      }
+    }
+
+    /**
+     * 输入框（composer 座位）的矩形。
+     *
+     * 这里**故意**不复用 mountGallery 里的 centreColumn / composerOf：那是挂载体内部的
+     * 函数，工厂级的本函数够不到（硬性规则 4 的形状）。查找逻辑与它们一致，注释写明
+     * 重复的原因 —— 两份实现谁坏了都会在"挂件不出现"上显形，而不是静默错位。
+     *
+     * ── 为什么不能只写 `.centerCol`（真机事故：挂件永远建不出来）────────────────
+     *
+     * 框架类名是**构建期哈希**：侧栏列在真机上叫 `ZTP-Xa_sidebarCol`，中心列同理是
+     * `…_centerCol`。SKILL §13 的老教训在这里换了个形态复发——选择器命中 0 个元素、
+     * 无异常无日志。所以中心列的查找必须像 `sidebarColumn()` 一样**哈希容忍**
+     * （`[class*="_centerCol"]`），并再加两级兜底：全局找第一个 contenteditable /
+     * textarea（聊天输入框几乎必然是其一）；连它都没有时由调用方回退到视口定位。
+     * @returns 矩形，或 null（连全局输入框都找不到）。
+     */
+    function petAnchorBox() {
+      if (typeof document === 'undefined') return null
+      const centre = document.querySelector('[data-windows-titlebar] .centerCol')
+        || document.querySelector('[class*="_centerCol"]')
+        || document.querySelector('[class*="centerCol" i]')
+      const composer = (centre === null ? null
+        : centre.querySelector('[contenteditable="true"]') || centre.querySelector('textarea'))
+        || document.querySelector('[contenteditable="true"]')
+        || document.querySelector('textarea')
+      if (composer === null && centre === null) return null
+      for (const node of [composer === null ? undefined : composer.parentElement, composer, centre]) {
+        if (node === undefined || node === null) continue
+        const rect = node.getBoundingClientRect()
+        if (rect.width > 0 || rect.height > 0) return rect
+      }
+      return null
+    }
+
+    /** 把 x 夹进窗口（狗按其半宽、球按其半径留边），拖出去也会被接住。 */
+    function petClampX(x, half, width) {
+      return Math.max(half, Math.min(x, Math.max(half, width - half)))
+    }
+
+    /**
+     * 视口尺寸，带兜底：个别环境读不到 innerWidth / innerHeight 时钳位会变成 NaN，
+     * 狗会瞬间飞出屏幕 —— 与其信任它们存在，不如在这里回退成常见值。
+     * @returns `{ width, height }`（px）。
+     */
+    function petViewport() {
+      const pick = (value, fallback) =>
+        (typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback)
+      try {
+        return {
+          width: pick(window.innerWidth, 1280),
+          height: pick(window.innerHeight, 800),
+        }
+      } catch {
+        return { width: 1280, height: 800 }
+      }
+    }
+
+    /** 指针坐标；桩环境给不出数字时返回 null（调用方直接忽略这一帧）。 */
+    function petPointOf(event) {
+      const x = event?.clientX
+      const y = event?.clientY
+      if (typeof x !== 'number' || typeof y !== 'number') return null
+      return { x, y }
+    }
+
+    /** 挂件层自己的样式表（与 PAGE_CSS 分开：它属于运行时舞台，不属于面板页面）。 */
+    const PET_CSS = [
+      `#${PET_STAGE_ID}{position:fixed;left:0;top:0;right:0;bottom:0;pointer-events:none;z-index:1200}`,
+      // 弹窗打开时整层隐藏（body 标记类由 syncPetDialogHidden 维护）——
+      // 挂件 z-index 高于模态弹窗，不藏会浮在弹窗内容上方（实机读数 2026-09-27）。
+      'body.dsh-dialog-open #dsh-theme-pet{display:none!important}',
+      '.dsh-pet-actor,.dsh-pet-prop{position:absolute;left:0;top:0;pointer-events:auto;cursor:grab;will-change:transform}',
+      '.dsh-pet-actor:active,.dsh-pet-prop:active{cursor:grabbing}',
+      // flip 层与 figure 层必须分开：**镜像（内联 transform）绝不能和跑步动画（keyframes）
+      // 放在同一个元素上** —— CSS 动画会覆盖内联 transform，放在一层就会"朝左跑时镜像
+      // 失效、倒着跑"（真机事故）。尺寸由 buildPetStage 按注册表写内联（每只宠物不同）。
+      '.dsh-pet-flip,.dsh-pet-figure{display:block;width:100%;height:100%}',
+      '.dsh-pet-side,.dsh-pet-front{display:block;width:100%;height:100%}',
+      '.dsh-pet-front{display:none}',
+      '.dsh-pet-react .dsh-pet-side{display:none}',
+      '.dsh-pet-react .dsh-pet-front{display:block}',
+      // 眨眼：所有宠物共用（markup 里带 dsh-pet-eye 类的眼睛都会眨）。
+      '.dsh-pet-eye{transform-box:fill-box;transform-origin:center;animation:dsh-pet-blink 4.6s infinite}',
+      '@keyframes dsh-pet-blink{0%,91%,94.5%,100%{transform:scaleY(1)}92.8%{transform:scaleY(.12)}}',
+      // 待机微动画锚点（幅度刻意克制："活着"，不是"表演"）；origin 由各宠物 markup 内联。
+      '.dsh-pet-tail{animation:dsh-pet-wag 1.5s ease-in-out infinite}',
+      '@keyframes dsh-pet-wag{from{transform:rotate(-7deg)}to{transform:rotate(9deg)}}',
+      '.dsh-pet-ear{animation:dsh-pet-ear-flop 3.4s ease-in-out infinite}',
+      '@keyframes dsh-pet-ear-flop{0%,86%,100%{transform:rotate(0)}91%{transform:rotate(7deg)}96%{transform:rotate(-5deg)}}',
+      '.dsh-pet-wing{animation:dsh-pet-wing-idle 3s ease-in-out infinite}',
+      '@keyframes dsh-pet-wing-idle{0%,88%,100%{transform:rotate(0)}93%{transform:rotate(-8deg)}}',
+      '.dsh-pet-belly{animation:dsh-pet-breathe 3.8s ease-in-out infinite}',
+      '@keyframes dsh-pet-breathe{0%,100%{transform:scale(1)}50%{transform:scale(1.025)}}',
+      // 跑动（run 步态）：腿部摆动 + 身体起伏。
+      '@keyframes dsh-pet-gallop-a{0%,100%{transform:rotate(17deg)}50%{transform:rotate(-17deg)}}',
+      '@keyframes dsh-pet-gallop-b{0%,100%{transform:rotate(-15deg)}50%{transform:rotate(15deg)}}',
+      '.dsh-pet-run .dsh-pet-leg-a{animation:dsh-pet-gallop-a .3s linear infinite}',
+      '.dsh-pet-run .dsh-pet-leg-b{animation:dsh-pet-gallop-b .3s linear infinite}',
+      '.dsh-pet-run .dsh-pet-figure{animation:dsh-pet-bob .3s ease-in-out infinite}',
+      '@keyframes dsh-pet-bob{0%,100%{transform:translateY(0)}50%{transform:translateY(-1.6px)}}',
+      // 摇摆步态（企鹅/熊猫）：身体左右摇；不挂腿部动画（脚贴地）。
+      '.dsh-pet-waddle .dsh-pet-figure{animation:dsh-pet-rock .46s ease-in-out infinite}',
+      '@keyframes dsh-pet-rock{0%,100%{transform:rotate(-4deg)}50%{transform:rotate(4deg)}}',
+      // 蹦跳步态（兔）：无循环类，起伏由运行时驱动（petRun.lift），落地即脚印。
+      // 戳一下：正面像 + 两次小跳；加油/庆祝/精神一下共用这条 hop（关键帧在后）。
+      '@keyframes dsh-pet-hop{0%,100%{transform:translateY(0)}30%{transform:translateY(-5px)}60%{transform:translateY(-2px)}}',
+      '.dsh-pet-react .dsh-pet-figure{animation:dsh-pet-hop .55s ease-in-out 2}',
+      '.dsh-pet-cheer .dsh-pet-figure{animation:dsh-pet-hop .5s ease-in-out 2}',
+      '.dsh-pet-perk .dsh-pet-figure{animation:dsh-pet-perk .9s ease-out 1}',
+      '@keyframes dsh-pet-perk{0%{transform:scale(1)}30%{transform:scale(1.045)}100%{transform:scale(1)}}',
+      // 名牌：opacity/visibility 显隐 + 隐藏侧 1.2s 延迟。实机验收：鼠标从宠物
+      // 移向「改名/戳一下」的途中要穿过名牌与宠物之间的 5px 空隙，hover 一断名牌
+      // 就消失。两处纯 CSS 的修法（不引 JS 定时器，符合有界性纪律）：
+      //   · ::before 是跨过空隙的**透明桥**——名牌是 actor 的子元素，鼠标在桥上
+      //     时 actor:hover 仍成立，可以一路走上名牌；
+      //   · 隐藏侧 visibility 延迟 1.2s：离开 actor 后名牌仍可交互一小会儿，
+      //     鼠标来得及走上去。显示侧 delay 归零（transition-delay 作用于全部属性）。
+      '.dsh-pet-tag{display:inline-flex;position:absolute;left:50%;bottom:calc(100% + 5px);',
+      'transform:translateX(-50%);pointer-events:auto;white-space:nowrap;z-index:3;',
+      'align-items:center;gap:4px;padding:3px 6px;border-radius:8px;background:rgba(40,33,28,.92);',
+      'color:#fff;font:11.5px/1.5 system-ui,"Segoe UI","Microsoft YaHei",sans-serif;',
+      'box-shadow:0 3px 10px rgba(0,0,0,.22);opacity:0;visibility:hidden;',
+      'transition:opacity .18s ease,visibility 0s linear 1.2s}',
+      '.dsh-pet-tag::before{content:"";position:absolute;left:0;right:0;bottom:-12px;height:12px}',
+      '.dsh-pet-actor:hover .dsh-pet-tag,.dsh-pet-tag.dsh-pet-editing{opacity:1;visibility:visible;transition-delay:0s}',
+      '.dsh-pet-name{max-width:96px;overflow:hidden;text-overflow:ellipsis}',
+      '.dsh-pet-actions{display:inline-flex;gap:4px}',
+      '.dsh-pet-tag button{border:none;border-radius:5px;padding:1px 7px;cursor:pointer;',
+      'font:11px/1.6 inherit;color:#fff;background:rgba(255,255,255,.18)}',
+      '.dsh-pet-tag button:hover{background:rgba(255,255,255,.34)}',
+      '.dsh-pet-input{display:none;width:88px;border:none;border-radius:5px;padding:2px 6px;',
+      'font:11.5px/1.5 inherit;color:#2b2320}',
+      '.dsh-pet-editing .dsh-pet-name,.dsh-pet-editing .dsh-pet-actions{display:none}',
+      '.dsh-pet-editing .dsh-pet-input{display:block}',
+      // 拖拽中的反馈：影子加深，让人看清"它离地了"。
+      '.dsh-pet-dragging .dsh-pet-figure{filter:drop-shadow(0 7px 6px rgba(0,0,0,.28))}',
+      // 脚印：随物种换形状与颜色（注册表 trail.art），落一次淡一次；
+      // 超时由 JS 兜底回收（reduced-motion 关掉动画时也成立）。
+      '.dsh-pet-trailmark{position:absolute;left:0;top:0;opacity:.5;',
+      'pointer-events:none;animation:dsh-pet-trail-fade 3.4s ease-out forwards}',
+      '@keyframes dsh-pet-trail-fade{0%{opacity:.5}70%{opacity:.34}100%{opacity:0}}',
+      // 叫声/闲聊/加油气泡。
+      '.dsh-pet-bubble{position:absolute;left:0;top:0;pointer-events:none;white-space:nowrap;',
+      'padding:2px 8px;border-radius:9px;background:#fff;color:#3B2B23;border:1px solid #E4CBA2;',
+      'font:12px/1.6 system-ui,"Segoe UI","Microsoft YaHei",sans-serif;',
+      'box-shadow:0 2px 7px rgba(0,0,0,.16);animation:dsh-pet-bubble 1.15s ease-out forwards}',
+      '@keyframes dsh-pet-bubble{0%{opacity:0;transform-origin:bottom left;scale:.6}',
+      '14%{opacity:1;scale:1}78%{opacity:1;scale:1}100%{opacity:0;scale:1;translate:0 -9px}}',
+      '@media (prefers-reduced-motion:reduce){',
+      `#${PET_STAGE_ID} *{animation:none!important}`,
+      // 名牌的 visibility 延迟是"鼠标能走上去"的功能窗口（透明桥），不是装饰动画：
+      // reduced-motion 只去掉 opacity 淡入淡出，把交互窗口原样保留。
+      `#${PET_STAGE_ID} .dsh-pet-tag{transition:visibility 0s linear 1.2s}}`,
+    ].join('\n')
+
+    /**
+     * 挂件层样式表的就位与自愈（与 ambient 的 ensureAmbientStylesheet 同一策略）：
+     * 每次同步都检查，不在就装、内容陈旧就换 —— "一次安装应该能活下来"这个假设
+     * 在这台机器上已经失败过一次。
+     * @returns 样式表元素，或 null（没有 document）。
+     */
+    function ensurePetStylesheet() {
+      if (typeof document === 'undefined') return null
+      const existing = document.querySelector('style[data-plugin-css="theme-gallery/pet"]')
+      if (existing !== null) {
+        if (existing.textContent === PET_CSS) return existing
+        existing.remove()
+      }
+      const tag = document.createElement('style')
+      tag.dataset.plugin = 'theme-gallery'
+      tag.dataset.pluginCss = 'theme-gallery/pet'
+      tag.textContent = PET_CSS
+      if (document.head !== null) document.head.append(tag)
+      else document.documentElement.append(tag)
+      return tag
+    }
+
+    /* ── 活性机制的常量与状态（闲聊 / 打字回头 / 生成中加油）───────────────────
+     *
+     * 三重有界：闲聊是**单个可取消句柄**（petChatterTimer，任意时刻至多一个）；
+     * 加油/庆祝只挂短时类名（句柄进 petTimers）；打字回头是 document 上唯一的
+     * input 监听（搭舞台才装、拆舞台即卸）。任何一级检测失效都静默降级。
+     */
+
+    /** 闲聊：距最近互动至少 2 分钟才可能出现；之后每 2.5 分钟一个窗口。 */
+    const CHATTER_FIRST_MS = 120000
+    const CHATTER_GAP_MS = 150000
+    /** 窗口内的随机延迟上限：避免"整点报时"的机械感，也挡住测试桩的立即定时器。 */
+    const CHATTER_JITTER_MS = 90000
+    /** 最近一次互动时刻（戳/拖/切宠/改名/加油都算）；0 = 尚未发生过。 */
+    let petLastInteractAt = 0
+    /** 闲聊的单句柄；0 = 无排程。 */
+    let petChatterTimer = 0
+
+    /** 打字回头：两次反应至少隔 15s；监听只此一个。 */
+    const PET_TYPE_REACT_MS = 15000
+    let petLastTypingAt = 0
+
+    /**
+     * "模型正在生成"的 DOM 信号：composer 主按钮在生成中会把 aria-label 置为
+     * 「停止生成」/「Stop generating」（app.asar 内嵌 InputBar 实测，无哈希、
+     * 框架有意设置的语义属性 —— SKILL §13 认可的稳定钩子类型）。
+     * 查不到 = 未在生成（或界面改版），两种都按"闲"处理，静默降级。
+     */
+    const PET_WORKING_SELECTORS = [
+      'button[aria-label="停止生成"]',
+      'button[aria-label="Stop generating"]',
+    ]
+    /** 最近一次确认"在生成"的时刻；用于"忙过又闲下来"才庆祝。 */
+    let petLastWorkedAt = 0
+
+    /**
+     * 记一次互动并重置闲聊计时。三机制共用的时间轴：宠物"和你玩过"之后，
+     * 悄悄话才愿意再等一会儿。
+     */
+    function petNoteInteraction() {
+      petLastInteractAt = Date.now()
+      schedulePetChatter()
+    }
+
+    /** 排一次闲聊（先清旧句柄；舞台不在就不排）。 */
+    function schedulePetChatter() {
+      if (petStage === null) return
+      if (typeof window.clearTimeout === 'function') window.clearTimeout(petChatterTimer)
+      const base = petLastInteractAt === 0 ? CHATTER_FIRST_MS : CHATTER_GAP_MS
+      const wait = base + Math.floor(Math.random() * CHATTER_JITTER_MS)
+      petChatterTimer = window.setTimeout(petChatterTick, wait)
+    }
+
+    /**
+     * 闲聊到点。三道闸都过才冒泡：舞台在、宠物待机、页面可见、距最近互动 ≥ 首闸。
+     * 时间闸同时是**测试闸**：桩的 drive() 会把定时器立即执行，而桩里只过去了几毫秒，
+     * 闸门挡住 → 测试不会看到伪闲聊（断言见 check-boot-path）。
+     */
+    function petChatterTick() {
+      petChatterTimer = 0
+      if (petStage === null) return
+      if (petRun.mode !== 'idle') { schedulePetChatter(); return }
+      if (typeof document !== 'undefined' && document.visibilityState === 'hidden') {
+        schedulePetChatter()
+        return
+      }
+      const idleFor = Date.now() - petLastInteractAt
+      if (petLastInteractAt === 0 || idleFor < CHATTER_FIRST_MS) { schedulePetChatter(); return }
+      const kind = petKindById(petRun.kindId)
+      const line = kind.chat[Math.floor(Math.random() * kind.chat.length)]
+      if (typeof line === 'string' && line !== '') petBubble(line)
+      petLastInteractAt = Date.now()
+      schedulePetChatter()
+    }
+
+    /** 是否检出"生成中"信号（找不到 = false，绝不抛错）。 */
+    function petWorkingSignal() {
+      if (typeof document === 'undefined' || typeof document.querySelector !== 'function') return false
+      try {
+        for (const selector of PET_WORKING_SELECTORS) {
+          if (document.querySelector(selector) !== null) return true
+        }
+      } catch {
+        return false
+      }
+      return false
+    }
+
+    /** 生成开始：冒加油台词 + 原地小跳两下（CSS 两次迭代，无 JS 循环）。 */
+    function petCheer() {
+      if (petStage === null || petRun.mode === 'drag') return
+      petNoteInteraction()
+      petBubble(petKindById(petRun.kindId).cheer)
+      petFlash('dsh-pet-cheer', 1700)
+    }
+
+    /** 生成结束（忙过又闲下来）：冒完成台词 + 小跳一下。 */
+    function petCelebrate() {
+      if (petStage === null || petRun.mode === 'drag') return
+      petNoteInteraction()
+      petBubble(petKindById(petRun.kindId).done)
+      petFlash('dsh-pet-cheer', 900)
+    }
+
+    /** 在宠物身上挂一个短时类名（挂/摘各一次，句柄入 petTimers，拆台统一清）。 */
+    function petFlash(cls, ms) {
+      if (petRefs.actor === null) return
+      petRefs.actor.classList.add(cls)
+      petTimers.push(window.setTimeout(() => {
+        if (petRefs.actor !== null) petRefs.actor.classList.remove(cls)
+      }, ms))
+    }
+
+    /**
+     * 打字回头：用户在聊天输入框里敲字（节流 15s 内不重复）→ 宠物转身面向输入框，
+     * 精神一下。反应是锦上添花，任何失败都吞掉保持安静。
+     */
+    function petOnTyping(event) {
+      try {
+        if (petStage === null || petRun.mode === 'drag') return
+        const target = event?.target
+        if (target === undefined || target === null) return
+        const isComposer = target.isContentEditable === true || target.tagName === 'TEXTAREA'
+        if (!isComposer) return
+        const now = Date.now()
+        if (now - petLastTypingAt < PET_TYPE_REACT_MS) return
+        petLastTypingAt = now
+        const box = petAnchorBox()
+        if (box !== null && petRefs.actor !== null) {
+          const kind = petKindById(petRun.kindId)
+          const centre = petRun.x + petDisplaySize(kind).w / 2
+          const nextDir = (box.left + box.right) / 2 > centre ? 1 : -1
+          if (nextDir !== petRun.dir) {
+            petRun.dir = nextDir
+            applyPetPositions()
+          }
+        }
+        petFlash('dsh-pet-perk', 900)
+      } catch {
+        // 反应失败不值得打扰任何人。
+      }
+    }
+
+    /* ── 弹窗打开时隐藏挂件（用户 2026-09-27 定）────────────────────────────
+     *
+     * 挂件层挂 body、z-index 1200，高于设置等模态弹窗 —— 弹窗一开，小雪兔就浮在
+     * 弹窗内容上方（实测读数：设置 → 通用设置任何分节都如此）。检测走**语义属性**
+     * （role="dialog" / aria-modal / 原生 <dialog>），绝不碰框架哈希类名（§13）；
+     * 任何弹窗都触发 —— 不止设置弹窗，以后别的确认框也不会被挂件挡。
+     * observer 是事件驱动（childList/attributes），随舞台起停 —— 有界；
+     * body 上的标记类只在挂件存活期间存在，拆除时一并清掉。
+     */
+
+    /** 弹窗隐藏的 observer 句柄；undefined = 未安装。 */
+    let petDialogObserver
+
+    /** 现在有没有模态弹窗开着（语义选择器，一次查询）。 */
+    function petDialogOpen() {
+      try {
+        return typeof document !== 'undefined' && document !== null
+          && document.querySelector('dialog[open], [role="dialog"], [aria-modal="true"]') !== null
+      } catch {
+        return false
+      }
+    }
+
+    /**
+     * 把"弹窗开着"落成 body 标记类（PET_CSS 里一条规则据此藏挂件层）。
+     * @returns 弹窗是否开着（诊断读数用）。
+     */
+    function syncPetDialogHidden() {
+      const open = petDialogOpen()
+      try {
+        document.body?.classList?.toggle('dsh-dialog-open', open)
+      } catch {
+        // classList 不可用（极端桩）时挂件照常显示 —— 隐藏是体验优化，不是功能闸。
+      }
+      return open
+    }
+
+    /** 随舞台安装：装上即先同步一次，之后由 DOM 变化驱动。 */
+    function installPetDialogObserver() {
+      if (petDialogObserver !== undefined) return
+      if (typeof MutationObserver !== 'function') return
+      syncPetDialogHidden()
+      petDialogObserver = new MutationObserver(() => { syncPetDialogHidden() })
+      petDialogObserver.observe(document.body, {
+        childList: true, subtree: true,
+        attributes: true, attributeFilter: ['open', 'role', 'aria-modal', 'class'],
+      })
+    }
+
+    /** 随舞台拆除：断开 observer、清掉标记类 —— 挂件不在了就不该留痕迹。 */
+    function removePetDialogObserver() {
+      if (petDialogObserver === undefined) return
+      try { petDialogObserver.disconnect() } catch {
+        // 断开失败只留一个空 observer，下一次安装会覆盖它。
+      }
+      petDialogObserver = undefined
+      try {
+        document.body?.classList?.remove?.('dsh-dialog-open')
+      } catch {
+        // 同上：清理失败不影响功能。
+      }
+    }
+
+    /**
+     * 拆掉舞台与其样式表，清空运行态。
+     *
+     * 定时器、闲聊句柄、document 监听一并清掉：任何一句话都不许对已拆除的节点说。
+     */
+    function removePetStage() {
+      removePetDialogObserver()
+      for (const handle of petTimers) window.clearTimeout(handle)
+      petTimers = []
+      if (typeof window.clearTimeout === 'function') window.clearTimeout(petChatterTimer)
+      petChatterTimer = 0
+      if (typeof document !== 'undefined' && typeof document.removeEventListener === 'function') {
+        document.removeEventListener('input', petOnTyping, true)
+      }
+      if (petStage !== null) petStage.remove()
+      petStage = null
+      for (const key of Object.keys(petRefs)) petRefs[key] = null
+      petTrailCount = 0
+      petBubbleCount = 0
+      petRun.mode = 'idle'
+      petRun.dragging = null
+      petRun.anchorKey = ''
+      petRun.lastAt = 0
+      petRun.kindId = ''
+      petRun.lift = 0
+      petRun.hopFrac = 0
+      petLastInteractAt = 0
+      petLastTypingAt = 0
+      // 注意：petRun.working / petLastWorkedAt / everWorked **不**随舞台重置 ——
+      // "模型在不在生成"是对应用的观察，不是舞台的状态；重置它会让换宠/重搭期间的
+      // 边沿（尤其忙→闲的完成庆祝）静默丢失。陈旧触发由庆祝的 60s 时效窗挡住。
+    }
+
+    /** 把宠物与道具画到它们该在的位置（transform-only，不触发布局；hop 抬升只进显示）。 */
+    function applyPetPositions() {
+      if (petRefs.actor === null || petRefs.prop === null || petRefs.flip === null) return
+      const kind = petKindById(petRun.kindId)
+      petRefs.actor.style.transform = `translate(${Math.round(petRun.x)}px,${Math.round(petRun.y - petRun.lift)}px)`
+      petRefs.prop.style.transform
+        = `translate(${Math.round(petRun.propX - petPropDisplaySize(kind).w / 2)}px,${Math.round(petRun.propY)}px)`
+      // 镜像写在独立的 flip 层 —— 绝不与跑步动画同层（动画会覆盖内联 transform，
+      // 那正是"朝左跑却倒着跑"的事故根因）。
+      petRefs.flip.style.transform = petRun.dir === 1 ? 'none' : 'scaleX(-1)'
+    }
+
+    /**
+     * 跑动类名按步态挂：run → 腿部摆动 + 起伏；waddle → 身体左右摇；
+     * hop 不挂循环类（起伏由运行时驱动，落地节奏即脚步）。
+     */
+    function petMotionClass() {
+      return petKindById(petRun.kindId).motion === 'waddle' ? 'dsh-pet-waddle' : 'dsh-pet-run'
+    }
+
+    /** 开始跑向道具（幂等：跑动中 / 拖拽中 / 已在道具旁都不会白跑一轮）。 */
+    function petStartRun() {
+      if (petStage === null || petRun.mode === 'run' || petRun.mode === 'drag') return
+      if (petDistanceToProp() <= 5) {
+        petRun.mode = 'idle'
+        return
+      }
+      petRun.mode = 'run'
+      petRun.trailDist = 0
+      petRun.hopFrac = 0
+      petRun.lift = 0
+      petRun.lastAt = 0
+      petRefs.actor.classList.add(petMotionClass())
+      // 复用工厂级单帧助手 step()：本文件的 requestAnimationFrame 预算因此不加一。
+      step(petTick)
+    }
+
+    /** 宠物（左上角）到道具（中心）的直线距离（显示坐标系）。 */
+    function petDistanceToProp() {
+      const kind = petKindById(petRun.kindId)
+      return Math.hypot(petRun.propX - petRun.x,
+        (petRun.propY + petPropDisplaySize(kind).h / 2) - (petRun.y + petDisplaySize(kind).h / 2))
+    }
+
+    /** 停下（回到待机）。步态类名一并摘掉，腿/摇摆动画随之停止。 */
+    function petStopRun() {
+      if (petRefs.actor !== null) {
+        petRefs.actor.classList.remove('dsh-pet-run')
+        petRefs.actor.classList.remove('dsh-pet-waddle')
+      }
+      petRun.mode = 'idle'
+      petRun.lastAt = 0
+      petRun.lift = 0
+    }
+
+    /**
+     * 跑动的每一帧。只在 mode === 'run' 时自续，停下即断 —— 这条循环有界：
+     * 终点是道具，距离单调收敛，超时（标签页隐藏时 rAF 自动暂停）也不会累积。
+     * 移动是**二维**的：朝道具的直线方向走，头始终朝向它（水平分量定镜像）。
+     * 三种步态在这里分岔：run/waddle 直线推进（后者靠 CSS 摇摆）；hop 抛物线蹦跳
+     * （hopFrac 是 0..1 的相位，lift 只影响显示坐标，落地一枚脚印）。
+     */
+    function petTick() {
+      if (petStage === null || petRun.mode !== 'run') return
+      const kind = petKindById(petRun.kindId)
+      const now = Date.now()
+      const dt = petRun.lastAt === 0 ? 0.016 : Math.min((now - petRun.lastAt) / 1000, 0.064)
+      // 防线：任何非有限数进来都立即停车并留痕 —— NaN 若混进位置，宠物会凭空消失，
+      // 而"消失"没有任何报错。宁可停下来让面板/控制台说一句话。
+      if (!Number.isFinite(dt) || !Number.isFinite(petRun.x) || !Number.isFinite(petRun.y)
+        || !Number.isFinite(petRun.propX) || !Number.isFinite(petRun.propY)) {
+        console.error('[theme-gallery] pet run got a non-finite number; stopping the run loop.'
+          + ` dt=${dt} pet=(${petRun.x},${petRun.y}) prop=(${petRun.propX},${petRun.propY})`)
+        petStopRun()
+        return
+      }
+      petRun.lastAt = now
+      const dx = petRun.propX - petRun.x
+      const dy = (petRun.propY + petPropDisplaySize(kind).h / 2) - (petRun.y + petDisplaySize(kind).h / 2)
+      const dist = Math.hypot(dx, dy)
+      if (dist <= 5) {
+        petStopRun()
+        return
+      }
+      // 先调头再跑：水平朝向由水平分量决定（几乎竖直的短途不改变朝向）。
+      if (dx > 1) petRun.dir = 1
+      else if (dx < -1) petRun.dir = -1
+      const pace = Math.min(kind.speed * dt, dist)
+      petRun.x += (dx / dist) * pace
+      petRun.y += (dy / dist) * pace
+      if (kind.motion === 'hop') {
+        // 一跳 = PET_HOP_LEN_PX 的水平路程：相位推进，抛物线抬升，落地留印。
+        petRun.hopFrac += pace / PET_HOP_LEN_PX
+        if (petRun.hopFrac >= 1) {
+          petRun.hopFrac -= 1
+          petRun.trailSide = -petRun.trailSide
+          dropTrail()
+        }
+        petRun.lift = Math.round(Math.sin(Math.PI * Math.min(petRun.hopFrac, 1)) * PET_HOP_LIFT_PX)
+      } else {
+        petRun.lift = 0
+        petRun.trailDist += pace
+        if (petRun.trailDist >= kind.trail.everyPx) {
+          petRun.trailDist = 0
+          petRun.trailSide = -petRun.trailSide
+          dropTrail()
+        }
+      }
+      applyPetPositions()
+      step(petTick)
+    }
+
+    /**
+     * 落一枚脚印（随物种换形状与颜色），落在宠物当前脚下；
+     * 超时由 JS 兜底回收，活节点数有上限。
+     */
+    function dropTrail() {
+      if (petStage === null || petTrailCount >= PET_TRAIL_MAX) return
+      const kind = petKindById(petRun.kindId)
+      const display = petDisplaySize(kind)
+      const mark = document.createElement('span')
+      mark.className = 'dsh-pet-trailmark'
+      mark.innerHTML = `<svg viewBox="0 0 ${kind.trail.w} ${kind.trail.h}" width="${kind.trail.w}"`
+        + ` height="${kind.trail.h}" aria-hidden="true">${kind.trail.art}</svg>`
+      mark.style.transform = `translate(${Math.round(petRun.x + display.w / 2 + kind.trail.side * petRun.trailSide) - kind.trail.w / 2}px,`
+        + `${Math.round(petRun.y + display.h) - kind.trail.h + 1}px)`
+      petStage.append(mark)
+      petTrailCount += 1
+      window.setTimeout(() => {
+        mark.remove()
+        petTrailCount = Math.max(0, petTrailCount - 1)
+      }, PET_TRAIL_FADE_MS + 200)
+    }
+
+    /** 冒一句气泡（叫声/闲聊/加油共用；文案是常量；数量有上限）。 */
+    function petBubble(text) {
+      if (petStage === null || petBubbleCount >= PET_BUBBLE_MAX) return
+      const kind = petKindById(petRun.kindId)
+      const bubble = document.createElement('span')
+      bubble.className = 'dsh-pet-bubble'
+      bubble.textContent = String(text)
+      bubble.style.transform = `translate(${Math.round(petRun.x) + Math.round(petDisplaySize(kind).w) + 6}px,`
+        + `${Math.round(petRun.y) - 30}px)`
+      petStage.append(bubble)
+      petBubbleCount += 1
+      window.setTimeout(() => {
+        bubble.remove()
+        petBubbleCount = Math.max(0, petBubbleCount - 1)
+      }, 1250)
+    }
+
+    /**
+     * 戳一下：宠物转过身面对用户，说两句它的口头禅，然后该干嘛干嘛（刚才在跑就接着跑）。
+     * react 期间再戳是空操作 —— 不然定时器会互相叠。
+     */
+    function petReact() {
+      if (petStage === null || petRun.mode === 'drag' || petRun.mode === 'react') return
+      const kind = petKindById(petRun.kindId)
+      petNoteInteraction()
+      petRun.reactWasRunning = petRun.mode === 'run'
+      petStopRun()
+      petRun.mode = 'react'
+      petRefs.actor.classList.add('dsh-pet-react')
+      petBubble(kind.react.lines[0])
+      petTimers.push(window.setTimeout(() => petBubble(kind.react.lines[1]), Math.round(kind.react.ms * 0.4)))
+      petTimers.push(window.setTimeout(() => {
+        // react 不可重入（mode 门在函数开头），所以此刻挂起的定时器只有这一组：
+        // 直接清空即可，数组不会随戳的次数增长。
+        petTimers = []
+        if (petRefs.actor === null) return
+        petRefs.actor.classList.remove('dsh-pet-react')
+        petRun.mode = 'idle'
+        if (petRun.reactWasRunning || petDistanceToProp() > 5) petStartRun()
+      }, kind.react.ms))
+    }
+
+    /** 点「改名」：名牌切换成输入框并钉住显示（不依赖悬停）。 */
+    function petStartRename() {
+      if (petRefs.tag === null || petRefs.input === null) return
+      const kind = petKindById(petRun.kindId)
+      petRefs.tag.classList.add('dsh-pet-editing')
+      petRefs.input.value = readPetState().names[kind.id] ?? kind.home
+      try {
+        petRefs.input.focus()
+        petRefs.input.select()
+      } catch {
+        // 无焦点可给（极端环境）就跳过；输入框仍在，点击即得焦点。
+      }
+    }
+
+    /** 提交改名：空值回退旧名，最长 10 字；textContent 写回，注入面为零；名字按宠记忆。 */
+    function petCommitRename() {
+      if (petRefs.tag === null || petRefs.input === null) return
+      if (!petRefs.tag.classList.contains('dsh-pet-editing')) return
+      petRefs.tag.classList.remove('dsh-pet-editing')
+      const kind = petKindById(petRun.kindId)
+      const state = readPetState()
+      const current = state.names[kind.id] ?? kind.home
+      const raw = String(petRefs.input.value ?? '').trim().slice(0, 10)
+      const name = raw === '' ? current : raw
+      savePetState({ names: { ...state.names, [kind.id]: name } })
+      if (petRefs.name !== null) petRefs.name.textContent = name
+      petNoteInteraction()
+    }
+
+    /** 取消改名（Esc）。 */
+    function petCancelRename() {
+      if (petRefs.tag !== null) petRefs.tag.classList.remove('dsh-pet-editing')
+    }
+
+    /**
+     * 开始拖宠物 / 拖道具。指针捕获尽量用上（指针出了窗口也能收到 pointerup），
+     * 事件监听挂在被捕获元素上、结束时成对摘除 —— 不给全局留下常驻监听。
+     * @param event - pointerdown 事件（桩环境可能缺字段，逐项容错）。
+     * @param which - 'actor' 或 'prop'。
+     */
+    function petDragStart(event, which) {
+      try {
+        if (petStage === null || petRun.mode === 'react') return
+        const point = petPointOf(event)
+        if (point === null) return
+        const target = event.currentTarget
+        if (target === undefined || target === null) return
+        // 先停跑、再进拖拽态 —— 顺序不能反：petStopRun 会把 mode 写回 idle，
+        // 而宠物移动的每一帧都靠 mode === 'drag' 才跟手（反着写，拖动就静默失效）。
+        petStopRun()
+        petRun.mode = 'drag'
+        petRun.dragging = which
+        petRun.dragDX = point.x - (which === 'actor' ? petRun.x : petRun.propX)
+        petRun.dragDY = point.y - (which === 'actor' ? petRun.y : petRun.propY)
+        petStage.classList.add('dsh-pet-dragging')
+        if (typeof target.setPointerCapture === 'function' && typeof event.pointerId === 'number') {
+          try { target.setPointerCapture(event.pointerId) } catch { /* 指针可能已经释放 */ }
+        }
+        const move = (moveEvent) => petDragMove(moveEvent)
+        const end = (endEvent) => {
+          target.removeEventListener('pointermove', move)
+          target.removeEventListener('pointerup', end)
+          target.removeEventListener('pointercancel', end)
+          petDragEnd(endEvent)
+        }
+        target.addEventListener('pointermove', move)
+        target.addEventListener('pointerup', end)
+        target.addEventListener('pointercancel', end)
+      } catch (error) {
+        console.error('[theme-gallery] pet drag could not start:', error)
+      }
+    }
+
+    /** 拖动中：全屏二维跟手（x / y 都自由，钳位只保证不出屏）。 */
+    function petDragMove(event) {
+      if (petRun.mode !== 'drag') return
+      const point = petPointOf(event)
+      if (point === null) return
+      const viewport = petViewport()
+      const kind = petKindById(petRun.kindId)
+      const display = petDisplaySize(kind)
+      const propDisplay = petPropDisplaySize(kind)
+      if (petRun.dragging === 'actor') {
+        // 宠物的 transform 用左上角坐标，钳位按左上角算（右/下各留出它的宽高）。
+        petRun.x = petClampX(point.x - petRun.dragDX, 0, viewport.width - display.w)
+        petRun.y = petClampX(point.y - petRun.dragDY, 0, viewport.height - display.h)
+      } else {
+        petRun.propX = petClampX(point.x - petRun.dragDX, propDisplay.w / 2, viewport.width)
+        petRun.propY = petClampX(point.y - petRun.dragDY, 0, viewport.height - propDisplay.h)
+      }
+      applyPetPositions()
+    }
+
+    /**
+     * 松手：记住新位置（视口相对偏移，重启/缩放后自愈），然后宠物跑向道具
+     * （拖道具同理 —— 道具到哪它追到哪，直线跑过去）。
+     */
+    function petDragEnd() {
+      if (petStage === null) return
+      petStage.classList.remove('dsh-pet-dragging')
+      const which = petRun.dragging
+      petRun.dragging = null
+      petRun.mode = 'idle'
+      const viewport = petViewport()
+      if (which === 'actor') {
+        savePetState({
+          placed: true,
+          pet: { dx: Math.round(petRun.x - viewport.width), dy: Math.round(petRun.y - viewport.height) },
+        })
+      } else if (which === 'prop') {
+        savePetState({
+          placed: true,
+          prop: { dx: Math.round(petRun.propX - viewport.width), dy: Math.round(petRun.propY - viewport.height) },
+        })
+      }
+      petNoteInteraction()
+      applyPetPositions()
+      petStartRun()
+    }
+
+    /**
+     * 搭建舞台。结构节点全部用 createElement 逐个搭建（事件挂得上、桩环境找得到），
+     * 美术件按注册表包裹注入（petSvg/petPropSvg）；名字用 textContent 写入 ——
+     * 用户输入永远不进 HTML 字符串。尺寸（每只宠物不同）写内联，CSS 只管布局。
+     */
+    function buildPetStage() {
+      const state = readPetState()
+      const kind = petKindById(state.kind)
+      const display = petDisplaySize(kind)
+      const propDisplay = petPropDisplaySize(kind)
+      const stage = document.createElement('div')
+      stage.id = PET_STAGE_ID
+      stage.dataset.plugin = 'theme-gallery'
+      stage.dataset.petOwner = PET_OWNER
+      stage.dataset.petKind = kind.id
+
+      const prop = document.createElement('div')
+      prop.className = 'dsh-pet-prop'
+      prop.style.width = `${propDisplay.w}px`
+      prop.style.height = `${propDisplay.h}px`
+      prop.innerHTML = petPropSvg(kind)
+
+      const actor = document.createElement('div')
+      actor.className = 'dsh-pet-actor'
+      actor.style.width = `${display.w}px`
+      actor.style.height = `${display.h}px`
+
+      // flip 层（水平镜像，内联 transform）与 figure 层（跑步/跳跃动画）必须分开 ——
+      // 同层时 CSS 动画覆盖内联 transform，宠物会朝左跑却头朝右（真机事故）。
+      const flip = document.createElement('span')
+      flip.className = 'dsh-pet-flip'
+      const figure = document.createElement('span')
+      figure.className = 'dsh-pet-figure'
+      figure.innerHTML = petSvg(kind, 'side', 'dsh-pet-side') + petSvg(kind, 'front', 'dsh-pet-front')
+      flip.append(figure)
+
+      const tag = document.createElement('span')
+      tag.className = 'dsh-pet-tag'
+      const name = document.createElement('span')
+      name.className = 'dsh-pet-name'
+      const actions = document.createElement('span')
+      actions.className = 'dsh-pet-actions'
+      const renameButton = document.createElement('button')
+      renameButton.type = 'button'
+      renameButton.className = 'dsh-pet-rename'
+      renameButton.textContent = '改名'
+      const pokeButton = document.createElement('button')
+      pokeButton.type = 'button'
+      pokeButton.className = 'dsh-pet-poke'
+      pokeButton.textContent = '戳一下'
+      const input = document.createElement('input')
+      input.className = 'dsh-pet-input'
+      input.maxLength = 10
+      input.setAttribute('aria-label', `${kind.home}的名字`)
+      actions.append(renameButton, pokeButton)
+      tag.append(name, actions, input)
+      actor.append(tag, flip)
+      stage.append(prop, actor)
+
+      petRefs.actor = actor
+      petRefs.prop = prop
+      petRefs.flip = flip
+      petRefs.figure = figure
+      petRefs.tag = tag
+      petRefs.name = name
+      petRefs.input = input
+      petRefs.actor.addEventListener('pointerdown', (event) => petDragStart(event, 'actor'))
+      petRefs.prop.addEventListener('pointerdown', (event) => petDragStart(event, 'prop'))
+      // 名牌里的按钮不许触发拖拽：按住"戳一下"把宠物拖着走，谁都会觉得坏了。
+      for (const control of [renameButton, pokeButton, input]) {
+        control.addEventListener('pointerdown', (event) => {
+          if (event !== undefined && typeof event.stopPropagation === 'function') event.stopPropagation()
+        })
+      }
+      renameButton.addEventListener('click', () => petStartRename())
+      pokeButton.addEventListener('click', () => petReact())
+      input.addEventListener('keydown', (event) => {
+        if (event?.key === 'Enter') petCommitRename()
+        else if (event?.key === 'Escape') petCancelRename()
+      })
+      input.addEventListener('blur', () => petCommitRename())
+      name.textContent = state.names[kind.id] ?? kind.home
+      petRun.kindId = kind.id
+
+      petStage = stage
+      document.body.append(stage)
+      // 活性机制随舞台一起起停：打字监听装上、闲聊排一次（时间闸见 petChatterTick）。
+      if (typeof document !== 'undefined' && typeof document.addEventListener === 'function') {
+        document.addEventListener('input', petOnTyping, true)
+      }
+      // 弹窗隐藏挂件的 observer 同步起停（装上即先按当前状态同步一次）。
+      installPetDialogObserver()
+      schedulePetChatter()
+    }
+
+    /** 最近一次挂件同步的读数（面板诊断用，与 ambientReport 同一角色）。 */
+    let petReport
+
+    /**
+     * 把最近一次同步的读数写进 petReport。
+     * @param entry - 读数片段（enabled / stage / display / anchor / 几何 / css / note）。
+     */
+    function notePetReport(entry) {
+      petReport = { ...entry }
+    }
+
+    /** 面板上的挂件读数，一句话（与 describeAmbientReport 同一风格，刻意笨）。 */
+    function describePetReport() {
+      const r = petReport
+      if (r === undefined) return '挂件[尚未同步]'
+      const parts = [r.enabled === true ? '开' : '关', `舞台=${r.stage ?? '?'}`, `显示=${r.display === true ? '在' : '收'}`,
+        `锚点=${r.anchor ?? '?'}`, `品种=${r.kind ?? '-'}`, `活动=${r.activity ?? '-'}`]
+      if (r.right !== undefined) parts.push(`锚右=${r.right}`, `锚底=${r.bottom}`)
+      // 地面= 独立输出：视口回退（锚点断）时恰恰最需要这个读数来核对抬量 ——
+      // 旧实现把它挂在 锚右 那一支里，而 right 只在锚点找到时才写，回退时地面
+      // 读数跟着一起消失（读数通道静默断裂，实机核对无从做起）。
+      if (r.groundY !== undefined) parts.push(`地面=${r.groundY}`)
+      if (r.x !== undefined) parts.push(`宠x=${r.x}`, `宠y=${r.y ?? '?'}`, `道具x=${r.propX}`, `道具y=${r.propY ?? '?'}`)
+      parts.push(`样式=${r.css === true ? '在' : '缺'}`, `模式=${r.mode ?? '-'}`)
+      if (r.note !== undefined) parts.push(r.note)
+      return `挂件[${parts.join(' ')}]`
+    }
+
+    /**
+     * 面板上的挂件自检行。
+     *
+     * 挂件关闭时不产出行（不打扰）；开启时的**警告**（舞台没建出 / 被收起 / 样式缺失）
+     * 必须无条件到达面板 —— "开了但什么都不出现"正是本项目最典型的静默失败，
+     * 这一行就是它的可观测出口。
+     * @param petEnabled - store 里的挂件开关。
+     * @returns 一行自检文字，或 null（挂件关闭）。
+     */
+    function petLineOf(petEnabled) {
+      try {
+        if (petEnabled !== true) return null
+        const r = petReport
+        if (r === undefined || r.enabled !== true) return '⚠ 挂件已开启但尚未同步（syncPetStage 未运行）'
+        if (r.stage === 'absent') return `⚠ 挂件未建出舞台：${r.note ?? '锚点（输入框）未找到'}`
+        if (r.display !== true) return `⚠ 挂件舞台已建但被收起：锚点=${r.anchor}`
+        if (r.css !== true) return '⚠ 挂件样式表未生效（PET_CSS 不在文档中）'
+        return `挂件自检通过 · ${describePetReport()}`
+      } catch (error) {
+        return `⚠ 挂件自检失败: ${String(error && error.message ? error.message : error)}`
+      }
+    }
+
+    /** 与 sceneryLineIsWarning 同一条判据：⚠ 开头或带"失败"的行不算例行汇报。 */
+    function petLineIsWarning(line) {
+      return typeof line === 'string' && (line.startsWith('⚠') || line.includes('失败'))
+    }
+
+    /**
+     * 挂件层的同步入口：resync（每帧至多一次，与 ambient 共用节流）与开关切换都会进来。
+     *
+     * 幂等判据在最前面（规则 3）：几何指纹没变就一个字节都不写。输入框不在屏幕上
+     * （比如正看着别的面板）时挂件收起，等它回来 —— 收起不算状态变化。
+     * 每一条退出路径都写 petReport：挂件的失败形态就是"什么都不出现"，没有读数就永远查不下去。
+     *
+     * 二期新增两件事，都在一切写入之前完成判定：
+     *  · **换宠物**：localStorage 里的 kind 与舞台当前的 kindId 不一致 → 拆旧舞台、
+     *    按新宠物重建（缺省摆位 + 出场跑向道具由既有逻辑自然发生）。
+     *  · **生成中信号**（petWorkingSignal）在这里顺路检测 —— resync 本来就随 DOM
+     *    变化节流触发，不需要新观察器；上升沿加油、下降沿（忙过之后）庆祝。
+     */
+    function syncPetStage() {
+      if (typeof document === 'undefined') return
+      // 急停开关与 ambient 同源：config.ambient:false 把这层装饰一并停掉。
+      if (!petRun.enabled || !ambientEnabled()) {
+        if (petStage !== null) removePetStage()
+        notePetReport({ enabled: petRun.enabled, stage: 'absent', display: false, 'anchor': '-', note: ambientEnabled() ? '开关为关' : '急停开关(ambient:false)' })
+        return
+      }
+      const state = readPetState()
+      const kind = petKindById(state.kind)
+      const viewport = petViewport()
+      if (petRun.firstSyncAt === 0) petRun.firstSyncAt = Date.now()
+      // 地面线：锚点（输入框）找到时贴它的下缘；找不到回退到屏幕底缘**抬高一段**
+      // （实机验收：主题面板页 composer 隐藏 → 视口回退 → 宠物贴着窗口最底边被裁掉
+      // 一截。抬高 48px 让它完整可见；输入框在屏上时本行一个像素都不变）。
+      // 自检行有 锚点=视口回退 与 地面= 两个读数，实机可直接核对回退边距。
+      const anchor = petAnchorBox()
+      const anchorKind = anchor === null ? '视口回退' : 'found'
+      const anchorRead = anchor === null ? {} : { right: Math.round(anchor.right), bottom: Math.round(anchor.bottom) }
+      const groundTop = anchor === null ? viewport.height - PET_FALLBACK_GROUND_GAP : anchor.bottom
+      petRun.groundY = Math.min(groundTop - 2, viewport.height - 6)
+      ensurePetStylesheet()
+      // 换宠物：不是当前舞台这只 → 拆掉重建（removePetStage 会清干净定时器与监听）。
+      if (petStage !== null && petRun.kindId !== kind.id) removePetStage()
+      // 热重载会把上一个实例的舞台留在 body 上：不是本实例属主的直接清扫（ambient 同款）。
+      for (const stray of document.querySelectorAll(`#${PET_STAGE_ID}`)) {
+        if (stray.dataset.petOwner !== PET_OWNER) stray.remove()
+      }
+      if (petStage === null) buildPetStage()
+      if (petStage === null) {
+        notePetReport({ enabled: true, stage: 'absent', display: false, anchor: anchorKind, note: '舞台搭建失败（见控制台）' })
+        return
+      }
+      petStage.style.display = ''
+      // 生成中信号：边缘检测（闲→忙加油；忙→闲且忙过才庆祝）。放在舞台建成**之后**：
+      // 边沿若恰好落在"舞台刚被拆掉待重建"的那次同步里（比如换宠物），在前面检测就会
+      // 静默丢失这次加油。任何检测失败都按"闲"处理，静默降级。
+      const working = petWorkingSignal()
+      if (working !== petRun.working) {
+        petRun.working = working
+        if (working) petCheer()
+        // 60s 时效窗：忙过的记录太旧（比如挂件关了一阵再开）就不庆祝，
+        // 那不是"刚完成的对话"。
+        else if (petLastWorkedAt !== 0 && Date.now() - petLastWorkedAt < 60000) petCelebrate()
+      }
+      if (working) {
+        petRun.everWorked = true
+        petLastWorkedAt = Date.now()
+      } else {
+        petLastWorkedAt = 0
+      }
+      const key = [
+        Math.round(viewport.width), Math.round(viewport.height),
+        Math.round(petRun.groundY), state.placed === true, kind.id,
+      ].join('|')
+      const shownNow = petStage.style.display !== 'none'
+      const cssReady = ambientStylesheetReady()
+        && document.querySelector('style[data-plugin-css="theme-gallery/pet"]') !== null
+      const activity = petRun.everWorked === false && Date.now() - petRun.firstSyncAt > 300000
+        ? '未检出'
+        : (petRun.working ? '生成中' : '闲')
+      const kindNote = stateKindFallback ? '注=kind回落' : undefined
+      const withNote = (base) => [base, kindNote].filter(Boolean).join(' ')
+      if (key === petRun.anchorKey) {
+        notePetReport({
+          enabled: true, stage: 'built', display: shownNow, anchor: anchorKind,
+          kind: kind.id, activity, ...anchorRead,
+          groundY: Math.round(petRun.groundY),
+          x: Math.round(petRun.x), y: Math.round(petRun.y),
+          propX: Math.round(petRun.propX), propY: Math.round(petRun.propY),
+          css: cssReady, mode: petRun.mode, note: withNote('几何未变化'),
+        })
+        return
+      }
+      petRun.anchorKey = key
+      // 拖拽中位置归指针管：几何变化（如拖动的同时改了窗口）等松手后再算，
+      // 否则这里改写位置会和指针打架，松手时还会存下错的偏移。
+      if (petRun.mode === 'drag') {
+        notePetReport({
+          enabled: true, stage: 'built', display: true, anchor: anchorKind,
+          kind: kind.id, activity, ...anchorRead,
+          groundY: Math.round(petRun.groundY), css: cssReady, mode: petRun.mode, note: withNote('拖拽中：位置归指针管'),
+        })
+        return
+      }
+      if (state.placed) {
+        // 用户拖过：以视口右/下缘的偏移还原（窗口缩放后自愈），只保证不出屏。
+        const display = petDisplaySize(kind)
+        const propDisplay = petPropDisplaySize(kind)
+        petRun.propX = petClampX(viewport.width + state.prop.dx, propDisplay.w / 2, viewport.width)
+        petRun.propY = petClampX(viewport.height + state.prop.dy, 0, viewport.height - propDisplay.h)
+        if (petRun.mode === 'idle') {
+          petRun.x = petClampX(viewport.width + state.pet.dx, 0, viewport.width - display.w)
+          petRun.y = petClampX(viewport.height + state.pet.dy, 0, viewport.height - display.h)
+        }
+      } else {
+        // 缺省摆位（每只宠物自带）：道具在宠物**左侧**、宠物**面朝左**看着玩具，
+        // 两者都站在地面线上；水平位置锚定屏幕右缘（输入框右侧的空白区域）。
+        const display = petDisplaySize(kind)
+        const propDisplay = petPropDisplaySize(kind)
+        petRun.propX = petClampX(viewport.width + kind.place.prop.dx, propDisplay.w / 2, viewport.width)
+        petRun.propY = petRun.groundY - propDisplay.h
+        if (petRun.mode === 'idle') {
+          petRun.x = petClampX(viewport.width + kind.place.pet.dx, 0, viewport.width - display.w)
+          petRun.y = petRun.groundY - display.h
+        }
+      }
+      applyPetPositions()
+      // 开局（或几何变化后）离道具远就跑过去 —— 也是它每次启用的小入场。
+      if (petRun.mode === 'idle' && petDistanceToProp() > 6) petStartRun()
+      notePetReport({
+        enabled: true, stage: 'built', display: true, anchor: anchorKind,
+        kind: kind.id, activity, ...anchorRead,
+        groundY: Math.round(petRun.groundY),
+        x: Math.round(petRun.x), y: Math.round(petRun.y),
+        propX: Math.round(petRun.propX), propY: Math.round(petRun.propY),
+        css: cssReady, mode: petRun.mode, note: kindNote,
+      })
+    }
+
+    /**
+     * Report whether the accent token layer actually reached the theme snapshot.
+     *
+     * ── WHY THIS READING IS NEEDED ───────────────────────────────────────────
+     *
+     * `syncAccent` stacks three tokens (`button-ghost-active-fill` / `-border` / `-hover`) with
+     * `ctx.theme.overrideTokens`. Whether that layer works had **never been verified**, and one
+     * earlier attempt to verify it used the wrong evidence: the active workspace FOLDER icon
+     * turns the accent colour, which was taken as proof — but that icon is painted by the skin's
+     * own `--dsw-alias-state-business-primary` token and has nothing to do with the layer.
+     *
+     * The service makes this checkable without any guesswork: `composeActive` folds every
+     * override layer into `snapshot.active.tokens` before publishing, so the composed value is
+     * readable straight off `getTheme()`.
+     *
+     * ── WHAT CAN AND CANNOT PROVE IT ─────────────────────────────────────────
+     *
+     * The composed VALUE is the only channel that carries information, and only when it differs
+     * from what the skin declares for that same token:
+     *
+     *  • both bundled skins already ship `button-ghost-active-*` in their own palettes, AND the
+     *    palette layer supplies them too — so the token COUNT is 67 either way. An earlier
+     *    comment here claimed a count that "does not move" disproves the layer; for these skins
+     *    it cannot move, so the claim was wrong and the count is reported for context only;
+     *  • 梦海游鱼 declares `#2B74B5` for that token but its accent is `#FFD166`, so reading back
+     *    `#FFD166` proves the accent layer composed OVER the palette — the palette alone cannot
+     *    produce it;
+     *  • 山青婷彩's accent is `#E88BB0` and it declares `#E88BB0` for the same token, so its
+     *    reading is identical whether or not the layer is there. That is a property of the SKIN,
+     *    not of the layer, and the verdict below says so instead of implying the reading proved
+     *    something.
+     *
+     * The verdict is therefore computed, never asserted: it compares the composed value with the
+     * skin's declared value and with the accent the layer was built from.
+     * @returns the reading, as one segment of the panel line.
+     */
+    function describeAccentLayer() {
+      try {
+        const theme = ctx?.theme
+        if (theme === undefined) return '激活层[无 theme 服务]'
+        const snapshot = theme.getTheme()
+        const active = snapshot?.active
+        const tokens = active?.tokens ?? {}
+        const TOKEN = '--dsw-alias-button-ghost-active-border'
+        const composed = tokens[TOKEN]
+        const definition = typeof active?.id === 'string' ? bundledTheme(active.id) : undefined
+        const declared = declaredToken(definition, TOKEN)
+        const accent = definition?.accent
+        const layers = snapshot?.overrides === undefined
+          ? '(服务未暴露)'
+          : String(snapshot.overrides.size ?? snapshot.overrides.length ?? '?')
+        // Computed, not assumed — see the note above. `不可分辨` is a real answer: it says this
+        // skin's own value coincides with its accent, so this reading proves nothing either way.
+        const verdict = accent === undefined
+          ? '非本包皮肤(无法判断)'
+          : accent === declared
+            ? '不可分辨(强调色=皮肤自备值)'
+            : composed === accent
+              ? '生效(强调色压过自备值)'
+              : composed === declared
+                ? '未生效(仍是自备值)'
+                : `未知(既非强调色也非自备值)`
+        return `激活层[id=${active?.id ?? '?'}`
+          + ` 层数=${layers}`
+          + ` token数=${Object.keys(tokens).length}(自备同名令牌，不构成判据)`
+          + ` ${TOKEN.replace('--dsw-alias-', '')}=${composed === undefined ? '(缺失)' : String(composed)}`
+          + ` 自备=${declared === undefined ? '(无)' : String(declared)}`
+          + ` 强调色=${accent ?? '(无)'}`
+          + ` 判据=${verdict}]`
+      } catch (error) {
+        return `激活层[读取失败: ${String(error && error.message ? error.message : error)}]`
+      }
+    }
+
+    /* ═══════════════════ 心情问候语（标题栏跑马灯）═══════════════════
+     *
+     * 面板第 14 张卡「心情问候」控制的第三种非主题卡面（与宠物挂件同一模式）：
+     * 一条滚动的问候文字住在标题栏条内（应用/编辑菜单右侧、原生窗口按钮左侧的
+     * 空拖拽带上），每 35 分钟换一条，语言料库里的正向短句。需求与决策记录见
+     * docs/DESIGN-心情问候语-位置与语料方案.md，实施细节见 IMP-心情问候语-A/B/C。
+     *
+     *  · 不写主题服务：开关、设置、选句指针全部存 localStorage，绝不碰 preference；
+     *  · 文字**只经 textContent** 进 DOM —— 语料虽是自家数据，注入面也按零算；
+     *  · 有界工作：一个链式 setTimeout（35 分钟换条）+ 一个 resize listener，
+     *    没有轮询、没有 interval（自旋事故的家规）；
+     *  · 座位是 shell.overlay 槽位里的一张静态 div（见 mountGallery 的槽位注册段），
+     *    本模块命令式地往里建条；座位还没渲染时留读数等下一次 sync，不轮询。
+     */
+
+    /** 卡片数据：id、标题与 tooltip（卡面**不渲染** description，与配色/挂件卡同一条分支）。 */
+    const MOOD_WIDGET = {
+      id: 'mood-greeting',
+      label: '心情问候',
+      description: '标题栏上滚动的问候语：默认开启，35 分钟换一条。卡上可开关，'
+        + '并可调滚动速度（慢/中/快）、方向（左→右/右→左）与位置区域'
+        + '（居中/左靠齐/左右缩进/右靠齐）。它不改变当前主题皮肤，可与任何皮肤同时开启。',
+    }
+
+    /** 问候的开关与三组设置记在这里。挂件同一条铁律：绝不写 `ui-theme.preference`。 */
+    const MOOD_KEY = 'theme-gallery:mood'
+
+    /** 选句指针（当天消费到第几条）单独存：形状与用户设置无关，坏了自己愈合。 */
+    const MOOD_POINTER_KEY = 'theme-gallery:mood-pointer'
+
+    /** 换条周期（用户定的 35 分钟）。 */
+    const MOOD_PERIOD_MS = 35 * 60 * 1000
+
+    /** 滚动速度三档（px/s）。中速默认；数值是初值，实机看着不合适就调表——
+     *  调了要同步改 check-mood 的常量断言。60 偏快（用户二轮返工），中速降到 50。 */
+    const MOOD_SPEEDS = { slow: 30, medium: 50, fast: 100 }
+
+    /**
+     * 位置区域的 5 等份映射（用户原话的几何化，DESIGN 第九节）：
+     * 区域 = 标题栏条减去左侧菜单后的水平段分成 5 等份，每一档占用其中几份。
+     * 留空的等份是给"将来装的其他插件"的（用户原话）。
+     */
+    const MOOD_ZONE_GEOMETRY = {
+      left: { first: 1, parts: 4 },   // 左靠齐：占第 1–4 等份，右侧留 1
+      center: { first: 1, parts: 5 }, // 居中（默认）：占满
+      indent: { first: 2, parts: 3 }, // 左右缩进：中间 3 等份，左右各留 1
+      right: { first: 2, parts: 4 },  // 右靠齐：占第 2–5 等份，左侧留 1
+    }
+
+    /**
+     * 时段池边界（已确认）：早安 05:00–11:00 / 白天 11:00–22:00 / 夜深 22:00–次日 05:00。
+     * 夜深的 `to: 29` 是环形写法：小时数 <5 时先加 24（见 moodPoolName），24–28 落进夜深。
+     */
+    const MOOD_TIME_POOLS = [
+      { pool: 'morning', from: 5, to: 11 },
+      { pool: 'day', from: 11, to: 22 },
+      { pool: 'night', from: 22, to: 29 },
+    ]
+
+    /**
+     * 原生窗口控制按钮（最小化/最大化/关闭）的预留宽度。它们是 OS 层 overlay，
+     * DOM 测不到，只能预留——135px 是按钮本身，**用户返工（2026-09-27 截图）**：
+     * 文字要离右上角按钮"远一点"，所以再让出 45px 呼吸位，共 180。
+     */
+    const MOOD_WINBTN_RESERVE = 180
+
+    /**
+     * 左端让位（用户二轮返工）：侧栏分界线到问候文字的呼吸位；菜单右缘的间隙
+     * （侧栏收起时才由菜单决定左端，此时多让一些）。兜底常量 = 展开时侧栏 280 + 呼吸位。
+     */
+    const MOOD_SIDEBAR_GAP = 12
+    const MOOD_MENU_GAP = 48
+    const MOOD_FALLBACK_MENU_RIGHT = 292
+
+    /** shell.overlay 里那张静态座位的选择器（槽位注册段渲染），与问候条元素 id。 */
+    const MOOD_SEAT_SELECTOR = '[data-dsh-mood-seat]'
+    const MOOD_BAR_ID = 'dsh-mood-bar'
+
+    /** 语料分类枚举——与 embed-themes.mjs 的 MOOD_CATEGORIES 同一张表（建期已校验，运行期再认一遍）。 */
+    const MOOD_CATEGORIES = ['morning', 'day', 'night', 'general', 'holiday']
+
+    /**
+     * 运行期再消毒一遍内联语料（不信任模块级常量的形状）。
+     * 手改过 client.js、或旧版本内联了坏数据时，坏条目**逐条丢弃**，
+     * 好条目照用——而不是整体抛错把问候功能打死。
+     * @param pack - 内联的 BUNDLED_MOOD_LINES。
+     * @returns 消毒后的行数组（可能为空；空库由 moodLineOf 报警告）。
+     */
+    function sanitizeMoodLines(pack) {
+      const source = pack !== null && typeof pack === 'object' && Array.isArray(pack.lines) ? pack.lines : []
+      const out = []
+      for (const line of source) {
+        if (line === null || typeof line !== 'object') continue
+        if (typeof line.text !== 'string' || line.text.length === 0 || line.text.length > 200) continue
+        if (!MOOD_CATEGORIES.includes(line.category)) continue
+        if (typeof line.id !== 'string' || line.id === '') continue
+        const clean = {
+          id: line.id,
+          seq: typeof line.seq === 'number' && Number.isFinite(line.seq) ? line.seq : 0,
+          category: line.category,
+          text: line.text,
+        }
+        if (line.category === 'holiday'
+          && line.holiday !== null && typeof line.holiday === 'object'
+          && typeof line.holiday.from === 'string' && typeof line.holiday.to === 'string') {
+          clean.holiday = { from: line.holiday.from, to: line.holiday.to }
+        }
+        out.push(clean)
+      }
+      return out
+    }
+
+    /** 消毒副本：mood 运行区只读这一份，永远不直接摸 BUNDLED_MOOD_LINES。 */
+    const MOOD_LINES = sanitizeMoodLines(BUNDLED_MOOD_LINES)
+
+    /**
+     * 读用户设置。localStorage 里的东西不可信（readPetState 同款理由）：
+     * 逐字段消毒，坏字段回缺省；**缺省是开**（用户定的"默认开"）。
+     * @returns `{ on, speed, direction, zone }`。
+     */
+    function readMoodState() {
+      const fallback = { on: true, speed: 'medium', direction: 'ltr', zone: 'center' }
+      try {
+        const raw = window.localStorage?.getItem(MOOD_KEY)
+        if (typeof raw !== 'string' || raw === '') return fallback
+        const parsed = JSON.parse(raw)
+        if (parsed === null || typeof parsed !== 'object') return fallback
+        return {
+          on: parsed.on === true,
+          speed: typeof parsed.speed === 'string' && parsed.speed in MOOD_SPEEDS ? parsed.speed : fallback.speed,
+          direction: parsed.direction === 'rtl' ? 'rtl' : fallback.direction,
+          zone: typeof parsed.zone === 'string' && parsed.zone in MOOD_ZONE_GEOMETRY ? parsed.zone : fallback.zone,
+        }
+      } catch {
+        return fallback
+      }
+    }
+
+    /**
+     * 合并写回设置。写失败只记录 —— localStorage 被禁用时问候仍在本次会话里活着。
+     * @param patch - 要合并的字段（先经调用方认可）。
+     */
+    function saveMoodState(patch) {
+      try {
+        window.localStorage?.setItem(MOOD_KEY, JSON.stringify({ ...readMoodState(), ...patch }))
+      } catch (error) {
+        console.error('[theme-gallery] could not save the mood state:', error)
+      }
+    }
+
+    /** 本地日期键 `YYYY-MM-DD`（选句的"今天"以本地时区为准）。 */
+    function moodDateKey(date) {
+      const pad = (n) => String(n).padStart(2, '0')
+      return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
+    }
+
+    /** `MM-DD` 键（节日区间比较用）。 */
+    function moodMonthDay(date) {
+      const pad = (n) => String(n).padStart(2, '0')
+      return `${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
+    }
+
+    /**
+     * 当前小时属于哪个时段池。夜深的环形边界：小时 <5 时加 24 归入"昨晚延续"。
+     * @param hour - `date.getHours()`（0–23）。
+     * @returns 池名。
+     */
+    function moodPoolName(hour) {
+      const h = hour < 5 ? hour + 24 : hour
+      for (const range of MOOD_TIME_POOLS) {
+        if (h >= range.from && h < range.to) return range.pool
+      }
+      return 'general'
+    }
+
+    /**
+     * 一条节日语料今天是否命中。`from > to` 视为跨年区间（如 12-31 → 01-02）。
+     * @param line - 语料行（带 holiday 区间）。
+     * @param mmdd - 今天的 `MM-DD`。
+     * @returns 命中与否。
+     */
+    function moodHolidayMatches(line, mmdd) {
+      if (line.holiday === undefined) return false
+      const { from, to } = line.holiday
+      if (from <= to) return mmdd >= from && mmdd <= to
+      return mmdd >= from || mmdd <= to
+    }
+
+    /**
+     * 此刻该用的语料池：节日命中 → 节日池（全部命中条目的并集）；否则时段池；
+     * 池空（理论不发生——建期断言五类非空）回落 general。
+     * @param date - "现在"。
+     * @param lines - 消毒后的语料。
+     * @returns `{ pool, items }`；items 可为空数组。
+     */
+    function moodPicksFor(date, lines) {
+      const mmdd = moodMonthDay(date)
+      const holiday = lines.filter((line) => line.category === 'holiday' && moodHolidayMatches(line, mmdd))
+      if (holiday.length > 0) return { pool: 'holiday', items: holiday }
+      const poolName = moodPoolName(date.getHours())
+      const picked = lines.filter((line) => line.category === poolName)
+      if (picked.length > 0) return { pool: poolName, items: picked }
+      return { pool: 'general', items: lines.filter((line) => line.category === 'general') }
+    }
+
+    /** FNV-1a 32 位——日期种子的原料（无依赖、确定性）。 */
+    function moodHash(text) {
+      let hash = 0x811c9dc5
+      for (let at = 0; at < text.length; at += 1) {
+        hash ^= text.charCodeAt(at)
+        hash = Math.imul(hash, 0x01000193)
+      }
+      return hash >>> 0
+    }
+
+    /** mulberry32 PRNG——小、快、确定性，够洗牌用。 */
+    function mulberry32(seed) {
+      let a = seed >>> 0
+      // 先把函数赋给常量再返回：`return (…) =>` 里的 `return (` 会被 scope 审计
+      // 读成"调用了名为 return 的函数"（wcagContrast 同一条教训的第三种形态）。
+      const next = () => {
+        a = (a + 0x6d2b79f5) | 0
+        let t = Math.imul(a ^ (a >>> 15), 1 | a)
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+        const out = ((t ^ (t >>> 14)) >>> 0) / 4294967296
+        return out
+      }
+      return next
+    }
+
+    /**
+     * 当日确定性洗牌：同一天同池顺序稳定（会话重启不换血），跨天不同——
+     * "每天不重样"的体验由种子里的日期实现，不依赖任何在线内容。
+     * @param items - 池内语料。
+     * @param date - "今天"。
+     * @param pool - 池名（进种子，跨池顺序也不同）。
+     * @returns 新数组（不改入参）。
+     */
+    function moodDayOrder(items, date, pool) {
+      const next = mulberry32(moodHash(`${moodDateKey(date)}|${pool}`))
+      const order = [...items]
+      for (let at = order.length - 1; at > 0; at -= 1) {
+        const swap = Math.floor(next() * (at + 1))
+        const hold = order[at]
+        order[at] = order[swap]
+        order[swap] = hold
+      }
+      return order
+    }
+
+    /** 读选句指针；坏/缺返回 null（轮换逻辑自愈到 index 0）。 */
+    function moodPointer() {
+      try {
+        const raw = window.localStorage?.getItem(MOOD_POINTER_KEY)
+        if (typeof raw !== 'string' || raw === '') return null
+        const parsed = JSON.parse(raw)
+        if (parsed === null || typeof parsed !== 'object') return null
+        return {
+          date: typeof parsed.date === 'string' ? parsed.date : '',
+          pool: typeof parsed.pool === 'string' ? parsed.pool : '',
+          index: Number.isInteger(parsed.index) && parsed.index >= 0 ? parsed.index : 0,
+          lastId: typeof parsed.lastId === 'string' ? parsed.lastId : '',
+        }
+      } catch {
+        return null
+      }
+    }
+
+    /** 写选句指针；写失败只是明天从头开始，不值得打断谁。 */
+    function saveMoodPointer(pointer) {
+      try {
+        window.localStorage?.setItem(MOOD_POINTER_KEY, JSON.stringify(pointer))
+      } catch { /* 存储被禁时问候仍可显示，只是换条顺序回到队首 */ }
+    }
+
+    /**
+     * 选下一条并推进指针（每次调用都消费一格——启动首条也一样，指针保证
+     * 同一天内尽量不重复；池耗尽回绕，回绕后与上一条相同且池里不止一条时跳一格）。
+     * @param now - "现在"。
+     * @param lines - 消毒后的语料。
+     * @returns 语料行，或 null（语料不可用）。
+     */
+    function moodNextLine(now, lines) {
+      if (!Array.isArray(lines) || lines.length === 0) return null
+      const { pool, items } = moodPicksFor(now, lines)
+      if (items.length === 0) return null
+      const dateKey = moodDateKey(now)
+      const pointer = moodPointer()
+      const fresh = pointer === null || pointer.date !== dateKey || pointer.pool !== pool
+      const start = fresh ? 0 : pointer.index
+      const order = moodDayOrder(items, now, pool)
+      let pick = start % order.length
+      if (order.length > 1 && order[pick].id === pointer?.lastId) pick = (pick + 1) % order.length
+      saveMoodPointer({ date: dateKey, pool, index: pick + 1, lastId: order[pick].id })
+      return order[pick]
+    }
+
+    /**
+     * 应用/编辑菜单的右缘（问候区左端）。菜单是 preload 注入的固定元素
+     * （`[data-windows-menu]`，见 preload 的 installWindowsMenu），
+     * 侧栏折叠时它会挪位——每次都实测，几何自动跟随，不做写死常量。
+     * @returns 菜单右缘 + 间隙；读不到时给兜底常量。
+     */
+    /**
+     * 问候区左端。**用户二轮返工（截图）**：左端要让开**整个左侧菜单栏列**——
+     * 侧栏与工作区有明显分界线（卡通素材也渲染在侧栏内），问候从分界线右侧开始，
+     * 不再只是避开"编辑"按钮。所以取两者较大值：
+     *
+     *   · 侧栏列的实测右缘（`sidebarColumn()`，展开 ≈ 280，即分界线）+ 小呼吸位；
+     *   · 应用/编辑菜单的右缘（侧栏**收起**时列宽为 0、菜单挪到 84px 起，此时由它兜底）。
+     *
+     * 都读不到（异常环境/旧版本）才落常量兜底。每次都实测：侧栏宽度是用户可拖的，
+     * 收起/展开也随时切——写死必错（SKILL §13 同一条哲学）。
+     * @returns 左端 x（px）。
+     */
+    function moodMenuRight() {
+      let boundary = 0
+      try {
+        const column = sidebarColumn()
+        if (column !== null && typeof column.getBoundingClientRect === 'function') {
+          const rect = column.getBoundingClientRect()
+          if (Number.isFinite(rect.right) && rect.right > 0) boundary = rect.right + MOOD_SIDEBAR_GAP
+        }
+      } catch { /* 桩环境没有 rect —— 由菜单/兜底接管 */ }
+      try {
+        const host = document.querySelector('[data-windows-menu]')
+        if (host !== null && typeof host.getBoundingClientRect === 'function') {
+          const rect = host.getBoundingClientRect()
+          if (Number.isFinite(rect.right) && rect.right > 0) boundary = Math.max(boundary, rect.right + MOOD_MENU_GAP)
+        }
+      } catch { /* 同上 */ }
+      if (boundary > 0) return boundary
+      return MOOD_FALLBACK_MENU_RIGHT
+    }
+
+    /**
+     * 位置区域的矩形：5 等份映射（MOOD_ZONE_GEOMETRY）作用在
+     * 「问候区左端（侧栏分界线右侧）→ 窗口按钮左缘」这段上。
+     * @param zone - `readMoodState().zone`。
+     * @param viewportWidth - 窗口宽。
+     * @param menuRight - `moodMenuRight()` 的读数（即左端）。
+     * @returns `{ left, width }`（px），几何不可算时 null。
+     */
+    function moodZoneRect(zone, viewportWidth, menuRight) {
+      const geo = MOOD_ZONE_GEOMETRY[zone]
+      if (geo === undefined) return null
+      const right = viewportWidth - MOOD_WINBTN_RESERVE
+      const left = Math.min(menuRight, right - 160)
+      // 左端为负 = 窗口窄到连菜单都放不下（异常环境）——宁可不渲染（自检行会给读数），
+      // 也不要把条画到屏幕外去。
+      if (!(right > left) || left < 0) return null
+      const unit = (right - left) / 5
+      const rectLeft = left + unit * (geo.first - 1)
+      const rectWidth = unit * geo.parts
+      if (!Number.isFinite(rectLeft) || !Number.isFinite(rectWidth) || rectWidth <= 0) return null
+      return { left: rectLeft, width: rectWidth }
+    }
+
+    /** 问候条的样式表（一次性安装；元素树全部经 createElement/textContent）。 */
+    const MOOD_CSS = [
+      `#${MOOD_BAR_ID}{position:fixed;top:0;height:var(--dsh-windows-titlebar-height,40px);`
+        + 'display:flex;align-items:center;overflow:hidden;pointer-events:none;'
+        + 'font-size:12px;letter-spacing:.12em;color:var(--dsw-alias-label-tertiary)}',
+      '.dsh-mood-track{display:inline-flex;white-space:nowrap;will-change:transform;'
+        + 'animation:dsh-mood-rtl linear infinite}',
+      '[data-dsh-mood-dir="ltr"] .dsh-mood-track{animation-name:dsh-mood-ltr}',
+      '@keyframes dsh-mood-rtl{from{transform:translateX(0)}to{transform:translateX(-50%)}}',
+      '@keyframes dsh-mood-ltr{from{transform:translateX(-50%)}to{transform:translateX(0)}}',
+      '.dsh-mood-half{display:inline-flex;align-items:center}',
+      /* 句尾间隙 = **整个区域宽**（内联 width 由 moodBuildBar 按实测写入）：
+         间隙 ≥ 区域宽时，数学上保证任一时刻区域内至多一句可见 —— 用户返工
+         （2026-09-27 截图）："同一时刻，只有一句话显示在一处"。 */
+      '.dsh-mood-text{flex:none}',
+      '.dsh-mood-gap{flex:none;display:inline-block}',
+      /* reduced-motion：功能保留、只停动画（挂件先例）——静止显示一份，超长省略。
+         ⚠ 全杀规则必须待在媒体查询**里面**：裸写一条无条件 `animation:none!important`
+         会把跑马灯动画本身一起杀掉（实机读数抓到过：animationName 变成 none）。 */
+      '@media (prefers-reduced-motion:reduce){'
+        + `#${MOOD_BAR_ID} *{animation:none!important}`
+        + '.dsh-mood-half+.dsh-mood-half{display:none}'
+        + `#${MOOD_BAR_ID} .dsh-mood-half{overflow:hidden;text-overflow:ellipsis;max-width:100%}}`,
+    ].join('\n')
+
+    /** 样式表是否已在文档里（自检读数之一）。 */
+    function moodCssInstalled() {
+      if (typeof document === 'undefined' || typeof document.querySelector !== 'function') return false
+      return document.querySelector('style[data-plugin-css="theme-gallery/mood"]') !== null
+    }
+
+    /** 安装样式表（幂等）。 */
+    function installMoodCss() {
+      if (typeof document === 'undefined' || typeof document.querySelector !== 'function') return
+      if (moodCssInstalled()) return
+      const tag = document.createElement('style')
+      tag.dataset.plugin = 'dsh-theme-gallery'
+      tag.dataset.pluginCss = 'theme-gallery/mood'
+      tag.textContent = MOOD_CSS
+      document.head.appendChild(tag)
+    }
+
+    /** 拆除样式表（teardown 路径用）。 */
+    function removeMoodCss() {
+      if (typeof document === 'undefined' || typeof document.querySelector !== 'function') return
+      for (const stale of document.querySelectorAll('style[data-plugin-css="theme-gallery/mood"]')) stale.remove()
+    }
+
+    /** 问候条运行态。`enabled` 是 localStorage 的内存镜像（petRun 同款理由）。 */
+    const moodRun = { enabled: false, timer: null, retryTimer: null, retryTries: 0, resizeBound: false, fingerprint: '', line: null, pool: '-' }
+
+    /**
+     * 座位缺席的有界重试。shell.overlay 的渲染时机由外壳决定，常常晚于本插件的
+     * 首轮 publish（实机读数：指针已走、座位已在、条还没建 —— 就是这个缺口），
+     * 而之后可能再没有 publish 路过。所以缺席时用**单个可取消句柄**每 2 秒重试，
+     * 至多 `MOOD_SEAT_RETRY_MAX` 次（约 30 秒）—— 建成即停，拆条即清，
+     * 不做持续轮询（有界工作的家规）。
+     */
+    const MOOD_SEAT_RETRY_MS = 2000
+    const MOOD_SEAT_RETRY_MAX = 15
+
+    function moodArmSeatRetry() {
+      if (moodRun.retryTimer !== null || moodRun.retryTries >= MOOD_SEAT_RETRY_MAX) return
+      if (typeof window === 'undefined' || typeof window.setTimeout !== 'function') return
+      moodRun.retryTimer = window.setTimeout(() => {
+        moodRun.retryTimer = null
+        moodRun.retryTries += 1
+        try {
+          if (!moodRun.enabled) return
+          const seat = document.querySelector(MOOD_SEAT_SELECTOR)
+          if (seat === null) {
+            moodArmSeatRetry()
+            return
+          }
+          moodRun.retryTries = 0
+          moodBuildBar()
+        } catch (error) {
+          console.error('[theme-gallery] could not retry the mood seat:', error)
+        }
+      }, MOOD_SEAT_RETRY_MS)
+    }
+
+    function moodCancelSeatRetry() {
+      moodClearTimer(moodRun.retryTimer)
+      moodRun.retryTimer = null
+    }
+
+    /** 自检读数。挂件 petReport 同款：每条退出路径都写，失败形态是"什么都不出现"，没有读数就查不下去。 */
+    let moodReport
+    function noteMoodReport(patch) {
+      moodReport = { ...(moodReport ?? {}), ...patch }
+    }
+
+    /** 例行读数用的中文标签（自检行是给人读的）。 */
+    const MOOD_ZONE_LABELS = { left: '左靠齐', center: '居中', indent: '左右缩进', right: '右靠齐' }
+    const MOOD_SPEED_LABELS = { slow: '慢速', medium: '中速', fast: '快速' }
+
+    /**
+     * 面板自检行（petLineOf 同款形状）：关着返回 null；开着出问题给 ⚠ 警告；
+     * 一切正常给一行读数。警告无条件显示、读数走 debug 开关——既有口径。
+     * @param on - 问候是否开启（store 的 moodOn）。
+     * @returns 自检行或 null。
+     */
+    function moodLineOf(on) {
+      try {
+        if (on !== true) return null
+        const r = moodReport
+        if (r === undefined || r.enabled !== true) return '⚠ 问候已开启但尚未同步（syncMoodBar 未运行）'
+        if (r.seat !== 'ok') return `⚠ 问候条未建出：${r.note ?? '座位（shell.overlay）尚未渲染'}`
+        if (r.css !== true) return '⚠ 问候样式表未生效（MOOD_CSS 不在文档中）'
+        if (r.line === null || r.line === undefined) return `⚠ 语料不可用：${r.note ?? '没有可用语料'}`
+        return `问候自检通过 · 条=${r.line} 池=${r.pool} 区域=${r.zoneLabel} 方向=${r.dirLabel} 速度=${r.speedLabel} 左=${r.left} 右=${r.right}`
+      } catch (error) {
+        return `⚠ 问候自检失败: ${String(error && error.message ? error.message : error)}`
+      }
+    }
+
+    /** 与 petLineIsWarning 同一条判据：⚠ 开头或带"失败"的行不算例行汇报。 */
+    function moodLineIsWarning(line) {
+      return typeof line === 'string' && (line.startsWith('⚠') || line.includes('失败'))
+    }
+
+    /** 拆掉问候条元素（不动计时器——那是 teardown 的事）。 */
+    function removeMoodBar() {
+      if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return
+      const bar = document.getElementById(MOOD_BAR_ID)
+      if (bar !== null) bar.remove()
+    }
+
+    /**
+     * 按当前状态（重）建问候条。幂等判据在最前：指纹没变一个字节都不写
+     * （bounded-work 的守卫规矩；publish 每次都路过这里，不能每次都重建 DOM）。
+     *
+     * 文字**只经 textContent** 进 DOM；两半内容逐字节相同，translateX 0↔-50% 的
+     * 循环天然无缝；时长 = 半宽 ÷ 速度档，速度换算全部落在动画时长上。
+     */
+    function moodBuildBar() {
+      if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return
+      const state = readMoodState()
+      if (!moodRun.enabled || !ambientEnabled()) {
+        removeMoodBar()
+        noteMoodReport({
+          enabled: moodRun.enabled, seat: 'absent', css: moodCssInstalled(), line: null,
+          note: moodRun.enabled ? '急停开关(ambient:false)' : '开关为关',
+        })
+        return
+      }
+      installMoodCss()
+      const seatNode = document.querySelector(MOOD_SEAT_SELECTOR)
+      if (seatNode === null) {
+        noteMoodReport({
+          enabled: true, seat: 'absent', css: moodCssInstalled(),
+          line: moodRun.line === null ? null : moodRun.line.id,
+          pool: moodRun.pool, note: '座位（shell.overlay）尚未渲染',
+        })
+        moodArmSeatRetry()
+        return
+      }
+      const viewport = petViewport()
+      const menuRight = moodMenuRight()
+      const rect = moodZoneRect(state.zone, viewport.width, menuRight)
+      if (rect === null) {
+        noteMoodReport({
+          enabled: true, seat: 'ok', css: moodCssInstalled(),
+          line: moodRun.line === null ? null : moodRun.line.id, pool: moodRun.pool,
+          note: `几何不可算（viewport=${viewport.width} 菜单右缘=${menuRight}）`,
+        })
+        return
+      }
+      const active = moodRun.line
+      if (active === null) {
+        noteMoodReport({ enabled: true, seat: 'ok', css: moodCssInstalled(), line: null, pool: moodRun.pool, note: '语料不可用' })
+        return
+      }
+      const fingerprint = [active.id, state.speed, state.direction, state.zone, rect.left, rect.width, viewport.width].join('|')
+      let bar = document.getElementById(MOOD_BAR_ID)
+      if (bar !== null && moodRun.fingerprint === fingerprint) {
+        moodCancelSeatRetry()
+        moodRun.retryTries = 0
+        noteMoodReport({
+          enabled: true, seat: 'ok', css: true, line: active.id, pool: moodRun.pool,
+          zoneLabel: MOOD_ZONE_LABELS[state.zone], dirLabel: state.direction === 'ltr' ? '左→右' : '右→左',
+          speedLabel: MOOD_SPEED_LABELS[state.speed], left: Math.round(rect.left), right: Math.round(rect.left + rect.width),
+        })
+        return
+      }
+      // —— 指纹变了：整条重建。重建比 diff 便宜，也是把旧速度/旧方向的动画一并带走的唯一途径。
+      if (bar === null) {
+        bar = document.createElement('div')
+        bar.id = MOOD_BAR_ID
+      }
+      bar.textContent = ''
+      bar.dataset.dshMoodDir = state.direction
+      bar.style.left = `${rect.left}px`
+      bar.style.width = `${rect.width}px`
+      // **先把 bar 挂进座位再量宽度**：脱离 DOM 的元素 getBoundingClientRect() 是 0
+      // （实机读数抓到过）。track 也一样——量宽前先把它挂进 bar。
+      seatNode.appendChild(bar)
+      const track = document.createElement('div')
+      track.className = 'dsh-mood-track'
+      bar.appendChild(track)
+      // 每半 = **一句 + 一段等于区域宽的间隙**。间隙 ≥ 区域宽 ⇒ 两句不可能同时
+      // 落在区域内（B 的左缘与 A 的右缘至少隔一个区域宽），滚动到接缝处 A 出、
+      // B 进，视觉上"同一时刻只有一句话显示在一处"（用户返工要求）。
+      const buildHalf = () => {
+        const half = document.createElement('span')
+        half.className = 'dsh-mood-half'
+        const text = document.createElement('span')
+        text.className = 'dsh-mood-text'
+        text.textContent = active.text
+        half.appendChild(text)
+        const gap = document.createElement('span')
+        gap.className = 'dsh-mood-gap'
+        gap.style.width = `${rect.width}px`
+        half.appendChild(gap)
+        track.appendChild(half)
+        return half
+      }
+      const first = buildHalf()
+      track.appendChild(first.cloneNode(true))
+      // 建成即停：座位重试链清零（它只在缺席时武装）。
+      moodCancelSeatRetry()
+      moodRun.retryTries = 0
+      // 区域随窗口宽重算：唯一的事件 listener，首次建条时绑定、teardown 时拆除。
+      if (!moodRun.resizeBound && typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+        window.addEventListener('resize', moodOnResize)
+        moodRun.resizeBound = true
+      }
+      const halfWidth = first.getBoundingClientRect().width
+      const speed = MOOD_SPEEDS[state.speed] ?? MOOD_SPEEDS.medium
+      const duration = halfWidth > 0 && Number.isFinite(halfWidth) ? halfWidth / speed : 0
+      // 时长非法（量不到宽度）就不写样式——交给 reduced-motion 的静止形态兜底，绝不写 NaN。
+      if (duration > 0 && Number.isFinite(duration)) track.style.animationDuration = `${duration}s`
+      // 字体加载完成后**重建一次**：副本数与滚动时长刚才按回退字体量的（实机读数：
+      // 12 份、47.8s），字体就位后宽度才真实。一次性 promise、指纹守卫仍在 —— 有界。
+      if (typeof document !== 'undefined' && document.fonts?.ready?.then === 'function') {
+        document.fonts.ready.then(() => {
+          if (moodRun.fingerprint !== fingerprint || moodRun.enabled !== true) return
+          moodRun.fingerprint = ''
+          moodBuildBar()
+        }).catch(() => { /* 字体 API 异常就用首次的度量，不追 */ })
+      }
+      moodRun.fingerprint = fingerprint
+      noteMoodReport({
+        enabled: true, seat: 'ok', css: true, line: active.id, pool: moodRun.pool,
+        zoneLabel: MOOD_ZONE_LABELS[state.zone], dirLabel: state.direction === 'ltr' ? '左→右' : '右→左',
+        speedLabel: MOOD_SPEED_LABELS[state.speed], left: Math.round(rect.left), right: Math.round(rect.left + rect.width),
+      })
+    }
+
+    /**
+     * 计时器只走 **`window.setTimeout` / `window.clearTimeout`**（挂件同款）：
+     * 测试桩拦得住，也绝不留一个裸的全局定时器把进程吊住（有界工作的家规）。
+     */
+    function moodClearTimer(handle) {
+      if (handle === null) return
+      if (typeof window !== 'undefined' && typeof window.clearTimeout === 'function') window.clearTimeout(handle)
+    }
+
+    /** 35 分钟后的下一次换条（单句柄链式；任何路径先 clear 自己）。 */
+    function moodScheduleNext() {
+      moodClearTimer(moodRun.timer)
+      moodRun.timer = null
+      if (typeof window === 'undefined' || typeof window.setTimeout !== 'function') return
+      moodRun.timer = window.setTimeout(() => {
+        moodRun.timer = null
+        try {
+          if (!moodRun.enabled) return
+          const line = moodNextLine(new Date(), MOOD_LINES)
+          if (line === null) {
+            noteMoodReport({ enabled: true, seat: moodReport?.seat ?? 'absent', css: moodCssInstalled(), line: null, pool: moodRun.pool, note: '语料不可用' })
+            return
+          }
+          moodRun.line = line
+          moodRun.pool = line.category === 'holiday' ? 'holiday' : moodRun.pool
+          moodBuildBar()
+        } catch (error) {
+          console.error('[theme-gallery] could not rotate the mood line:', error)
+        } finally {
+          moodScheduleNext()
+        }
+      }, MOOD_PERIOD_MS)
+    }
+
+    /**
+     * 问候条的同步入口（幂等）：publish 顺路调用、开关与设置路径显式调用。
+     * 与 syncPetStage 同一条哲学——每条退出路径都写 moodReport。
+     * 计时器只在第一次启动（句柄存在就不动它），换条节奏不随 publish 漂移。
+     */
+    function syncMoodBar() {
+      try {
+        const state = readMoodState()
+        moodRun.enabled = state.on
+        if (!state.on) {
+          moodTeardown()
+          return
+        }
+        if (moodRun.timer === null) moodScheduleNext()
+        if (moodRun.line === null) {
+          const line = moodNextLine(new Date(), MOOD_LINES)
+          moodRun.line = line
+          if (line !== null) moodRun.pool = line.category
+        }
+        moodBuildBar()
+      } catch (error) {
+        console.error('[theme-gallery] could not sync the mood bar:', error)
+      }
+    }
+
+    /** resize 时区域要重算（唯一的事件 listener；挂载/拆卸成对）。 */
+    function moodOnResize() {
+      try {
+        moodBuildBar()
+      } catch (error) {
+        console.error('[theme-gallery] could not resize the mood bar:', error)
+      }
+    }
+
+    /**
+     * 全部拆除：计时器、resize listener、条元素、样式表、运行态。
+     * **刻意不叫 `…Dispose`**——那是自发光守卫审计里主题层专用模式的名字（规则 1）。
+     */
+    function moodTeardown() {
+      moodClearTimer(moodRun.timer)
+      moodRun.timer = null
+      moodCancelSeatRetry()
+      moodRun.retryTries = 0
+      if (moodRun.resizeBound && typeof window !== 'undefined' && typeof window.removeEventListener === 'function') {
+        window.removeEventListener('resize', moodOnResize)
+      }
+      moodRun.resizeBound = false
+      removeMoodBar()
+      removeMoodCss()
+      moodRun.fingerprint = ''
+      moodRun.line = null
+      noteMoodReport({ enabled: false, seat: 'absent', css: false, line: null, pool: '-', note: '开关为关' })
+    }
+
+    /* ═══════════════════ 菜单折叠（侧栏入口收放 + 设置页常驻面板）═══════════════════
+     *
+     * 方案二（用户定）：设置页入口**常驻**，侧栏入口由本开关收放。三件事：
+     *  ① 面板第 15 张卡「菜单折叠」（默认关）—— 卡面带路径提示，点击只改 localStorage；
+     *  ② `settings.section` 槽位注册一个**常驻**的一级设置分节（用户指定：agent预设下方），
+     *     内容 = 完整面板（ThemeGalleryPage + 同一个 pinned store），侧栏收起后面板仍可达
+     *     —— 这是"不会把自己锁在外面"的关键；
+     *  ③ 侧栏入口的注册/撤销随开关走（槽位 disposer，即时生效，不重启、不碰 CSS）。
+     * 不写主题服务：折叠状态只存 localStorage（铁律）。
+     */
+
+    /** 折叠卡的 id、标题与 tooltip 文案。 */
+    const MENU_COLLAPSE_WIDGET = {
+      id: 'menu-collapse',
+      label: '菜单折叠',
+      description: '开启后，左侧栏不再显示「主题皮肤」入口；设置 → 通用设置（agent预设 下方）'
+        + '里有轻量入口，可一键打开面板或恢复侧栏显示。关闭后恢复侧栏显示。默认关闭。',
+    }
+
+    /** 折叠状态记在这里。与皮肤 id 同一条铁律：绝不写 `ui-theme.preference`。 */
+    const MENU_COLLAPSE_KEY = 'theme-gallery:menu-collapse'
+
+    /**
+     * 设置分节在设置页导航里的位置（order）。
+     *
+     * 探针读数（app.asar + profile 插件，2026-09-27）：settings.section 里 cool-theme=5、
+     * skin-center=120、pet=130；General 行 appearance=10、font-size=11。「agent预设」的
+     * 注册点不在客户端 bundle 里（无法静态标定它的 order），先取 **135**（排在已知插件
+     * 分节之后）；实机若不在 agent预设 下方，改这一个数字即可。
+     */
+    const SETTINGS_SECTION_ORDER = 135
+
+    /**
+     * 读取并消毒折叠状态。缺省**关**（= 侧栏显示现状），坏数据回缺省。
+     * @returns `{ collapsed }`。
+     */
+    function readMenuCollapseState() {
+      try {
+        const raw = window.localStorage?.getItem(MENU_COLLAPSE_KEY)
+        if (typeof raw !== 'string' || raw === '') return { collapsed: false }
+        const parsed = JSON.parse(raw)
+        if (parsed === null || typeof parsed !== 'object') return { collapsed: false }
+        return { collapsed: parsed.collapsed === true }
+      } catch {
+        return { collapsed: false }
+      }
+    }
+
+    /** 合并写回折叠状态（写失败只记录 —— localStorage 被禁用时本次会话仍可玩）。 */
+    function saveMenuCollapseState(patch) {
+      try {
+        window.localStorage?.setItem(MENU_COLLAPSE_KEY, JSON.stringify({ ...readMenuCollapseState(), ...patch }))
+      } catch (error) {
+        console.error('[theme-gallery] could not save the menu-collapse state:', error)
+      }
+    }
+
+    /** 折叠开关现在是否开着（= 侧栏入口已收起）。 */
+    function menuCollapsed() {
+      return readMenuCollapseState().collapsed
+    }
+
+    /** store 未就绪时分节读的兜底快照（hooks 必须恒在场，见 MenuSettingsSection 文档）。 */
+    const SECTION_FALLBACK_SNAPSHOT = { labels: {}, selected: '', menuCollapsed: false }
+
+    /**
+     * 设置页的常驻分节（方案二，形态 A —— 用户 2026-09-27 定）：**轻量入口**。
+     *
+     * 实机读数：完整面板塞进弹窗内容列会白屏（根因 = `store.getState` 与真实
+     * StoreInstance 契约漂移，真实只有 `getSnapshot` —— 已修），而且就算修好，
+     * 弹窗也挡住大半屏幕，换肤的全屏效果在里面看不见。官方契约把 settings.section
+     * 定位为"一个列表项一个设置页"（owner props 只有 close），dsh-pet 的分节同样
+     * 是轻量表单 —— 所以分节只做三件事：报状态（当前皮肤 / 侧栏入口）、给
+     * 「打开主题皮肤面板」跳转（`ctx.layout.selectPanel` —— 契约明说它是给插件
+     * 做面板切换的横切面 + `close` 关弹窗）、折叠开着时给「恢复侧栏入口」。
+     * 真正的换肤 / 挂件 / 问候操作都在主区全屏面板里完成。
+     * @param props - 分节 props（t/close + inject 面成员）。
+     * @returns 分节元素树。
+     */
+    function MenuSettingsSection(props) {
+      const { t, close, store, toggleMenuCollapse } = props
+      // hooks 规则：订阅恒在场 —— store 缺失（inject 面没解析）时订阅空源、读兜底
+      // 快照，分节退化为引导文案，绝不白屏（白屏教训就在眼前）。
+      // 两个包装都是刻意的：抽出方法会丢 this，直接给属性引用在真实引擎上不安全。
+      const snapshot = useSyncExternalStore(
+        (onStoreChange) => (store?.subscribe ? store.subscribe(onStoreChange) : () => {}),
+        () => (store?.getSnapshot ? store.getSnapshot() : SECTION_FALLBACK_SNAPSHOT),
+      )
+      const skinLabel = snapshot?.labels?.[snapshot?.selected] ?? snapshot?.selected ?? ''
+      const collapsed = snapshot?.menuCollapsed === true
+      // 排版（用户 2026-09-27 返工）：标题 → 说明 → 读数块（两行，label 左值右）→
+      // 按钮组（主按钮跳转、次按钮恢复）—— 主次分明、垂直节奏，适配弹窗窄容器。
+      return jsxs('div', {
+        className: 'tg-section',
+        children: [
+          jsx('div', { className: 'tg-section-title', children: t('title') }),
+          jsx('div', { className: 'tg-section-hint', children: t('sectionHint') }),
+          jsxs('div', {
+            className: 'tg-section-facts',
+            children: [
+              jsxs('div', {
+                className: 'tg-section-row',
+                children: [
+                  jsx('span', { children: t('sectionSkinLabel') }),
+                  jsx('span', { className: 'tg-section-value', children: skinLabel }),
+                ],
+              }),
+              jsxs('div', {
+                className: 'tg-section-row',
+                children: [
+                  jsx('span', { children: t('sectionSidebarLabel') }),
+                  jsx('span', {
+                    className: 'tg-section-value',
+                    children: collapsed ? t('menuCollapsed') : t('menuShown'),
+                  }),
+                ],
+              }),
+            ],
+          }),
+          jsxs('div', {
+            className: 'tg-section-actions',
+            children: [
+              jsx('button', {
+                type: 'button',
+                className: 'tg-section-open',
+                onClick: () => {
+                  // 软跳转：布局面不在 / 面板未注册都只留痕，绝不把设置弹窗带崩。
+                  try {
+                    if (ctx !== undefined && ctx !== null && typeof ctx.layout?.selectPanel === 'function') {
+                      ctx.layout.selectPanel(PANEL_ID)
+                    } else {
+                      console.error('[theme-gallery] ctx.layout.selectPanel is unavailable; cannot jump to the panel')
+                    }
+                  } catch (error) {
+                    console.error('[theme-gallery] could not jump to the panel:', error)
+                  }
+                  // 官方明说 close 是给"从分节离开设置"用的 —— 跳转后关掉弹窗，全屏效果可见。
+                  if (typeof close === 'function') close()
+                },
+                children: t('openPanel'),
+              }),
+              collapsed ? jsx('button', {
+                type: 'button',
+                className: 'tg-section-restore',
+                onClick: () => {
+                  // 复用折叠卡的同一动作：写回 localStorage + 重新注册侧栏入口 + publish
+                  // 报回 store —— 分节经订阅重渲染，这颗按钮自己消失。
+                  try { toggleMenuCollapse() } catch (error) {
+                    console.error('[theme-gallery] could not restore the sidebar entry:', error)
+                  }
+                },
+                children: t('restoreSidebar'),
+              }) : null,
+            ],
+          }),
+        ],
+      })
+    }
+
+    /** 侧栏入口的 inject 句柄；undefined = 当前没有注册（已折叠）。 */
+    let sidebarEntryDispose
+
+    /**
+     * 侧栏入口的注册/撤销随折叠开关走（幂等）。
+     *
+     * 撤销用的是槽位系统自己的 disposer —— 官方机制，即时生效；**绝不**用 CSS 硬藏
+     * （框架类名带哈希，§13 的教训）。每次状态变化都留痕（noteAmbientEvent），
+     * "收起了/恢复了"必须可查，而不是靠用户盯着侧栏猜。
+     */
+    function syncSidebarEntry() {
+      if (typeof ctx === 'undefined' || ctx === null) return
+      if (menuCollapsed()) {
+        if (sidebarEntryDispose !== undefined) {
+          sidebarEntryDispose()
+          sidebarEntryDispose = undefined
+          noteAmbientEvent('侧栏入口已收起（菜单折叠开）')
+        }
+        return
+      }
+      if (sidebarEntryDispose !== undefined) return
+      sidebarEntryDispose = ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({
+        name: 'sidebar.panellist',
+        id: PANEL_ID,
+        order: 30,
+        locale: NS,
+        label: () => zh.title,
+      }, PanelGlyph))
+      noteAmbientEvent('侧栏入口已显示（菜单折叠关）')
+    }
+
+    /**
+     * Render the main-column gallery page.
+     *
+     * `usePanelInfo` comes from the layout's GlobalStandardProps, so the page can
+     * render nothing when another panel is selected without the shell having to
+     * mount and unmount it.
+     * @param props - composed slot props.
+     * @returns the page element tree.
+     */
+    function ThemeGalleryPage({ t, setTheme, pickScheme, togglePet, pickPet, toggleMood, setMood, toggleMenuCollapse, useStore, usePanelInfo }) {
+      const info = usePanelInfo((s) => s.activePanelId)
+      const ids = useStore((s) => s.ids)
+      const labels = useStore((s) => s.labels)
+      const descriptions = useStore((s) => s.descriptions)
+      const swatches = useStore((s) => s.swatches)
+      const cardRows = useStore((s) => s.cardRows)
+      const scheme = useStore((s) => s.scheme)
+      const petEnabled = useStore((s) => s.petEnabled)
+      const petKind = useStore((s) => s.petKind)
+      const moodOn = useStore((s) => s.moodOn)
+      const moodSpeed = useStore((s) => s.moodSpeed)
+      const moodDirection = useStore((s) => s.moodDirection)
+      const moodZone = useStore((s) => s.moodZone)
+      const menuCollapsed = useStore((s) => s.menuCollapsed)
+      const selected = useStore((s) => s.selected)
+      const status = useStore((s) => s.status)
+      // The layout keeps this page registered whatever the selection is, so it
       // renders nothing while another panel owns the main column.
       if (info !== PANEL_ID) return null
       // An empty picker must explain itself: the boot screen says only "failed",
@@ -6679,13 +10279,23 @@ window.__ModuleLoader__.load({
       // Detail lines are opt-in; a line that reports a problem is not detail.
       const scenery = sceneryLine(selected)
       const showScenery = scenery !== null && (debugEnabled() || sceneryLineIsWarning(scenery))
+      // 挂件行同理：开了挂件却建不出舞台，警告必须无条件出现在面板上。
+      const petLine = petLineOf(petEnabled === true)
+      const showPet = petLine !== null && (debugEnabled() || petLineIsWarning(petLine))
+      // 问候行同理：开着却没建出条（或样式缺失），必须无条件可见。
+      const moodLine = moodLineOf(moodOn === true)
+      const showMood = moodLine !== null && (debugEnabled() || moodLineIsWarning(moodLine))
       // ── THE HEADER COUNT IS SKINS, NOT CARDS ─────────────────────────────────
       //
       // The built-in 浅色 / 深色 cards are not skins — they only switch the palette back to the
       // official appearance — so counting them here would advertise a number that disagrees
       // with the README and with npm's description ("6 skins"). The cards are named in the
       // same line instead, so nothing is hidden by leaving them out of the number.
-      const builtInCards = ids.filter((id) => BUILT_IN_LABELS[id] !== undefined).length
+      // 宠物挂件卡/心情问候卡/菜单折叠卡同理：它们不是主题、不换配色，只开关各自的
+      // 功能，所以与内置卡一起排除在"皮肤数"之外（copy-consistency 的正则钉住的是
+      // skinCount 那一行的形状）。
+      const builtInCards = ids.filter((id) => BUILT_IN_LABELS[id] !== undefined
+        || id === PET_WIDGET.id || id === MOOD_WIDGET.id || id === MENU_COLLAPSE_WIDGET.id).length
       const skinCount = ids.length - builtInCards
       return jsxs('div', {
         className: 'tg-page',
@@ -6724,6 +10334,21 @@ window.__ModuleLoader__.load({
               // shell exactly like clicking the card would — so the anchor becomes active
               // and the scheme layer has something to sit on.
               onPickScheme: (schemeId) => { pickScheme(schemeId) },
+              // 挂件卡：点击 = 开关挂件（见 ThemeCard 的挂件分支）。开关状态也一并传下去，
+              // 徽标与 aria-pressed 都读它。
+              onTogglePet: () => { togglePet() },
+              petEnabled: petEnabled === true,
+              // 头像选择行：点亮哪颗、卡面画哪只，都读这个字段（publish 从 localStorage 报来）。
+              petKind: typeof petKind === 'string' && petKind !== '' ? petKind : 'ban-ban',
+              onPickPet: (kindId) => { pickPet(kindId) },
+              // 心情问候卡：胶囊开关与三组 chips 都读这些字段（publish 从 localStorage 报来）。
+              mood: { on: moodOn === true, speed: moodSpeed, direction: moodDirection, zone: moodZone },
+              onToggleMood: () => { toggleMood() },
+              onSetMood: (patch) => { setMood(patch) },
+              // 菜单折叠卡：点击 = 收起/恢复侧栏入口（见 ThemeCard 的折叠分支）。
+              // 状态从 localStorage 报来，徽标与 aria-pressed 都读它。
+              menuCollapsed: menuCollapsed === true,
+              onToggleMenuCollapse: () => { toggleMenuCollapse() },
               t,
             }, id)),
           }),
@@ -6734,7 +10359,7 @@ window.__ModuleLoader__.load({
           // reference block — and the caption is what keeps them from being mistaken for a
           // malfunction, which is exactly how a user read them. They stay CONDITIONAL:
           // detail waits for the debug switch, while a warning or a failure always prints.
-          (debugEnabled() || showScenery)
+          (debugEnabled() || showScenery || showPet || showMood)
             ? jsxs('div', {
               className: 'tg-diag',
               children: [
@@ -6749,6 +10374,18 @@ window.__ModuleLoader__.load({
                     children: scenery,
                   })
                   : null,
+                showPet
+                  ? jsx('div', {
+                    className: `tg-debug${petLineIsWarning(petLine) ? ' tg-warn' : ''}`,
+                    children: petLine,
+                  })
+                  : null,
+                showMood
+                  ? jsx('div', {
+                    className: `tg-debug${moodLineIsWarning(moodLine) ? ' tg-warn' : ''}`,
+                    children: moodLine,
+                  })
+                  : null,
               ],
             })
             : null,
@@ -6792,6 +10429,23 @@ window.__ModuleLoader__.load({
     /** Display name used in client diagnostics. */
     exports.name = 'theme-gallery'
 
+    /**
+     * 心情问候的座位：shell.overlay 槽位里的一张静态 div。
+     *
+     * 零 hooks、零 props——问候条的几何/文本/速度全由 mood 模块命令式管理
+     * （见 moodBuildBar），这张 div 只是给 React 一个可卸载的挂载点。
+     * `data-dsh-mood-seat` 是 MOOD_SEAT_SELECTOR 找它的稳定钩子（自己的数据属性，
+     * 不依赖框架的哈希类名——SKILL §13 的老规矩）。
+     * @returns the seat element.
+     */
+    function MoodSeat() {
+      return jsx('div', {
+        className: 'dsh-mood-seat',
+        'data-dsh-mood-seat': '',
+        'aria-hidden': 'true',
+      })
+    }
+
     /**
      * The HARD dependency list — deliberately ONE entry.
      *
@@ -6822,17 +10476,26 @@ window.__ModuleLoader__.load({
      * That is the pair that makes it safe, and this package now has both:
      *
      *   package.json  dsh.client.inject = ["@deepseek-ai/dsh-client-locale",
+     *                                      "@deepseek-ai/dsh-client-ui-layout",
      *                                      "@deepseek-ai/dsh-client-ui-theme"]
-     *   here          exports.inject   = ['slots', 'locale', 'theme']
+     *   here          the inject list   = ['slots', 'locale', 'theme', 'layout']
      *
      * The two earlier failures were the `modifies` cycle and the missing module declaration.
-     * Both are fixed, and both are asserted in `tests/check-boot-safety.mjs`.
+     * Both are fixed, and both are asserted in `tests/check-boot-safety.mjs`. `layout` joined
+     * in 2026-09-27 for the settings-section jump: without the declaration `ctx.layout` is
+     * undefined and the "open panel" button silently only closed the dialog (实测读数).
+     * Note: the assertion regex is anchored to line start — prose examples like this one
+     * must NOT be written as `exports.inject = [...]`, or the static audit reads the comment.
      *
      * `locale` is declared for the same reason: the sidebar row resolves its label through it,
      * and the providing module is declared in the manifest.
      * @type {string[]}
      */
-    exports.inject = ['slots', 'locale', 'theme']
+    // `layout` 是设置分节「打开主题皮肤面板」的跳转面（ctx.layout.selectPanel —— 官方
+    // Context 合并声明，契约原文说它就是给其他插件做面板切换的横切面）。实机读数
+    // 2026-09-27：没声明它时 ctx.layout 是 undefined，跳转按钮只关了弹窗 —— 插件
+    // 能读到哪些服务完全由这份清单决定，缺一个就是静默失败。
+    exports.inject = ['slots', 'locale', 'theme', 'layout']
 
     /**
      * Marks this client module as a PLUGIN rather than a plain service module.
@@ -7578,11 +11241,25 @@ window.__ModuleLoader__.load({
         // The registry keeps the order things were registered in, so re-ranking a card can
         // never change which themes exist, what they contain, or the order they were
         // contributed — `cardsInDisplayOrder` is a view over the filtered list.
-        const themes = cardsInDisplayOrder([...snapshot.themes].filter((theme) => !OMITTED_IDS.has(theme.id)))
+        // 宠物挂件卡不是主题、不在注册表里：作为一张**只存在于面板**的卡片数据追加进来，
+        // 与其他卡走同一条排序管线（见 `petWidgetCardTheme`）。菜单折叠卡同构。
+        const themes = cardsInDisplayOrder([...snapshot.themes].filter((theme) => !OMITTED_IDS.has(theme.id))
+          .concat([petWidgetCardTheme(), moodCardTheme(), menuCollapseCardTheme()]))
         storeActions.sync(themes, appliedCardId(snapshot), revision)
         // 卡片上点亮哪一格，以及要不要把那一层配色叠上去 —— 两件事都读同一份
         // localStorage，所以"看到的选中态"与"屏幕上的颜色"不可能对不上。
         storeActions.markScheme(wantedScheme())
+        // 挂件卡的徽标读同一个来源：localStorage 里记着的开关状态。
+        storeActions.markPet(petWidgetOn())
+        // 头像选择行的点亮态与卡面图案也读同一个来源：当前是哪只宠物。
+        storeActions.markPetKind(readPetState().kind)
+        // 心情问候卡的胶囊开关与三组 chips 读同一个来源。
+        storeActions.markMood(readMoodState())
+        // 菜单折叠卡的徽标与 aria-pressed 读同一个来源。
+        storeActions.markMenuCollapse(menuCollapsed())
+        // 问候条是幂等同步：状态/几何/文本没变就一个字节都不写（moodBuildBar 指纹守卫），
+        // 所以 publish 顺路调用它没有性能负担，还负责把"座位晚渲染"捡起来。
+        syncMoodBar()
         syncSkin(snapshot)
         syncRememberedSkin(snapshot)
         syncScheme(snapshot)
@@ -7649,6 +11326,109 @@ window.__ModuleLoader__.load({
         }
       }
 
+      /**
+       * 用户点了挂件卡（或卡上的开关动作）：翻转开关、同步舞台、刷新面板。
+       *
+       * 这条路**完全不碰主题服务** —— 挂件与当前是什么皮肤正交，所以它能与任何皮肤
+       * （包括山青婷彩 / 梦海游鱼）同时开启，也不消耗主题写入预算。
+       * `publish()` 会把新状态经 `markPet` 报给页面，徽标与 aria-pressed 随之更新。
+       */
+      function togglePetWidget() {
+        try {
+          const next = !petWidgetOn()
+          savePetState({ on: next })
+          petRun.enabled = next
+          syncPetStage()
+          publish(ctx.theme.getTheme())
+        } catch (error) {
+          console.error('[theme-gallery] could not toggle the pet widget:', error)
+        }
+      }
+
+      /**
+       * 用户点了心情问候卡（或卡上的胶囊开关）：翻转开关、同步问候条、刷新面板。
+       *
+       * 与 `togglePetWidget` 同一条路：**完全不碰主题服务** —— 问候与当前是什么皮肤
+       * 正交；`publish()` 会把新状态经 `markMood` 报给页面，徽标与 aria-checked 随之更新。
+       */
+      function toggleMoodWidget() {
+        try {
+          const next = !readMoodState().on
+          saveMoodState({ on: next })
+          syncMoodBar()
+          publish(ctx.theme.getTheme())
+        } catch (error) {
+          console.error('[theme-gallery] could not toggle the mood greeting:', error)
+        }
+      }
+
+      /**
+       * 用户点了问候卡上的一枚设置 chip（速度/方向/区域）。
+       * 只认表里真实存在的值（MOOD_SPEEDS / ltr-rtl / MOOD_ZONE_GEOMETRY），
+       * 不认识的静默丢 —— 与 chooseScheme 拒绝不认识方案 id 同一条规矩：
+       * 写进 localStorage 会让下次启动带着一个点不亮的选中态。
+       * @param patch - `{ speed? , direction?, zone? }` 的部分字段。
+       */
+      function setMoodSettings(patch) {
+        try {
+          const clean = {}
+          if (patch !== null && typeof patch === 'object') {
+            if (typeof patch.speed === 'string' && patch.speed in MOOD_SPEEDS) clean.speed = patch.speed
+            if (patch.direction === 'ltr' || patch.direction === 'rtl') clean.direction = patch.direction
+            if (typeof patch.zone === 'string' && patch.zone in MOOD_ZONE_GEOMETRY) clean.zone = patch.zone
+          }
+          if (Object.keys(clean).length === 0) return
+          saveMoodState(clean)
+          syncMoodBar()
+          publish(ctx.theme.getTheme())
+        } catch (error) {
+          console.error('[theme-gallery] could not set the mood settings:', error)
+        }
+      }
+
+      /**
+       * 用户点了菜单折叠卡：翻转折叠状态、收放侧栏入口、刷新面板。
+       *
+       * 这条路**完全不碰主题服务** —— 折叠只改侧栏入口的显隐，面板本体（main 槽位）
+       * 与设置分节（settings.section）恒在，所以从任何一侧都能把开关翻回来。
+       * `publish()` 会把新状态经 `markMenuCollapse` 报给页面。
+       */
+      function toggleMenuCollapse() {
+        try {
+          saveMenuCollapseState({ collapsed: !menuCollapsed() })
+          syncSidebarEntry()
+          publish(ctx.theme.getTheme())
+        } catch (error) {
+          console.error('[theme-gallery] could not toggle the menu collapse:', error)
+        }
+      }
+
+      /**
+       * 用户点了挂件卡上的一颗头像：换成那只宠物并放它出场。
+       *
+       * 语义（需求 R2）：挂件关着时点头像 = 顺路**打开**（"点哪只出哪只"，即时反馈）；
+       * 开着时 = 只换宠物。`placed` 一并复位 —— 不同宠物尺寸不同，继承上一只的
+       * 视口偏移会错位，切宠即按新宠物的缺省摆位重新入座、跑向自己的道具。
+       * 这条路与 `togglePetWidget` 一样**完全不碰主题服务**。
+       * @param kindId - 宠物 id（不认识的静默拒绝，照 chooseScheme 的规矩）。
+       */
+      function selectPetWidget(kindId) {
+        try {
+          if (!PET_KIND_BY_ID.has(kindId)) return
+          const turningOn = !petWidgetOn()
+          const patch = { kind: kindId, placed: false }
+          if (turningOn) patch.on = true
+          savePetState(patch)
+          petRun.enabled = true
+          removePetStage()
+          petNoteInteraction()
+          syncPetStage()
+          publish(ctx.theme.getTheme())
+        } catch (error) {
+          console.error('[theme-gallery] could not select the pet:', error)
+        }
+      }
+
       /**
        * 卡片上「已应用」徽标应该落在哪一张卡上。
        *
@@ -7833,6 +11613,9 @@ window.__ModuleLoader__.load({
           }
           const active = lastSnapshot?.active?.id
           const kind = typeof active === 'string' ? bundledTheme(active)?.ambient?.kind : undefined
+          // 宠物挂件不依赖侧栏，只锚输入框：放在侧栏存在性判断**之前**，节流与本帧合并
+          // 共用（resync 至多每帧一次）。未开启时它第一行就返回，成本是一次布尔判断。
+          syncPetStage()
           if (sidebarColumn() === null) {
             // Recorded even though there is nothing to draw. An attempt that finds no sidebar
             // is the likeliest explanation for boot-time silence, and the old report could not
@@ -8000,6 +11783,35 @@ window.__ModuleLoader__.load({
       // shipped panel plugins use the plain form, so this does too — the extra
       // machinery was unverified, and a subscription that never installs is
       // indistinguishable from a panel that never registers.
+      /**
+       * 面板的 inject 面：侧栏页与设置分节（MenuSettingsSection）共用的同一份动作。
+       * **刻意零主题写入的新增** —— setTheme 是外壳槽位动作（审计允许清单精确匹配
+       * 的那一条），其余全部只写 localStorage。
+       * @returns 动作面（含 pinned store，供设置分节的 useSyncExternalStore 订阅）。
+       */
+      function buildPanelFace() {
+        return {
+          setTheme: (id) => { ctx.theme.setTheme(id) },
+          // 配色卡上的 15 个色值按钮走这条。它**不直接**切主题（见 `chooseScheme`），
+          // 所以这里不新增主题写入点。
+          pickScheme: (schemeId) => { chooseScheme(schemeId) },
+          // 挂件卡走这条：只开关挂件、只写 localStorage，同样不新增主题写入点。
+          togglePet: () => { togglePetWidget() },
+          // 头像选择行走这条：换宠物（必要时顺路打开），同样零主题写入。
+          pickPet: (kindId) => { selectPetWidget(kindId) },
+          // 心情问候卡走这两条：胶囊开关/点卡身开关、三组设置 chips。
+          // 一样零主题写入 —— 问候与皮肤正交。
+          toggleMood: () => { toggleMoodWidget() },
+          setMood: (patch) => { setMoodSettings(patch) },
+          // 菜单折叠卡走这条：收放侧栏入口、只写 localStorage，同样不新增主题写入点。
+          toggleMenuCollapse: () => { toggleMenuCollapse() },
+          // 设置分节组件用：pinned store 实例（subscribe/getSnapshot —— StoreInstance
+          // 契约上没有 getState，白屏事故的根因就是按 getState 读的），MenuSettingsSection
+          // 经 useSyncExternalStore 把它绑定成响应式视图。
+          store: storeInstance,
+        }
+      }
+
       ctx.slots.inject('main', () => {
         const disposePage = ctx.slots.register({
           name: 'main',
@@ -8014,12 +11826,7 @@ window.__ModuleLoader__.load({
             // — so it is set BEFORE the publish that reads it.
             injectRan = true
             publish(ctx.theme.getTheme())
-            return {
-              setTheme: (id) => { ctx.theme.setTheme(id) },
-              // 配色卡上的 15 个色值按钮走这条。它**不直接**切主题（见 `chooseScheme`），
-              // 所以这里不新增主题写入点。
-              pickScheme: (schemeId) => { chooseScheme(schemeId) },
-            }
+            return buildPanelFace()
           },
         }, ThemeGalleryPage)
 
@@ -8062,13 +11869,76 @@ window.__ModuleLoader__.load({
       // Sidebar entrance: the list id IS the main-panel key. `locale` is declared
       // the way the shipped panel entries declare it, so the row label resolves
       // through the dictionary rather than a raw string.
-      ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({
-        name: 'sidebar.panellist',
-        id: PANEL_ID,
-        order: 30,
+      // 菜单折叠（方案二）：注册/撤销随折叠开关走 —— syncSidebarEntry 读 localStorage
+      // 决定是否注册；设置页的常驻分节不受它影响（面板永远可达，不会把自己锁在外面）。
+      syncSidebarEntry()
+
+      /**
+       * 一级设置分节（`settings.section`）：完整面板常驻于 设置 → 分节列表。
+       * 槽位契约（官方 d.ts）：id = 分节键、order = 导航位置、label = 注册方本地化文案、
+       * 内容组件 + inject 面由注册方自带。order 的标定读数与"agent预设下方"的对位
+       * 见 SETTINGS_SECTION_ORDER 的文档。
+       */
+      ctx.slots.inject('settings.section', () => {
+        try {
+          const unregister = ctx.slots.register({
+            name: 'settings.section',
+            id: PANEL_ID,
+            order: SETTINGS_SECTION_ORDER,
+            label: () => zh.title,
+            locale: NS,
+            inject: () => buildPanelFace(),
+          }, MenuSettingsSection)
+          return () => { unregister() }
+        } catch (error) {
+          // 分节注册失败绝不拖垮挂载（面板仍在侧栏/主区可达）；失败本身要留痕。
+          console.error('[theme-gallery] could not register the settings section:', error)
+          return () => {}
+        }
+      })
+
+      /* ---------------- mood greeting seat ----------------
+       *
+       * 问候条本体由 mood 模块命令式地建进这张座位（`shell.overlay` 是官方扩展点：
+       * 布局壳在 AppFrame 最后渲染 `[data-shell-overlay]`，quota 提示、快捷键弹窗等
+       * 五个官方包都往里注册组件）。座位是一张**静态 div**：零 hooks（本插件只引
+       * jsx/jsxs，不引 react），一切状态由 localStorage 报给 store、由 publish 驱动
+       * syncMoodBar。`aria-hidden`：滚动文字对读屏是噪音，装饰读数走面板自检行。
+       *
+       * 为什么不直接 append 到 body（挂件的做法）：overlay 条目随外壳的 React 生命
+       * 周期走，外壳重组合时不会留下孤儿条；"座位还没渲染"由 moodReport 留读数、
+       * 下一次 publish 再捡，不轮询。
+       *
+       * 注入回调返回的清理函数在插件卸载时收尾全部计时器/监听器/样式表 ——
+       * **刻意不叫 `…Dispose`**：那是自发光守卫审计里主题层专用模式的名字（规则 1）。
+       */
+      ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+        name: 'shell.overlay',
+        id: 'theme-gallery:mood',
         locale: NS,
-        label: () => zh.title,
-      }, PanelGlyph))
+        inject: () => ({}),
+      }, MoodSeat))
+
+      /* ---------------- pet widget ----------------
+       *
+       * 启用状态在挂载时读一次 localStorage（存进 petRun.enabled 作镜像，避免 resync
+       * 每帧都读存储），开着就把舞台建起来；关闭时什么都不装。卸载时整层拆掉 ——
+       * 舞台、样式表与全部定时器都在 removePetStage 里收尾。
+       */
+      ctx.effect(() => {
+        if (typeof document === 'undefined') return
+        petRun.enabled = petWidgetOn()
+        if (petRun.enabled) syncPetStage()
+        return () => { removePetStage() }
+      }, 'theme-gallery: pet widget')
+
+      /* 心情问候：挂载即首建（座位可能还没渲染——syncMoodBar 会留读数，等 publish
+       * 顺路再捡），卸载时收尾全部计时器/监听器/条/样式表。 */
+      ctx.effect(() => {
+        if (typeof document === 'undefined') return
+        syncMoodBar()
+        return () => { moodTeardown() }
+      }, 'theme-gallery: mood greeting')
 
       /* ---------------- reading state ---------------- */