dsh-wisp 1.37.0 → 1.44.0

package/lib/client.js

@@ -51,7 +51,7 @@ window.__ModuleLoader__.load({
     var exports = module.exports
     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 
-    const VERSION = '1.37.0'
+    const VERSION = '1.44.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -81,6 +81,17 @@ const WHATS_NEW = {
   '1.35.0': '她开始替你值班：你走开时看着，回来报账；还能说今日小结。',
   '1.36.0': '她会说英文了（跟随界面语言/系统语言，也能强制）；音效与"汇报"姿势已就位。',
   '1.37.0': '菜单里能直接选台词语言（跟随界面 / 中文 / English），选一次就记住。',
+  '1.38.0': '她有身体了：按下去会压一下弹回来、拖着会侧身、落地会顿一下，指针靠近会朝你倾过来。',
+  '1.39.0': '她会看你的余额了（菜单里点一下），未登录或查不到时如实说。',
+  '1.40.0': '她的透明处真的点不到了：按轮廓命中，站在按钮上也不挡你点它。',
+  '1.41.0': '检查更新更耐得住：一个源连不上不再把另一个拖死，失败时 doctor() 会说清是哪个源、为什么。',
+  '1.42.0': '查更新失败时她会直接说清是哪一种：没通道 / 连不上 / 宿主没应答。',
+  '1.43.0': '一批"真的用鼠标点过一遍"才发现的问题：拨完开关面板不再消失、大小能调回出厂值、触摸与指针离开不再留姿势、静止档真的会停。',
+  '1.43.1': '检查更新多了一条兜底通道（问插件管理器），并且失败时会直接说出"为什么拿不到"。',
+  '1.43.2': '台词只说人话；查不成的原因排进「关于她」弹窗，不再往句子里塞英文碎片。',
+  '1.44.0': '查更新改成客户端自己抓（bundle 插件没有 host RPC 座位）—— 这才是它一直缺的那条路。',
+  '1.43.4': '把查更新失败时的诊断临时写进窗口标题，供定位用。',
+  '1.43.3': '把"没接上宿主"和"宿主没有网络通道"分成两句 —— 断在哪一环，一句话就看得出来。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -90,6 +101,11 @@ const WHATS_NEW = {
    所以这里只做三件真能做的事：报版本、说她更新了、把包名复制给你去 DSH 里装。 */
 const SEEN_VERSION_KEY = 'dsh-wisp:seen-version:v1'
 const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
+/* 但"按包名安装"只在 npm 上已经有这一版时成立。npm 暂存（或还没发）而 GitHub
+   已经更新时，照那句话装回来的是**旧版** —— 她得改口，并复制仓库地址而不是包名。
+   她本来就知道这个版本号是从哪个源读到的（updateCheck.from / sources）。 */
+const UPDATE_REPO = 'https://github.com/969246694/dsh-wisp'
+const UPDATE_HINT_GITHUB = 'npm 上还是旧版，用这个地址装 dsh-wisp：' + UPDATE_REPO
 
     /* ---- sprites: 256x384 WebP, transparent, inlined by build.mjs ---- */
     const SPRITES = {
@@ -219,11 +235,63 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
     const WAKE_THROTTLE_MS = 1000
     const WORRIED_MS = 3500                 // 出错表情持续多久
 
+    /* ---------------------------------------------------------------------
+       动作（motion）。
+
+       在这之前，"她的动作"只有两件事：换一张精灵图，以及一条常驻的呼吸
+       循环动画。按下、拖动、松手这些**手势**在画面上没有任何回应 —— 她像
+       一张贴在屏幕上的图，而不是一个被碰到会有反应的东西。
+
+       这里补的是"身体感"，而且刻意只用 CSS 关键帧 + 一个样式变量：插件
+       的稳态开销承诺是**零动画帧**（见 README 性能表），加一条 rAF 循环
+       就等于把那条承诺撤掉。所有动作都是"事件写一次属性，浏览器自己算"。
+
+       三个层各管一件事。CSS 的 transform 在同一个元素上是**覆盖**而不是
+       叠加，所以"分层"不是设计洁癖，是唯一做法：
+
+         .wisp-body    情绪动画（呼吸 / 跳 / 推 / 担心）—— 既有，不动
+         .wisp-motion  一次性动作（按下压一下 / 落地顿一下 / 换表情弹一下）
+                       由 data-accent 驱动，放外层 → 落地时的压扁是**屏幕坐标**
+                       里的竖直方向（重力方向），不会跟着侧倾一起歪
+         .wisp-lean    持续姿势（拖动速度 / 指针靠近 / 溜达方向）
+                       由 --wisp-tilt 驱动，旋转原点在脚底 → 像钟摆，不像转盘
+
+       data-accent 的取值里，pop-a / pop-b 是**同一件事的两个名字**：改
+       animation-name 是让同一条动画立刻重播的唯一可靠办法（同一个值再写
+       一次不会重播），而连戳两下必须看到两次弹。
+       --------------------------------------------------------------------- */
+    const MOTION_AMP = { full: 1, subtle: 0.5, off: 0 }
+    const TILT_DRAG_MAX = 8        // 拖动时最大侧倾（度）
+    const TILT_DRAG_PER_PX = 0.55  // 每一次指针事件横向走 1px 折算多少度（≈速度）
+    const TILT_NEAR_MAX = 3.5      // 指针靠近时最大侧倾（度）
+    const TILT_NEAR_PX = 170       // 多远算"她注意到你了"
+    const TILT_GLIDE_MAX = 2.5     // 溜达时朝行进方向前倾（度）
+    const TILT_GLIDE_PER_PX = 0.02 // 溜达距离折算成前倾角的斜率
+    /* 变化小于这个数就不写样式 —— pointermove 一秒能来上百次，而 0.05° 在
+       屏幕上是看不见的。写一次 = 一次样式重算，阈值就是它的闸门。 */
+    const TILT_STEP = 0.05
+
+    /* 动作时长必须是**代码**里的一份：CSS 只负责怎么动，什么时候收手由这里
+       决定（和 glide 的 1700ms 一个路子）。两边对不上就会出现"动画早放完了，
+       属性还挂着"或者反过来的空档。
+       没有 release：松手之后紧接着就是**点击反应**（换表情 → 弹一下），两者
+       抢同一个通道，而反应赢 —— "手指抬起来了"不值得盖过"她换了个表情"。
+       通道只留最后发生的那件事，不留一个永远演不到的关键帧。 */
+    const ACCENT_MS = { press: 200, land: 560, pop: 380 }
+
+    /* 换表情时"弹一下"的表情集合。idle / alert / sleep 不在里面：它们要么是
+       长时间稳态，要么由轮询反复重算，弹一下就变成抖。 */
+    const POPPY_MOODS = ['happy', 'poked', 'proud', 'attn', 'care', 'eat', 'worried', 'report']
+
     const DEFAULTS = {
       bottom: GROUND,
       right: 26,
       sleepAfterMs: 90000,
       reactions: true,
+      /* 交互动效档位：full 灵动 / subtle 克制（半幅）/ off 静止。
+         默认全开 —— 但必须有一个**不用改系统设置**就能让她安静下来的开关，
+         prefers-reduced-motion 是给"所有动画"的，不是给"我不想让她动"的。 */
+      motion: 'full',
       size: 4,                  // 560x840 CSS px, drawn from the 2048x3072 tier
       persist: true,            // remember where she was dragged to
       celebrate: true,          // cheer when a run finishes
@@ -240,6 +308,14 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       backAfterMs: 120000,      // 离开超过这么久，回来时她会说一句（2 分钟；0 = 关）
       milestones: true,         // 今日轮次到达里程碑时得意一下
       memory: true,             // 她记着你：一起多少天 / 常放哪个角 / 常穿哪套
+      /* lang 与 soundVolume 曾经**只在 CONFIG_SPEC 里声明、DEFAULTS 里没有**：
+         前者靠 isZhNow() 把非字符串兜成 'auto' 侥幸没事，后者直接是 undefined →
+         `Number(undefined)` = NaN → `clip.volume = NaN` 在浏览器里抛，被
+         playSound 的 try/catch 吞掉 —— 于是"打开音效"整条路静默失效。
+         配置键的两个"端"（声明 / 默认值）现在由预检钉住。 */
+      lang: 'auto',             // 'auto' 跟随界面语言；'zh' / 'en' 强制
+      sound: false,             // 音效默认关（无故出声是最招人烦的交互之一），且要有素材
+      soundVolume: 0.7,         // 音效音量（音效本身默认关，且要有 assets/audio 才存在）
       happyMs: 1100,
       wander: true,             // stroll around on her own while idle
       wanderMs: 45000,          // how often she considers moving
@@ -398,6 +474,16 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
       updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
       updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
+      /* 失败不是一个笼统的状态：「这个壳里没有联网的通道」「两个源都没连上」
+         「宿主那边没应答」是三件事，含糊地说成"没查到"就没人能追下去 ——
+         而用户看到的恰恰只有那一句。 */
+      updateNoChannel: ['这个壳里我没有联网的通道，查不了更新。', '这里没有能出去的网络通道。'],
+      /* 两种"没通道"必须分开说 —— 它们是链路上**不同的一环**断了：
+         · 没接上宿主半包（客户端这一侧连 `host.call` 都没有）
+         · 宿主跑了，但它拿不到 `web` 服务
+         合并成一句话的代价是：谁也说不清断在哪一环（这个坑真踩过）。 */
+      updateNoSeat: ['我没接上宿主半包，查不了更新。', '宿主那边没接上，查不了更新。'],
+      updateNoHost: ['宿主那边没应答，更新没查成。', '问不到宿主，更新没查成。'],
       milestone: [
         '今天第 {n} 轮了。', '{n} 轮了，还不错。', '已经 {n} 轮了，你挺能撑。',
         '第 {n} 轮 —— 我数着呢。', '{n} 轮，进度可观。', '今天 {n} 轮，记上了。',
@@ -409,6 +495,17 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
         '去窗边看看。', '我在这儿等你回来。', '坐太久了，动一下。', '你不动，我就一直看着你。',
       ],
       hint: ['右键我一下试试。', '右键我有菜单。', '拖我，或者右键我。'],
+
+      /* 余额。数字由客户端拼好（{n}），台词只管口气 —— 她报的是账户，
+         不是她自己的钱，所以既不邀功也不夸张。 */
+      balanceChecking: ['看一下……', '等等，我查查。', '让我看看。'],
+      balance: ['余额 {n}。', '还有 {n}。', '{n}，暂时够用。', '账上是 {n}。'],
+      balanceBonus: ['其中赠送 {n}。', '还有 {n} 是赠送的。'],
+      balanceEmpty: ['没查到余额记录。', '账上没有额度记录。'],
+      balanceSignedOut: ['没登录，看不到余额。', '这个得先登录才行。', '还没登录，余额在平台那边。'],
+      balanceUnavailable: ['刚才没读到，一会儿再看。', '这一下没读到，稍后再试。'],
+      balanceFailed: ['余额没查成。', '这个没读出来，稍后再试。'],
+      balanceUnsupported: ['这个壳里我查不了余额。', '这里没有查余额的通道。'],
     }
 
     /* 英文台词。**只翻译她说的话**（菜单按钮文案仍由 DSH 界面语言决定，不在这一层）。
@@ -443,6 +540,18 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       backSoon: ['Back already?', 'There you are.'],
       backLong: ['You were gone a while.', 'Long break. Welcome back.'],
       streak: ['{n} days in a row.', 'Day {n} together.'],
+      updateFailed: ["The update check didn't work.", "Couldn't reach the update sources."],
+      updateNoChannel: ["This shell gives me no network channel, so I can't check for updates.", 'No way out to the network from here.'],
+      updateNoSeat: ["I'm not connected to my host half, so I can't check for updates.", 'No host half attached.'],
+      updateNoHost: ["The host side didn't answer — the update check failed.", 'No answer from the host.'],
+      balanceChecking: ['One moment…', 'Let me check.'],
+      balance: ['Balance: {n}.', "You've got {n}.", '{n} on the account.'],
+      balanceBonus: [' {n} of that is credit.', ' ({n} is credit.)'],
+      balanceEmpty: ['No balance record came back.', 'Nothing on the account.'],
+      balanceSignedOut: ["You're signed out — I can't see the balance.", 'Sign in first and I can read it.'],
+      balanceUnavailable: ["Couldn't read it just now — try again in a bit.", 'That read did not go through.'],
+      balanceFailed: ["The balance lookup didn't work.", "Couldn't read that — try again later."],
+      balanceUnsupported: ["I can't reach the balance from this shell.", 'No balance channel here.'],
     }
 
     /* 语言：中文环境（或读不到语言）用中文，其余走英文覆盖层。
@@ -586,7 +695,10 @@ const SOUNDS = (typeof __WISP_SOUNDS__ === 'object' && __WISP_SOUNDS__ !== null)
       if (Ctor === null) return
       try {
         const clip = new Ctor(src)
-        clip.volume = Math.max(0, Math.min(1, Number(cfg.soundVolume)))
+        /* 音量必须落到 [0,1] 内的有限数：给媒体元素设 NaN/Infinity 会**抛异常**，
+           而这一整段是被 catch 包住的 —— 一个坏值会让音效静默消失，看起来像"开关没反应"。 */
+        const volume = Number(cfg.soundVolume)
+        clip.volume = isFinite(volume) ? clamp(volume, 0, 1) : 0.7
         const started = clip.play()
         if (started && typeof started.catch === 'function') started.catch(() => { /* 自动播放被拦下就作罢 */ })
       } catch (e) { /* 音效永远不该打断别的事 */ }
@@ -617,6 +729,7 @@ const SOUNDS = (typeof __WISP_SOUNDS__ === 'object' && __WISP_SOUNDS__ !== null)
       wanderMs: { kind: 'num', lo: 5000, hi: 3600000 },
       wanderRange: { kind: 'num', lo: 0, hi: 2000 },
       reactions: { kind: 'bool' },
+      motion: { kind: 'one', of: Object.keys(MOTION_AMP) },
       persist: { kind: 'bool' },
       celebrate: { kind: 'bool' },
       wander: { kind: 'bool' },
@@ -629,6 +742,9 @@ const SOUNDS = (typeof __WISP_SOUNDS__ === 'object' && __WISP_SOUNDS__ !== null)
       const spec = CONFIG_SPEC[key]
       if (spec.kind === 'num') return num(value, spec.lo, spec.hi, fallback)
       if (spec.kind === 'str') return typeof value === 'string' ? value : fallback
+      /* 枚举：认不出来的值一律退回 fallback。写错一个档位名不该让她变成
+         "动也不动、也没有报错"的那种坏状态。 */
+      if (spec.kind === 'one') return spec.of.indexOf(value) >= 0 ? value : fallback
       return bool(value, fallback)
     }
 
@@ -805,8 +921,13 @@ const SOUNDS = (typeof __WISP_SOUNDS__ === 'object' && __WISP_SOUNDS__ !== null)
 .wisp-root{position:absolute;width:${BOX_W}px;height:${BOX_H}px;pointer-events:none;transform-origin:top center;--wisp-aura:rgba(110,200,255,.42)}
 .wisp-root[data-dragging="true"]{will-change:transform}
 .wisp-root[data-gliding="true"]{transition:transform 1.6s cubic-bezier(.4,0,.2,1)}
-.wisp-body{position:absolute;inset:0;pointer-events:auto;cursor:grab;touch-action:none;user-select:none;-webkit-user-select:none;animation:wisp-bob 5.6s ease-in-out infinite}
-.wisp-body:active{cursor:grabbing}
+.wisp-body{position:absolute;inset:0;pointer-events:none;touch-action:none;user-select:none;-webkit-user-select:none;animation:wisp-bob 5.6s ease-in-out infinite}
+/* 命中层：一个**不画任何东西**的空盒子，只负责被鼠标点到。它带一层由 alpha 蒙版
+   生成的 clip-path —— 于是"透明处点不到"是**浏览器**做的，而不是 JS 事后补救：
+   事件根本不会派到她身上，下面的应用照常收到 hover / 点击 / 右键 / 滚轮。
+   （只写 pointer-events:none 是不够的：那只是不拦她自己的事，盒子仍然盖在应用上面。） */
+.wisp-hit{position:absolute;inset:0;pointer-events:auto;cursor:grab}
+.wisp-hit:active{cursor:grabbing}
 .wisp-img{position:absolute;inset:0;width:100%;height:100%;object-fit:contain;object-position:bottom center;filter:drop-shadow(0 6px 14px rgba(0,0,0,.30));transition:opacity .28s ease,filter .5s ease}
 .wisp-shine{position:absolute;left:50%;bottom:-8px;width:68%;height:16px;margin-left:-34%;border-radius:50%;background:radial-gradient(ellipse at center,var(--wisp-aura) 0%,transparent 70%);filter:blur(4px);pointer-events:none;transition:background .5s ease}
 .wisp-zzz{position:absolute;right:6px;top:8px;font-size:calc(13px * var(--wisp-scale));font-weight:600;color:var(--wisp-ink);text-shadow:0 0 8px var(--wisp-aura);animation:wisp-zzz 2.6s ease-out infinite;pointer-events:none}
@@ -829,6 +950,31 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 .wisp-root[data-mood="attn"] .wisp-body{animation-name:wisp-nudge;animation-duration:1.5s;animation-iteration-count:4}
 @keyframes wisp-nudge{0%,100%{transform:translate3d(0,0,0)}25%{transform:translate3d(-7px,0,0)}75%{transform:translate3d(7px,0,0)}}
 @keyframes wisp-hop{0%,100%{transform:translate3d(0,0,0)}45%{transform:translate3d(0,-16px,0)}}
+/* ---- 动作层（见文件上方 motion 常量处的说明）----
+   两层都是**空盒子**：绝对定位铺满、不吃指针。姿势与一次性动作分别只碰自己
+   那一层的 transform，所以它们永远不会互相覆盖。
+   transform-origin 放在脚底：压扁是"踩在地上压下去"，侧倾是"钟摆"，不是"转盘"。 */
+.wisp-motion,.wisp-lean{position:absolute;inset:0;pointer-events:none;transform-origin:50% 100%}
+.wisp-lean{transform:rotate(var(--wisp-tilt,0deg));transition:transform .5s cubic-bezier(.22,1.2,.36,1)}
+/* 拖动中姿势必须**跟手**：一有过渡，拖起来就像拽着一根橡皮筋。 */
+.wisp-root[data-dragging="true"] .wisp-lean{transition:none}
+/* 幅度档位：一个变量管住所有一次性动作的幅度（关键帧里用 calc 乘它），
+   指针侧倾的幅度在 JS 里读同一张表 —— 两边不会各调各的。 */
+.wisp-root{--wisp-amp:1}
+.wisp-root[data-motion="subtle"]{--wisp-amp:.5}
+.wisp-root[data-motion="off"]{--wisp-amp:0}
+/* 静止档：连呼吸和 z 都停 —— 她说"我不想让她动"时，是最彻底的静止。 */
+.wisp-root[data-motion="off"] .wisp-body,.wisp-root[data-motion="off"] .wisp-zzz{animation:none}
+/* 但"不动"不等于"冻住"：动画一关，z 会停在满不透明的初始态，看起来像一个卡住的字 */
+.wisp-root[data-motion="off"] .wisp-zzz{opacity:.5}
+.wisp-root[data-accent="press"] .wisp-motion{animation:wisp-press .2s ease-out}
+.wisp-root[data-accent="land"] .wisp-motion{animation:wisp-land .56s cubic-bezier(.2,1.15,.35,1)}
+.wisp-root[data-accent="pop-a"] .wisp-motion{animation:wisp-pop-a .38s ease-out}
+.wisp-root[data-accent="pop-b"] .wisp-motion{animation:wisp-pop-b .38s ease-out}
+@keyframes wisp-press{0%{transform:scale(1,1)}60%{transform:scale(calc(1 + .045*var(--wisp-amp,1)),calc(1 - .06*var(--wisp-amp,1)))}100%{transform:scale(1,1)}}
+@keyframes wisp-land{0%{transform:scale(calc(1 + .06*var(--wisp-amp,1)),calc(1 - .085*var(--wisp-amp,1)))}42%{transform:scale(calc(1 - .022*var(--wisp-amp,1)),calc(1 + .028*var(--wisp-amp,1)))}74%{transform:scale(calc(1 + .01*var(--wisp-amp,1)),calc(1 - .012*var(--wisp-amp,1)))}100%{transform:scale(1,1)}}
+@keyframes wisp-pop-a{0%{transform:scale(1)}46%{transform:scale(calc(1 + .035*var(--wisp-amp,1)))}100%{transform:scale(1)}}
+@keyframes wisp-pop-b{0%{transform:scale(1)}46%{transform:scale(calc(1 + .03*var(--wisp-amp,1)),calc(1 - .025*var(--wisp-amp,1)))}100%{transform:scale(1,1)}}
 /* 菜单与级联子面板共用一套外观变量 —— 面板是菜单的"上一层"，只改阴影与浮起量。
    尺寸走**紧凑刻度**：这是陪伴插件的浮层，不该占掉屏幕的观感重心。 */
 .wisp-menu{--wisp-surface:var(--dsw-alias-bg-overlay,var(--wisp-say-bg));--wisp-line:var(--dsw-alias-border-l1,var(--wisp-say-line));--wisp-hover:var(--dsw-alias-bg-layer-2,rgba(120,170,255,.2));--wisp-accent:var(--dsw-alias-brand-primary,#4a7cf7);position:absolute;min-width:164px;max-width:196px;padding:4px;border-radius:9px;font-size:11px;line-height:1.2;color:var(--dsw-alias-label-primary,var(--wisp-say-fg));background:var(--wisp-surface);border:1px solid var(--wisp-line);box-shadow:0 10px 28px rgba(0,0,0,.3);-webkit-backdrop-filter:blur(16px) saturate(160%);backdrop-filter:blur(16px) saturate(160%);pointer-events:auto;animation:wisp-menu .13s ease}
@@ -906,7 +1052,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 .wisp-credits{font-size:11px;opacity:.8;margin:6px 0 0}
 .wisp-dialog-action{display:block;width:100%;margin:4px 0 2px;padding:7px 10px;border:1px solid var(--dsw-alias-border-l1,var(--wisp-say-line));border-radius:8px;background:none;color:inherit;font:inherit;cursor:pointer}
 .wisp-dialog-action:hover{background:var(--dsw-alias-bg-layer-2,rgba(120,170,255,.2))}
-@media (prefers-reduced-motion:reduce){.wisp-body{animation:none!important}.wisp-menu,.wisp-submenu,.wisp-switch,.wisp-switch i,.wisp-slider-knob,.wisp-menu-item,.wisp-corner{animation:none!important;transition:none!important}}`
+@media (prefers-reduced-motion:reduce){.wisp-body{animation:none!important}.wisp-motion{animation:none!important}.wisp-zzz{animation:none!important;opacity:.5}.wisp-lean{transform:none!important;transition:none!important}.wisp-menu,.wisp-submenu,.wisp-switch,.wisp-switch i,.wisp-slider-knob,.wisp-menu-item,.wisp-corner{animation:none!important;transition:none!important}}`
 
     const installStyles = (styles) => {
       if (styles && typeof styles.insert === 'function') {
@@ -971,8 +1117,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       return null
     }
 
-    const buildMask = (key, url) => {
-      if (masks[key]) return
+    const buildMask = (key, url, onReady) => {
+      if (masks[key]) {
+        if (typeof onReady === 'function') onReady(key)
+        return
+      }
       try {
         const canvas = document.createElement('canvas')
         if (!canvas || typeof canvas.getContext !== 'function') return
@@ -1003,12 +1152,62 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
             // the aura, so without this a click that looks like it is on her
             // edge falls into the pass-through margin.
             masks[key] = dilate(raw)
+            if (typeof onReady === 'function') onReady(key)
           } catch (e) { /* tainted or unsupported: the full box stays hittable */ }
         }
         probe.src = url
       } catch (e) { /* no canvas: the full box stays hittable */ }
     }
 
+    /* ---------------------------------------------------------------------
+       蒙版 → clip-path。
+
+       蒙版是 96×144 的格，这里把每行连续的不透明格合并成矩形（再和上一行同列同宽的
+       矩形纵向合并），输出一条 SVG path。段数通常在几十段（实测某套皮肤 40 段），
+       一次设置、只在换皮肤或改大小时重算 —— 不是每帧的事。
+
+       为什么非要交给浏览器：`pointer-events:none` 只能让她自己不拦事件，她那个
+       560×840 的盒子仍然盖在应用上面 —— 事件**先派给她**，JS 再 return 已经晚了。
+       有了 clip-path，命中判定在浏览器里就按她的轮廓做，透明处是真的穿透。
+       --------------------------------------------------------------------- */
+    const clipPathOf = (mask, width, height) => {
+      if (!mask || !(width > 0) || !(height > 0)) return ''
+      const rects = []
+      let prev = new Map()          // 上一行里"可能继续往下长"的矩形
+      for (let y = 0; y < MASK_H; y++) {
+        const next = new Map()
+        let x = 0
+        while (x < MASK_W) {
+          if (mask[y * MASK_W + x] <= MASK_MIN_ALPHA) { x++; continue }
+          const start = x
+          while (x < MASK_W && mask[y * MASK_W + x] > MASK_MIN_ALPHA) x++
+          const key = start + ':' + (x - start)
+          const carried = prev.get(key)
+          if (carried && carried.y + carried.h === y) {
+            carried.h++
+            next.set(key, carried)
+          } else {
+            const rect = { x: start, y, w: x - start, h: 1 }
+            rects.push(rect)
+            next.set(key, rect)
+          }
+        }
+        prev = next
+      }
+      if (rects.length === 0) return ''
+      const sx = width / MASK_W
+      const sy = height / MASK_H
+      let d = ''
+      for (const rect of rects) {
+        const rx = (rect.x * sx).toFixed(1)
+        const ry = (rect.y * sy).toFixed(1)
+        const rw = (rect.w * sx).toFixed(1)
+        const rh = (rect.h * sy).toFixed(1)
+        d += 'M' + rx + ' ' + ry + 'h' + rw + 'v' + rh + 'h-' + rw + 'z'
+      }
+      return 'path("' + d + '")'
+    }
+
     /* ---------------------------------------------------------------------
        WHAT THE APP IS DOING — read from the DOM, deliberately.
 
@@ -1316,6 +1515,22 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         sayEl.style.top = Math.round(Math.max(coords.y, SAY_CLEARANCE)) + 'px'
       }
 
+      /* ---- 姿势角 --------------------------------------------------------
+         tiltScreen 是**屏幕坐标**里的角度：正数 = 顶朝右。
+         但她在左半边时整个 root 是镜像的（scaleX(-1)），镜像会把里面的旋转
+         一起翻过去 —— 所以写进样式前先乘一次 facing。少了这一步，"她朝指针
+         倾"在她跨过屏幕中线之后会变成朝反方向倾，而且只在半张屏幕上错。
+         它必须写在 paint() 里，因为 facing 只在 paint() 里算。 */
+      let tiltScreen = 0
+      let tiltWritten = null
+      let facingNow = 1
+      const applyTilt = () => {
+        const text = (Math.round(tiltScreen * facingNow * 10) / 10) + 'deg'
+        if (text === tiltWritten) return          // 同一个值不重复写：写一次就是一次样式重算
+        tiltWritten = text
+        root.style.setProperty('--wisp-tilt', text)
+      }
+
       const paint = () => {
         const facing = coords.x + boxW() / 2 < vw() / 2 ? -1 : 1
         // The translate places the box's TOP-LEFT corner, so it is `coords.x`,
@@ -1323,7 +1538,9 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         // feeding it a centre offset put the whole box half a box-width to the
         // right, off the edge of the viewport. The mirror still pivots in place
         // because `transform-origin` is the top CENTRE.
+        facingNow = facing
         root.style.transform = 'translate3d(' + coords.x + 'px,' + coords.y + 'px,0) scaleX(' + facing + ')'
+        applyTilt()
         placeSay()
       }
       paint()
@@ -1335,7 +1552,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       bodyEl.style.left = '0'
       bodyEl.style.right = '0'
       bodyEl.style.bottom = '0'
-      bodyEl.style.pointerEvents = 'auto'
+      bodyEl.style.pointerEvents = 'none'
       bodyEl.setAttribute('role', 'button')
       /* tabindex 是 0 而不是 -1：菜单已经支持键盘导航（↑↓/Home/End/Esc），但如果她本身
          不可聚焦，键盘用户就**没有办法打开它** —— 声明了 role="menu" 却没有入口，与
@@ -1345,6 +1562,38 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       bodyEl.setAttribute('aria-label', 'DeepSeek娘')
       bodyEl.setAttribute('aria-haspopup', 'menu')
 
+      /* 命中层（见 clipPathOf 上面的说明）：空盒子 + 由蒙版生成的 clip-path。
+         关键样式同样行内再写一遍 —— 样式表缺失时它必须仍然是"铺满、吃指针"的那个。 */
+      const hitEl = document.createElement('div')
+      hitEl.className = 'wisp-hit'
+      hitEl.setAttribute('aria-hidden', 'true')
+      hitEl.style.position = 'absolute'
+      hitEl.style.top = '0'
+      hitEl.style.left = '0'
+      hitEl.style.right = '0'
+      hitEl.style.bottom = '0'
+      hitEl.style.pointerEvents = 'auto'
+      hitEl.style.cursor = 'grab'
+
+      /* 动作层（见文件上方 motion 常量处的说明）：两个空盒子，把"姿势"与
+         "一次性动作"从情绪动画里分出来。关键样式同样**行内再写一遍** ——
+         理由和 layer/root 一样：样式表缺失时它们是 position:static 的普通
+         div，会把精灵图挤成两个叠着的方块。 */
+      const motionEl = document.createElement('div')
+      motionEl.className = 'wisp-motion'
+      const leanEl = document.createElement('div')
+      leanEl.className = 'wisp-lean'
+      for (const box of [motionEl, leanEl]) {
+        box.style.position = 'absolute'
+        box.style.top = '0'
+        box.style.left = '0'
+        box.style.right = '0'
+        box.style.bottom = '0'
+        box.style.pointerEvents = 'none'
+        /* 旋转/压扁的原点在脚底：否则侧倾像转盘，压扁像从头顶往下缩。 */
+        box.style.transformOrigin = '50% 100%'
+      }
+
       const shine = document.createElement('div')
       shine.className = 'wisp-shine'
 
@@ -1375,9 +1624,23 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         return skin.idle
       }
 
+      /* 把当前精灵图的蒙版变成命中层的形状。蒙版是异步来的（图片解码完才有），
+         所以它由 buildMask 的回调触发；换皮肤、改大小的时候各再调一次。 */
+      let hitClip = null
+      const applyHitClip = (key) => {
+        if (key !== currentSprite) return            // 过期的回调：那张图已经不是现在这张
+        const mask = masks[activeSkin + '/' + key]
+        const path = mask ? clipPathOf(mask, boxW(), boxH()) : ''
+        if (path === hitClip) return                 // 同一个形状不重复写
+        hitClip = path
+        hitEl.style.clipPath = path
+        hitEl.style.webkitClipPath = path
+      }
+
       const setSprite = (key) => {
+        currentSprite = key
         const url = resolveSprite(spriteOf(key))
-        buildMask(activeSkin + '/' + key, url)
+        buildMask(activeSkin + '/' + key, url, () => applyHitClip(key))
         currentSprite = key
         /* Cross-fade rather than swapping `src` outright: a hard swap makes every
            mood change read as a glitch. The outgoing sprite keeps its own layer
@@ -1401,7 +1664,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         outgoing.draggable = false
         outgoing.setAttribute('aria-hidden', 'true')
         outgoing.src = previous
-        bodyEl.insertBefore(outgoing, img)
+        leanEl.insertBefore(outgoing, img)
         img.src = url
         img.style.opacity = '0'
         clock.after(16, () => {
@@ -1412,8 +1675,17 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         clock.after(340, () => { if (outgoing.parentNode) outgoing.parentNode.removeChild(outgoing) })
       }
 
-      bodyEl.appendChild(shine)
-      bodyEl.appendChild(img)
+      /* 结构：body（情绪动画）> motion（一次性动作）> lean（姿势）> shine/img，
+      外加一个兄弟节点 hit（命中层）。 */
+      /* 光晕（脚底那圈光）挂在 motion 层、**不在 lean 层**：它是地面上的东西，
+         不该跟着她的侧身一起歪 —— 挂在 lean 里的时候，她一倾斜光圈也跟着转，
+         看起来像地板歪了。但按下/落地那一下的压扁它该跟着（那是"她压在地上"），
+         所以留在 motion 层而不是提到 body 层。 */
+      motionEl.appendChild(shine)
+      leanEl.appendChild(img)
+      motionEl.appendChild(leanEl)
+      bodyEl.appendChild(motionEl)
+      bodyEl.appendChild(hitEl)
       root.appendChild(bodyEl)
       layer.appendChild(root)
       setSprite('idle')
@@ -1470,10 +1742,86 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         return true
       }
 
+      /* ---- 动作层的三个入口 -------------------------------------------------
+         amp()    ：幅度档位（full 1 / subtle .5 / off 0），CSS 那边读的是同一个
+                    区间 —— 关键帧里用 calc 乘 --wisp-amp，指针侧倾在这里乘。
+         reduced()：prefers-reduced-motion。CSS 已经把动画关掉了，但**姿势是 JS
+                    写进去的**，样式表关不掉它，所以这里必须再问一次系统。
+                    matchMedia 不存在的壳里返回 false：拿不到就不假装系统说了什么。
+         accent() ：放一次"一次性动作"。它只写一个属性，什么时候收手由这里的
+                    时钟决定（CSS 只管怎么动）—— 所以不会出现"动画早放完了、
+                    属性还挂着"那种半截状态。 */
+      let reducedMql = null
+      const reduced = () => {
+        try {
+          if (reducedMql === null && typeof window.matchMedia === 'function') {
+            reducedMql = window.matchMedia('(prefers-reduced-motion: reduce)')
+          }
+          return !!(reducedMql && reducedMql.matches)
+        } catch (e) { return false }
+      }
+      const amp = () => {
+        const value = MOTION_AMP[cfg.motion]
+        return typeof value === 'number' ? value : 1
+      }
+
+      let accentHandle = null
+      let accentFlip = false
+      const accent = (name) => {
+        if (destroyed) return
+        /* 静止档与"系统要求别动"都不放动作。CSS 那边也关着（媒体查询 +
+           --wisp-amp:0），但**属性本身也不该被写上** —— 否则 doctor() 会报一个
+           根本没发生的动作，读代码的人也会以为这条路是活的。 */
+        if (amp() === 0 || reduced()) return
+        /* pop-a / pop-b 是同一件事的两个名字。**同一个值再写一次不会重播动画**，
+           而连戳两下必须看到两次弹 —— 换名字是这里最可靠的强制重播办法
+           （靠读一次 offsetWidth 强制重排也能做到，但那要在替身里也装一个
+           布局引擎，而替身没有布局）。 */
+        const value = name === 'pop'
+          ? ((accentFlip = !accentFlip) ? 'pop-b' : 'pop-a')
+          : name
+        root.dataset.accent = value
+        if (accentHandle) clock.cancel(accentHandle)
+        accentHandle = clock.after(ACCENT_MS[name] || 400, () => {
+          accentHandle = null
+          if (!destroyed) delete root.dataset.accent
+        })
+      }
+
+      /* 姿势：° 是**屏幕坐标**里的角度（正 = 顶朝右），乘镜像由 applyTilt 做。
+         这里是所有姿势的唯一闸门 —— 静止档与"系统要求别动"都在这一个地方归零，
+         调用点不必各自记得判断。 */
+      const setTilt = (deg) => {
+        const next = (amp() === 0 || reduced()) ? 0 : clamp(deg, -TILT_DRAG_MAX, TILT_DRAG_MAX)
+        if (Math.abs(next - tiltScreen) < TILT_STEP) return
+        tiltScreen = next
+        applyTilt()
+      }
+
+      /* 档位改动要**当场**生效，不用刷新：属性一改，CSS 那边的全部幅度规则
+         （关键帧里的 --wisp-amp、静止档关掉呼吸与 z）立刻跟上。
+         另外把姿势归零 —— 从"灵动"切到"静止"时她还歪着，就成了半截状态。 */
+      const applyMotion = () => {
+        root.dataset.motion = cfg.motion
+        if (amp() === 0 || reduced()) setTilt(0)
+      }
+      applyMotion()
+
       const setMood = (next) => {
-        if (destroyed || mood === next) return
+        if (destroyed) return
+        if (mood === next) return
         mood = next
         root.dataset.mood = next
+        /* 换表情 = 弹一下（只给有表情的那几个状态配，理由见 POPPY_MOODS）。
+           它必须在"真的换了表情"**之后**：`attn` 也在 POPPY_MOODS 里，而
+           poll 只要看到待处理面板就每一轮重算 setMood('attn') —— 放在去重之前，
+           她会在你盯着审批卡片等的时候每 1.2 秒抽一下（真机上 6 秒 5 次）。
+           "连戳两下第二下也要弹"是**手势**的要求，由 flashHappy/flashPoked
+           自己补（见那两处），不该让稳态重算也走这条路。 */
+        if (POPPY_MOODS.indexOf(next) >= 0) accent('pop')
+        /* 睡着时不该还朝着你的指针倾 —— 那和一个"睡着了还跟着你转头"的人一样怪。
+           在**进入** sleep 时归零，而不是在指针处理器里每帧都判一次。 */
+        if (next === 'sleep') setTilt(0)
         const want = SPRITE_OF[next] || 'idle'
         if (want !== currentSprite) setSprite(want)
         const zs = root.querySelectorAll('.wisp-zzz')
@@ -1501,6 +1849,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         const el = document.createElement('div')
         el.className = 'wisp-say'
         el.style.position = 'absolute'
+        /* 气泡的淡出时长跟着**它的寿命**走，而不是跟着样式表里那个数：
+           两边各写一份就会漂（样式表里写 4.2s、代码里活 4.4s —— 气泡会提前
+           200ms 淡完再干等）。和 ACCENT_MS 一个道理：CSS 管怎么动，代码管多久。 */
+        el.style.animationDuration = (SAY_MS / 1000) + 's'
         el.textContent = text
         // Into the LAYER, not the root: a child of the root would be mirrored
         // with her and scaled by `size`.
@@ -1734,6 +2086,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       }
 
       const flashHappy = (text) => {
+        /* 手势驱动的反应：**已经是这个表情时也要弹**。setMood 的弹一下挂在
+           "真的换了表情"后面（否则轮询重算的 attn 会变成 1.2 秒一次的抽搐），
+           所以"连戳两下"这条要求由这里补上 —— 它只由用户的手势触发。 */
+        if (mood === 'happy') accent('pop')
         setMood('happy')
         say(text)
         if (happyHandle) clock.cancel(happyHandle)
@@ -1745,6 +2101,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       const POKED_MS = 1800
       let pokedHandle = null
       const flashPoked = (text) => {
+        if (mood === 'poked') accent('pop')     // 同上：连戳到底也要每次都弹
         setMood('poked')
         say(text)
         if (pokedHandle) clock.cancel(pokedHandle)
@@ -2017,23 +2374,32 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          `data-gliding`，由 CSS 过渡接管 transform；一旦按下就立刻摘掉，
          否则拖动会被过渡拖后腿。 */
       let glideHandle = null
-      const glideTo = () => {
+      const glideTo = (dx) => {
         root.dataset.gliding = 'true'
         paint()
+        /* 朝行进方向微微前倾。整段 1.6 秒的滑行里，这一点倾斜就是"她往那边去"
+           与"她被平移到那边"的区别 —— 归零那一半由 .wisp-lean 的过渡做。 */
+        setTilt(clamp((Number(dx) || 0) * TILT_GLIDE_PER_PX, -TILT_GLIDE_MAX, TILT_GLIDE_MAX) * amp())
         if (glideHandle) clock.cancel(glideHandle)
         glideHandle = clock.after(1700, () => {
           glideHandle = null
           delete root.dataset.gliding
+          setTilt(0)
         })
       }
       const stopGlide = () => {
         if (glideHandle) { clock.cancel(glideHandle); glideHandle = null }
         delete root.dataset.gliding
+        setTilt(0)
       }
 
       let wanderHandle = null
       const syncWander = () => {
         if (wanderHandle) { clock.cancel(wanderHandle); wanderHandle = null }
+        /* 溜达也是"动作"：`motion: off` 和 prefers-reduced-motion 都该让她待在原地。
+           之前只关了 CSS 动画，她照样会自己滑走 —— 那是最容易被忽略的一种"没停下来"，
+           因为看起来只是一次正常的挪动。（CSS 关不掉 JS 写进去的坐标。） */
+        if (cfg.motion === 'off' || reduced()) return
         if (!cfg.wander || cfg.wanderRange <= 0 || paused) return
         wanderHandle = clock.every(cfg.wanderMs, () => {
           if (destroyed || hidden || mood !== 'idle' || start !== null) return
@@ -2042,9 +2408,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           // a real stroll rather than a rounding error in a random direction.
           const angle = Math.random() * Math.PI * 2
           const dist = cfg.wanderRange * (0.45 + Math.random() * 0.55)
+          const fromX = coords.x
           coords.x = clamp(coords.x + Math.cos(angle) * dist, 0, maxX())
           coords.y = clamp(coords.y + Math.sin(angle) * dist * 0.6, 0, maxY())
-          glideTo()
+          glideTo(coords.x - fromX)
           // 故意不 rememberPosition()：记忆的是"用户把她放在哪"，她自己的溜达
           // 不该覆盖那个意图，否则刷新后她会出现在一个用户从没选过的位置。
         })
@@ -2100,13 +2467,15 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (destroyed) return
         hidden = next === true
         root.dataset.hidden = hidden ? 'true' : 'false'
-        if (hidden) { closeMenu(); hideTab(); clearSay(); showTab() }
+        if (hidden) { closeMenu(); hideTab(); clearSay(); showTab(); setTilt(0) }
         else { hideTab(); paint() }
         if (cfg.persist) writeStored(HIDDEN_KEY, { hidden })
       }
 
       /* ---- drag & click ---- */
       let start = null, origin = null, moved = false, lastClick = 0
+      /* 上一次指针的横坐标：拖动中的侧倾是"这一段的位移"，不是"从按下算起的总位移" */
+      let lastDragX = 0
       /* 连戳计数：POKE_WINDOW_MS 内累计到 POKE_ANNOYED_AT 次就抗议一次 */
       const POKE_WINDOW_MS = 3000
       const POKE_ANNOYED_AT = 3
@@ -2139,14 +2508,34 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         const dx = e.clientX - start.x, dy = e.clientY - start.y
         if (!moved && Math.sqrt(dx * dx + dy * dy) > 4) moved = true
         if (!moved) return
+        const beforeX = coords.x, beforeY = coords.y
         coords.x = clamp(origin.x + dx, 0, maxX())
         coords.y = clamp(origin.y + dy, 0, maxY())
+        /* 被边界夹住时她其实**没有动** —— 这时候再按指针位移去倾，就是"原地歪"，
+           看起来像坏了。位置没变就把姿势归零（指针继续拖也不影响，因为下一帧
+           只要真的动了就会重新算）。 */
+        if (coords.x === beforeX && coords.y === beforeY) {
+          lastDragX = e.clientX
+          setTilt(0)
+          return
+        }
+        /* 拖动时她朝**运动的反方向**倾：被拎着走的东西，顶是往后倒的。
+           只看"这一次事件走了多远"就等价于速度，不用存历史、不用积分 ——
+           而且它天然跟着指针事件的频率走，慢拖就是小角度。 */
+        setTilt(-(e.clientX - lastDragX) * TILT_DRAG_PER_PX * amp())
+        lastDragX = e.clientX
         paint()
       }
       const onUp = () => {
         window.removeEventListener('pointermove', onMove)
         window.removeEventListener('pointerup', onUp)
         delete root.dataset.dragging
+        /* 松手分两种：真拖过 = 落地（顿一下）；只按了一下 = 什么都不放 ——
+           紧接着的点击反应会自己弹一下（见 ACCENT_MS 的说明：通道只留
+           最后发生的那件事）。姿势则一律由 CSS 过渡归零（拖动中它被
+           data-dragging 关掉了，现在恢复了）。 */
+        if (moved) accent('land')
+        setTilt(0)
         start = null
         if (moved) {
           rememberPosition()
@@ -2186,15 +2575,61 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (!hitsBody(e)) return
         stopGlide()          // a stroll must not fight the drag
         e.preventDefault(); e.stopPropagation()
+        /* 点她 = 把键盘焦点给她。以前这是浏览器的默认行为（她自己就是那个被点的
+           tabindex=0 元素）；命中层接管点击之后默认焦点会落到 <body>，于是
+           "点一下她、再按 Enter 开菜单"就断了 —— 显式补回来。 */
+        focusHer()
         start = { x: e.clientX, y: e.clientY }
         origin = { x: coords.x, y: coords.y }
         moved = false
+        lastDragX = e.clientX
         root.dataset.dragging = 'true'
+        /* 按下去就压一下 —— 触摸反馈要在**按下**那一刻发生，等到松手才动
+           就已经晚了（那正是"拖动"与"点击"共同的起点）。 */
+        accent('press')
         window.addEventListener('pointermove', onMove)
         window.addEventListener('pointerup', onUp)
       }
       bodyEl.addEventListener('pointerdown', onDown)
 
+      /* ---- 姿势：她注意到你的指针 -------------------------------------------
+         指针进到 170px 的圈里，她朝指针方向侧身；贴得越近倾得越多，出圈归零。
+
+         这是全插件唯一一处"持续读指针"的逻辑，所以它必须便宜：
+           · 纯算术，不查 DOM、不读布局（读一次 getBoundingClientRect 就是一次强制重排）
+           · 出圈就走 setTilt(0)，而 setTilt 自己挡掉"变化不到 0.05°"的写入
+           · 拖动中直接返回 —— 那时候姿势由速度接管
+         window 上本来就挂着 pointermove（wake：她得能被碰醒），所以这里不是
+         新开一条全局热路径，只是同一条路上的第二个判断。 */
+      const leanToPointer = (e) => {
+        if (destroyed || paused || hidden || start !== null) return
+        if (mood === 'sleep') return
+        if (cfg.motion === 'off' || reduced()) return
+        /* 触摸屏上"指针"就是手指：手指划过时让她整只歪过去是错的 ——
+           那既不是"靠近"也不是"路过"，而且手指一抬起姿势就冻在那儿。
+           所以触摸一律归零（真正该有的反馈是"按下压一下"，那是另一条通道）。 */
+        if (e.pointerType === 'touch') { setTilt(0); return }
+        if (typeof e.clientX !== 'number' || typeof e.clientY !== 'number') return
+        const dx = e.clientX - (coords.x + boxW() / 2)
+        const dy = e.clientY - (coords.y + boxH() / 2)
+        if (Math.abs(dx) > TILT_NEAR_PX || Math.abs(dy) > TILT_NEAR_PX) { setTilt(0); return }
+        const near = 1 - Math.abs(dx) / TILT_NEAR_PX
+        const level = 1 - Math.abs(dy) / TILT_NEAR_PX   // 从她正上方路过不该让她倾
+        setTilt((dx < 0 ? -1 : 1) * TILT_NEAR_MAX * near * level * amp())
+      }
+      window.addEventListener('pointermove', leanToPointer, { passive: true })
+      /* 指针移出窗口、或者你切走应用之后，不会再有点事件来把它归零 ——
+         没有这一下，她会一直朝着最后那个位置歪着。
+         `blur` 只覆盖"切走应用"，**指针移出窗口不会触发它** —— 补一个文档级
+         mouseleave（指针离开文档时才发），两条一起才真的覆盖到。 */
+      const resetTilt = () => setTilt(0)
+      window.addEventListener('blur', resetTilt)
+      try {
+        if (typeof document !== 'undefined' && document.addEventListener) {
+          document.addEventListener('mouseleave', resetTilt)
+        }
+      } catch (e) { /* 没有 document：她最多保留最后一次侧身，不影响其它功能 */ }
+
       /* 键盘入口：Enter / Space / 菜单键 / Shift+F10 打开菜单。
          Space 默认会滚动页面，Enter 在表单里会提交 —— 都要拦。 */
       /* 方向键微调位置。
@@ -2233,7 +2668,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          只认**带修饰键**的滚轮：她占地不小，直接吞掉普通滚轮等于在她身上把页面滚动禁掉。
          带修饰键是「缩放」的通行手势，此时 preventDefault 才是帮忙而不是捣乱。
          步长 0.25，上下限由 CONFIG_SPEC 统一夹紧（0.4–8），不在这里再写一遍。 */
-      const WHEEL_STEP = 0.25
+      /* 步长必须是"默认值可达"的：size 的区间是 0.4–8，默认 2.5。
+         原来键盘/滚轮步长 0.25，可达值只有 0.4 + 0.25k —— **2.5 不在格点上**
+         （最近的是 2.4 / 2.65），于是用户只要动过一次滑块，就再也调不回出厂大小。
+         0.1 让 2.5 正好落在格点上（0.4 + 21×0.1）。预检里有一条守着这个不变式。 */
+      const WHEEL_STEP = 0.1
       const onWheel = (ev) => {
         if (!ev.ctrlKey && !ev.metaKey) return          // 普通滚轮原样放行
         if (typeof ev.preventDefault === 'function') ev.preventDefault()
@@ -2544,12 +2983,17 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          子面板里的开关点完必须留在原地 —— 拨个开关面板就消失是最烦人的交互之一。 */
       const refreshSurfaces = () => {
         const keep = flyoutName
+        /* 重画之前先记住"这个面板是点开的还是悬停开的"：openMenu 里的 closeFlyout()
+           会把标记清掉，不记下来，拨一次开关后面板就从"钉住"降级成"悬停开启" ——
+           而重画出来的 DOM 里鼠标并没有真的悬停过，宽限期一到面板就自己关了。
+           用户看到的现象就是：拨个开关，面板消失（而这正是这段注释上面说不能有的）。 */
+        const keepPinned = flyoutPinned
         const keepIndex = flyoutRow && flyoutRow.dataset ? Number(flyoutRow.dataset.rowIndex) : -1
         openMenu(menuAtX, menuAtY, false)          // 重画菜单（会先关掉面板）
         if (!keep || !menuEl) return
         const row = menuEl.querySelectorAll('.wisp-menu-item')
           .find((el) => el.dataset && el.dataset.group === keep)
-        if (row) openFlyout(keep, row, Number.isFinite(keepIndex) && keepIndex >= 0 ? keepIndex : Number(row.dataset.rowIndex))
+        if (row) openFlyout(keep, row, Number.isFinite(keepIndex) && keepIndex >= 0 ? keepIndex : Number(row.dataset.rowIndex), keepPinned)
       }
 
       const openFlyout = (name, rowEl, index, pinned) => {
@@ -2829,7 +3273,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         ])
       }
 
-      const aboutDialog = () => {
+      const aboutDialog = (diagRes) => {
         const note = WHATS_NEW[VERSION]
         /* 菜单里那条「版本与更新」已经收掉了（版本号现在直接显示在菜单头部），
            所以检查更新必须有新的入口 —— 放在这里，上下文正合适。 */
@@ -2849,9 +3293,12 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           para('她还能陪你专注计时：菜单里开一段 25 或 45 分钟，期间她保持"干活中"，戳她一下是问还剩多久，到点她替你收工。'),
           para('这一版：' + (note || VERSION)),
           para('形象与设定参考社区项目 Neko3000/deepseek-whalechan（设定文档 CC BY-NC-SA 4.0，原作者 B站 ZipZipPipe、上善无形）。'),
+          /* 上一次检查更新失败时，把宿主看到的东西摆在最显眼的位置 —— 台词只有一句，
+             而"为什么拿不到"必须能被看到、被复制、被追问。 */
+          diagRes ? para('上次查更新为什么没成：\n' + describeDiag(diagRes)) : null,
           checkBtn,
           dialogFoot('非官方同人作品，与 DeepSeek 官方无关', 'v' + VERSION),
-        ])
+        ].filter(Boolean))
       }
 
       /* 菜单的结构 ------------------------------------------------------------
@@ -2901,6 +3348,8 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
             { label: '说句话', glyph: '✦', run: () => { wake(true); say(pick(LINES.click)) } },
             { label: '睡一会儿', glyph: '☾', run: () => setMood('sleep') },
             { label: '今天做了什么', glyph: '✎', run: () => saySummary() },
+            /* 余额：按需查，查完她自己说 —— 不做轮询（稳态零开销那条承诺不破）。 */
+            { label: '看看余额', glyph: '¥', run: () => { checkBalance() } },
             /* 语言：三选一。切换**立刻生效**（LINES 是视图，不是死值）。 */
             {
               kind: 'choice', key: 'lang', label: '台词语言', glyph: '文',
@@ -2910,6 +3359,17 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
                 { value: 'en', label: 'English' },
               ],
             },
+            /* 动作幅度：三选一。同样立刻生效 —— 它只改一个属性，CSS 全挂在上面。
+               给这一档的理由：prefers-reduced-motion 是**系统级**的"所有动画都别放"，
+               而"我不想让这只桌宠动来动去"是另一件事，不该逼人去改系统设置。 */
+            {
+              kind: 'choice', key: 'motion', label: '动作幅度', glyph: '≈',
+              options: [
+                { value: 'full', label: '灵动' },
+                { value: 'subtle', label: '克制' },
+                { value: 'off', label: '静止' },
+              ],
+            },
             /* 没有音效文件就不摆这个开关 —— 点了没反应的开关比没有开关更糟 */
             ...(HAS_SOUNDS ? [{ kind: 'switch', key: 'sound', label: '音效', glyph: '♪' }] : []),
             /* 开关是**真正的开关行**：带 aria-checked，点完菜单不关（就在原地更新） */
@@ -3131,7 +3591,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           if (focused && focused.dataset && focused.dataset.slider === '1'
             && (ev.key === 'ArrowLeft' || ev.key === 'ArrowRight')) {
             if (typeof ev.preventDefault === 'function') ev.preventDefault()
-            const step = ev.shiftKey ? 1 : 0.25
+            const step = ev.shiftKey ? 1 : 0.1
             applyConfig({ size: cfg.size + (ev.key === 'ArrowRight' ? step : -step) })
             /* 只更新滑块自身，不重画整张菜单 —— 焦点和展开状态都不动 */
             try {
@@ -3322,6 +3782,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         root.style.width = Math.round(boxW()) + 'px'
         root.style.height = Math.round(boxH()) + 'px'
         layer.style.setProperty('--wisp-scale', String(cfg.size))
+        /* 尺寸变了，命中层的形状也要跟着缩放（clip-path 里的坐标是 px，不是百分比）。 */
+        applyHitClip(currentSprite)
+        /* 动作档位也要当场生效（菜单里的胶囊就靠这一行）：它只改一个属性，
+           CSS 那边所有幅度规则都挂在它上面。 */
+        if (partial && typeof partial === 'object' && partial.motion !== undefined) applyMotion()
         coords.x = clamp(coords.x, 0, maxX())
         coords.y = clamp(coords.y, 0, maxY())
         paint()
@@ -3343,6 +3808,9 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
          host 是 shell 注入的名字，不是全局：拿不到就如实说"查不了"，不许抛。 */
       let updateCheck = { state: 'idle', at: 0 }
+      /* 上一次真正复制给用户的提示语（doctor 里能看到）—— "她让你装的是哪个" 必须可查，
+         否则"按包名安装"和"用 GitHub 地址装"这两条路到底走了哪条就没人说得清。 */
+      let lastUpdateHint = UPDATE_HINT
 
       const compareVersions = (a, b) => {
         const parse = (v) => String(v).split('-')[0].split('.').map((n) => {
@@ -3368,18 +3836,75 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         return null
       }
 
+      /* 客户端**自己的**通道 —— 这才是这个插件真正的联网方式。
+         
+         事实（从平台的 dsh-client-modules 加载器读出来的）：bundle 插件的客户端半包
+         是用 <script> 加载的**普通页面脚本**，平台不注入陷阱、不替换全局 —— 所以
+         `window.fetch` 对它可用。而 `host.call` 那个 RPC 座位只发给**动态插件**
+         （runner 里 `hasHostHalf: definition.hostCode !== undefined`），我们这个形态
+         从来没有过它。
+         
+         以前代码里写着"浏览器半包的 fetch 是陷阱"，那是把**预检替身**的契约当成了
+         平台契约 —— 整个更新检查因此在错误的路上走了很久（真机上永远"没接上宿主"）。 */
+      const NPM_LATEST_URL = 'https://registry.npmjs.org/dsh-wisp/latest'
+      const GITHUB_RAW_URL = 'https://raw.githubusercontent.com/969246694/dsh-wisp/main/package.json'
+      const clientVersionAt = (url) => {
+        try {
+          const fetcher = window.fetch
+          if (typeof fetcher !== 'function') return Promise.resolve(null)
+          return fetcher.call(window, url, { cache: 'no-store' })
+            .then((res) => (res && res.ok === true ? res.json() : null))
+            .then((data) => (data && typeof data.version === 'string' ? data.version : null))
+            .catch(() => null)
+        } catch (e) { return Promise.resolve(null) }
+      }
+
+      /* 客户端侧的完整检查：两个源各取一次，取更高的那个（与宿主侧同一套规则）。 */
+      const clientSideCheck = () => {
+        updateCheck = { state: 'checking', at: nowMs() }
+        return Promise.all([clientVersionAt(NPM_LATEST_URL), clientVersionAt(GITHUB_RAW_URL)])
+          .then(([npmVersion, githubVersion]) => {
+            const sources = {
+              npm: npmVersion ? { ok: true, version: npmVersion } : { ok: false, reason: 'fetch-failed' },
+              github: githubVersion ? { ok: true, version: githubVersion } : { ok: false, reason: 'fetch-failed' },
+            }
+            const cands = [['npm', npmVersion], ['github', githubVersion]].filter((p) => typeof p[1] === 'string')
+            if (cands.length === 0) {
+              updateCheck = { state: 'failed', reason: 'fetch-failed', sources, diag: null, at: nowMs() }
+              publishDiagToTitle(updateCheck)
+              return updateCheck
+            }
+            let best = cands[0]
+            for (const c of cands) if (compareVersions(best[1], c[1]) < 0) best = c
+            updateCheck = compareVersions(VERSION, best[1]) < 0
+              ? { state: 'available', latest: best[1], from: best[0], sources, at: nowMs() }
+              : { state: 'current', latest: best[1], from: best[0], sources, at: nowMs() }
+            return updateCheck
+          })
+      }
+
       const checkForUpdate = () => {
         const seat = hostSeat()
-        if (seat === null) {
-          updateCheck = { state: 'unsupported', at: nowMs() }
-          return Promise.resolve(updateCheck)
-        }
+        /* 没有 host 座位不是失败 —— 那是**这个形态的插件的常态**（bundle 插件没有 host RPC）。
+           客户端自己抓：这才是它本来该走的路。 */
+        if (seat === null) return clientSideCheck()
         updateCheck = { state: 'checking', at: nowMs() }
         return Promise.resolve()
           .then(() => seat.call('checkUpdate', { current: VERSION }))
           .then((res) => {
             if (!res || res.ok !== true || typeof res.latest !== 'string') {
-              updateCheck = { state: 'failed', reason: (res && res.reason) || 'no-result', at: nowMs() }
+              /* 失败时也要把**每个源各自的原因**留下来。用户看到的是"没查成"，
+                 而 doctor() 必须能说清是"这个壳里没有网络服务"还是"两个源都没连上" ——
+                 以前这里把 sources 丢了，失败就变成一句无法追问的话。 */
+              updateCheck = {
+                state: 'failed',
+                reason: (res && res.reason) || 'no-result',
+                sources: (res && res.sources) || null,
+                /* 宿主看到的诊断也要留下来 —— 失败台词会把它念出来，doctor 里也能查。 */
+                diag: (res && res.diag) || null,
+                at: nowMs(),
+              }
+              publishDiagToTitle(updateCheck)
             } else if (compareVersions(VERSION, res.latest) < 0) {
               /* from / sources 一起留着：两个源不一致时（npm 暂存、GitHub 已更新），
                  "这个数字是哪儿来的"比数字本身更需要能查。 */
@@ -3400,12 +3925,154 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           })
       }
 
+      /* ---- 看余额 -------------------------------------------------------------
+         和"检查更新"走同一条路，但服务不同：宿主半包 inject 'deepseekAccount'，
+         用平台自己的账户服务取余额。**插件从头到尾不碰 API key** —— 凭据在平台
+         手里，浏览器半包连读都读不到（它没有网络，fetch 是陷阱）。
+
+         未登录、读不到、这个壳里没有那个服务，是三句不同的话：
+         说是"查不到"但其实是"没登录"，就是在骗人。 */
+      let balanceCheck = { state: 'idle', at: 0 }
+
+      /* 金额由客户端拼，台词只管口气。货币符号认不出来就原样写代码。 */
+      const balanceAmount = (wallets) => {
+        const bits = []
+        for (const w of (Array.isArray(wallets) ? wallets : [])) {
+          if (!w || typeof w.balance !== 'string') continue
+          const sign = w.currency === 'CNY' ? '¥' : (w.currency === 'USD' ? '$' : '')
+          bits.push(sign === '' ? (w.balance + (w.currency ? ' ' + w.currency : '')) : sign + w.balance)
+        }
+        return bits.join(' + ')
+      }
+
+      const balanceLine = (res) => {
+        if (res.state === 'ready') {
+          const main = balanceAmount(res.wallets)
+          if (main === '') return pick(LINES.balanceEmpty)
+          const text = pick(LINES.balance).split('{n}').join(main)
+          const bonus = balanceAmount(res.bonusWallets)
+          return bonus === '' ? text : text + pick(LINES.balanceBonus).split('{n}').join(bonus)
+        }
+        if (res.state === 'signed-out') return pick(LINES.balanceSignedOut)
+        if (res.state === 'unavailable') return pick(LINES.balanceUnavailable)
+        if (res.state === 'unsupported') return pick(LINES.balanceUnsupported)
+        return pick(LINES.balanceFailed)
+      }
+
+      /* 按需查：菜单里那一行和 `__wisp.checkBalance()` 都走这里。
+         它**自己说话**（先"看一下……"再报结果）—— 菜单点完就关了，留一个
+         只返回状态、不出声的函数，用户会以为没反应。 */
+      const checkBalance = () => {
+        const seat = hostSeat()
+        if (seat === null) {
+          balanceCheck = { state: 'unsupported', at: nowMs() }
+          wake(true)
+          say(balanceLine(balanceCheck))
+          return Promise.resolve(balanceCheck)
+        }
+        balanceCheck = { state: 'checking', at: nowMs() }
+        wake(true)
+        say(pick(LINES.balanceChecking))
+        return Promise.resolve()
+          .then(() => seat.call('checkBalance', { locale: LANG_TAG }))
+          .then((res) => {
+            if (!res || res.ok !== true) {
+              balanceCheck = { state: 'failed', reason: (res && res.reason) || 'no-result', at: nowMs() }
+            } else if (res.status === 'ready') {
+              balanceCheck = {
+                state: 'ready',
+                wallets: Array.isArray(res.wallets) ? res.wallets : [],
+                bonusWallets: Array.isArray(res.bonusWallets) ? res.bonusWallets : [],
+                at: nowMs(),
+              }
+            } else if (res.status === 'signed-out' || res.status === 'unavailable') {
+              balanceCheck = { state: res.status, at: nowMs() }
+            } else {
+              /* 平台答了，答案是 failed —— 是结果，不是异常。 */
+              balanceCheck = { state: 'failed', reason: 'service-failed', at: nowMs() }
+            }
+            say(balanceLine(balanceCheck))
+            return balanceCheck
+          })
+          .catch((err) => {
+            balanceCheck = {
+              state: 'failed',
+              reason: 'call-failed',
+              detail: String(err && err.message ? err.message : err),
+              at: nowMs(),
+            }
+            say(balanceLine(balanceCheck))
+            return balanceCheck
+          })
+      }
+
+      /* 版本号来自 GitHub，而 npm 上那份**不是同一个号**（通常是 npm 暂存或还没发）——
+         这时候"按包名安装"会把人送回旧版。 */
+      const githubOnlyNewer = (res) => {
+        if (!res || res.state !== 'available' || res.from !== 'github') return false
+        const npm = res.sources && res.sources.npm
+        return !!(npm && npm.ok === true && npm.version !== res.latest)
+      }
+
       const updateLine = (res) => {
         if (res.state === 'available') return pick(LINES.updateAvailable) + res.latest
         if (res.state === 'current') return pick(LINES.updateCurrent)
+        /* 失败要说清是哪一种：没有通道 / 连不上 / 宿主没应答。
+           `no-web-service` 是"这个壳根本没有联网入口"，不是"网络不好"——
+           以前两者共用一句"没查到更新"，于是诊断只能靠猜。 */
+        /* 失败要说清是哪一种 —— 它们是链路上**不同的一环**断了：
+           `unsupported`：客户端这侧连 `host.call` 都没有（第一环）；
+           `no-web-service`：宿主跑了，但它拿不到 `web` 服务（第三环）；
+           `fetch-failed`：服务拿到了，两个源都连不上（第四环）。 */
+        if (res.state === 'unsupported') return pick(LINES.updateNoSeat)
+        if (res.reason === 'no-web-service') return pick(LINES.updateNoChannel)
+        if (res.reason === 'call-failed') return pick(LINES.updateNoHost)
         return pick(LINES.updateFailed)
       }
 
+      /* 技术的部分**不进台词**（台词是给人读的一句话，塞进去就是一串英文碎片），
+         但必须看得见 —— 失败时把宿主实际看到的排进「关于她」弹窗：
+         取服务的方式、拿到的东西是什么形状、兜底通道为什么也不行。
+         这是"她说查不了"和"我知道为什么"之间的那一步。 */
+      /* 诊断的**临时出口**：把"宿主看见了什么"写进窗口标题。
+         Agent 侧读一下窗口标题就能拿到（不用截图、不用控制台、不用用户复制）——
+         这台机器上的断点已经卡了两轮，值得开一个临时通道把它钉死。
+         120 秒后自动还原；定位到问题后这一条会撤掉。 */
+      let diagTitleTimer = null
+      const publishDiagToTitle = (res) => {
+        try {
+          if (typeof document === 'undefined' || !document || typeof document.title !== 'string') return
+          const diag = (res && res.diag) || {}
+          const short = [
+            'wisp-diag',
+            String((res && res.state) || '?'),
+            String((res && res.reason) || '-'),
+            'via=' + String(diag.via || '-'),
+            'how=' + String(diag.how || '-'),
+            'why=' + String(diag.why || '-'),
+            'mgr=' + String(diag.manager || '-'),
+          ].join(' ')
+          const original = document.title
+          document.title = short
+          if (diagTitleTimer !== null) clock.cancel(diagTitleTimer)
+          diagTitleTimer = clock.timeout(() => {
+            try { document.title = original } catch (e) { /* ignore */ }
+            diagTitleTimer = null
+          }, 120000)
+        } catch (e) { /* 标题写不了不该影响任何别的功能 */ }
+      }
+
+      const describeDiag = (res) => {
+        const diag = res && res.diag
+        if (!diag || typeof diag !== 'object') return '这次连诊断信息都没有拿到。'
+        const lines = ['通道：' + String(diag.via || '未知')]
+        if (diag.how) lines.push('取服务的方式：' + String(diag.how))
+        if (diag.why) lines.push('看到的东西：' + String(diag.why))
+        if (diag.registry) lines.push('插件管理器的 registry：' + String(diag.registry))
+        if (diag.manager) lines.push('兜底通道：' + String(diag.manager))
+        return lines.join('\n')
+      }
+
       /* 把包名复制到剪贴板，便于在 DSH 的「按插件包名安装」里粘贴。
          没有剪贴板权限（或不是安全上下文）时**静默降级**成只说话 —— 不该因此报错。 */
       const copyText = (text) => {
@@ -3425,6 +4092,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
          用户点这一项想知道的就是这两件事。 */
       const showUpdate = () => {
         const note = WHATS_NEW[VERSION]
+        let hint = UPDATE_HINT
         const copied = copyText('dsh-wisp')
         /* 一步到位：先把"我是谁、这一版做了什么"说出来，同时去查有没有新版；
            查回来再用一句话覆盖掉 —— 一次只冒一个气泡，所以是"说完结果就结束"。 */
@@ -3435,9 +4103,18 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           started.then((res) => {
             if (destroyed) return
             if (res.state === 'checking') return
+            /* 新版只在 GitHub 上 → 改口 + 把仓库地址放进剪贴板（包名会装回旧版）。 */
+            if (githubOnlyNewer(res)) {
+              hint = UPDATE_HINT_GITHUB
+              lastUpdateHint = hint
+              copyText(UPDATE_REPO)
+            }
             flashHappy(base + updateLine(res))
+            /* 查不成的时候：把"为什么"摆到弹窗里（台词只留一句人话）。 */
+            if (res.state === 'failed') aboutDialog(res)
           })
         }
+        lastUpdateHint = hint
         return { version: VERSION, note: note || null, copied, checking: true }
       }
 
@@ -3468,6 +4145,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         startFocus,
         stopFocus,
         saySummary,
+        checkBalance,
         get today() { return { ...watchToday() } },
         get focus() { return focusState() },
         openAbout: () => aboutDialog(),
@@ -3562,6 +4240,21 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
               error: { selector: ERROR_SELECTOR, matches: probe(ERROR_SELECTOR) },
             },
             dark: !!(body && body.hasAttribute('data-ds-dark-theme')),
+            /* 余额：最后一次查的结果 + 有没有 host 座位。**凭据从不经过这里** ——
+               插件拿不到 key，也就不可能被谁从 doctor() 里读走。 */
+            balance: Object.assign({ hostSeat: hostSeat() !== null }, balanceCheck),
+            /* 动作层的实时状态。姿势角是**屏幕坐标**里的角度（未乘镜像），
+               accent 是当下挂着的一次性动作 —— "她为什么歪着/弹了一下"
+               在 Console 里一眼能看出来，不用去读样式。 */
+            motion: {
+              level: cfg.motion,
+              amp: amp(),
+              reduced: reduced(),
+              tilt: Math.round(tiltScreen * 100) / 100,
+              tiltLocal: tiltWritten,
+              accent: root.dataset.accent || null,
+              pressed: root.dataset.dragging === 'true',
+            },
             tokens,
             /* 窗口背景：Mica 能不能露出来，取决于页面有没有在背景处画不透明像素。
                blockers 是"每个采样点上最上面那个铺满视口的画底色的元素"，
@@ -3581,7 +4274,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
               version: VERSION,
               whatsNew: WHATS_NEW[VERSION] ?? null,
               seenBefore: readStored(SEEN_VERSION_KEY),
-              hint: UPDATE_HINT,
+              hint: lastUpdateHint,
               canSelfUpdate: false,
               /* 上一次检查的结果（idle / checking / current / available / failed / unsupported） */
               lastCheck: { ...updateCheck },
@@ -3664,6 +4357,8 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           }
           window.removeEventListener('pointermove', onMove)
           window.removeEventListener('pointerup', onUp)
+          window.removeEventListener('pointermove', leanToPointer)
+          window.removeEventListener('blur', resetTilt)
           bodyEl.removeEventListener('pointerdown', onDown)
           bodyEl.removeEventListener('keydown', onBodyKey)
           bodyEl.removeEventListener('contextmenu', onContext)