dsh-wisp 1.36.0 → 1.42.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.36.0'
+    const VERSION = '1.42.0'
 
 /* 每一版一句话。**必须写当前版本** —— 预检里有一条断言盯着它，
    忘了更新就会红，不会静默过期。 */
@@ -80,6 +80,12 @@ const WHATS_NEW = {
   '1.34.1': '菜单改成紧凑刻度，占屏幕小了三成。',
   '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': '查更新失败时她会直接说清是哪一种：没通道 / 连不上 / 宿主没应答。',
 }
 
 /* 更新这件事**这个插件自己做不到**，如实写在代码里，免得以后有人以为能：
@@ -218,11 +224,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
@@ -239,6 +297,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
@@ -397,6 +463,11 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       updateCurrent: ['已经是最新的了。', '我就是最新的。', '没有更新的。'],
       updateAvailable: ['有新版本了：', '有新版：', '更新来了：'],
       updateFailed: ['更新没查成。', '这次没查到更新。', '更新检查没成功。'],
+      /* 失败不是一个笼统的状态：「这个壳里没有联网的通道」「两个源都没连上」
+         「宿主那边没应答」是三件事，含糊地说成"没查到"就没人能追下去 ——
+         而用户看到的恰恰只有那一句。 */
+      updateNoChannel: ['这个壳里我没有联网的通道，查不了更新。', '这里没有能出去的网络通道。'],
+      updateNoHost: ['宿主那边没应答，更新没查成。', '问不到宿主，更新没查成。'],
       milestone: [
         '今天第 {n} 轮了。', '{n} 轮了，还不错。', '已经 {n} 轮了，你挺能撑。',
         '第 {n} 轮 —— 我数着呢。', '{n} 轮，进度可观。', '今天 {n} 轮，记上了。',
@@ -408,6 +479,17 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
         '去窗边看看。', '我在这儿等你回来。', '坐太久了，动一下。', '你不动，我就一直看着你。',
       ],
       hint: ['右键我一下试试。', '右键我有菜单。', '拖我，或者右键我。'],
+
+      /* 余额。数字由客户端拼好（{n}），台词只管口气 —— 她报的是账户，
+         不是她自己的钱，所以既不邀功也不夸张。 */
+      balanceChecking: ['看一下……', '等等，我查查。', '让我看看。'],
+      balance: ['余额 {n}。', '还有 {n}。', '{n}，暂时够用。', '账上是 {n}。'],
+      balanceBonus: ['其中赠送 {n}。', '还有 {n} 是赠送的。'],
+      balanceEmpty: ['没查到余额记录。', '账上没有额度记录。'],
+      balanceSignedOut: ['没登录，看不到余额。', '这个得先登录才行。', '还没登录，余额在平台那边。'],
+      balanceUnavailable: ['刚才没读到，一会儿再看。', '这一下没读到，稍后再试。'],
+      balanceFailed: ['余额没查成。', '这个没读出来，稍后再试。'],
+      balanceUnsupported: ['这个壳里我查不了余额。', '这里没有查余额的通道。'],
     }
 
     /* 英文台词。**只翻译她说的话**（菜单按钮文案仍由 DSH 界面语言决定，不在这一层）。
@@ -442,6 +524,17 @@ 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.'],
+      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.'],
     }
 
     /* 语言：中文环境（或读不到语言）用中文，其余走英文覆盖层。
@@ -462,8 +555,35 @@ const UPDATE_HINT = '在 DSH 的插件列表里按包名安装：dsh-wisp'
       if (langHtml !== '') return langHtml
       try { return String(navigator.language || navigator.userLanguage || 'zh') } catch (e) { return 'zh' }
     })()
-    const IS_ZH = LANG_TAG.toLowerCase().indexOf('zh') === 0
-    const LINES = IS_ZH ? LINES_ZH : Object.assign({}, LINES_ZH, LINES_EN)
+    /* 进页面时的默认判定（用户没显式选过就用它） */
+    const IS_ZH_DEFAULT = LANG_TAG.toLowerCase().indexOf('zh') === 0
+
+    /* 现在用哪种语言：① 设置里显式选过就听它 ② 否则用进页面时的判定。
+       —— 做成**函数**而不是常量，这样菜单里切换立刻生效，不用刷新。 */
+    const isZhNow = () => {
+      /* cfg 是后面才声明的 const：取词可能发生在它初始化之前，
+         而那时访问它会抛 TDZ 错误（不是 undefined）—— 所以这里必须兜住。 */
+      let forced = 'auto'
+      try { forced = (cfg && typeof cfg.lang === 'string') ? cfg.lang : 'auto' } catch (e) { forced = 'auto' }
+      if (forced === 'zh') return true
+      if (forced === 'en') return false
+      return IS_ZH_DEFAULT
+    }
+
+    /* LINES 是一个**视图**：取词的那一刻才决定用中文还是英文覆盖层。
+       用 Proxy 而不是"提前合并成一个对象" —— 后者在切换语言时是死值，必须刷新页面。
+       覆盖层缺哪条就退回中文，所以可以慢慢补齐，永远不会出现半句话。 */
+    const LINES = new Proxy({}, {
+      get(_target, key) {
+        const zh = LINES_ZH[key]
+        if (isZhNow()) return zh
+        const en = LINES_EN[key]
+        return en === undefined ? zh : en
+      },
+      has(_target, key) { return key in LINES_ZH },
+      ownKeys() { return Reflect.ownKeys(LINES_ZH) },
+      getOwnPropertyDescriptor() { return { enumerable: true, configurable: true } },
+    })
 
     /* 深夜窗口。bedtime > wake 时它跨零点（默认 23→5）；不跨也能用（比如 1→5）。 */
     const isNightHour = (hour, from, to) => {
@@ -558,7 +678,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) { /* 音效永远不该打断别的事 */ }
@@ -575,6 +698,7 @@ const SOUNDS = (typeof __WISP_SOUNDS__ === 'object' && __WISP_SOUNDS__ !== null)
       hungry: { kind: 'bool' },
       hungerMs: { kind: 'num', lo: 0, hi: 86400000 },
       focusMinutes: { kind: 'num', lo: 1, hi: 600 },
+      lang: { kind: 'str' },
       sound: { kind: 'bool' },
       soundVolume: { kind: 'num', lo: 0, hi: 1 },
       night: { kind: 'bool' },
@@ -588,6 +712,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' },
@@ -600,6 +725,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)
     }
 
@@ -776,8 +904,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}
@@ -800,6 +933,29 @@ 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}
+.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}
@@ -825,6 +981,11 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 .wisp-menu-glyph{display:inline-block;width:12px;margin-right:4px;text-align:center;font-size:10.5px;opacity:.72;font-weight:400}
 .wisp-menu-item[data-accent="true"] .wisp-menu-glyph{opacity:1}
 .wisp-menu-caret{opacity:.5;font-size:8px;flex:0 0 auto}
+/* 三选一的胶囊组：选中的那颗有强调色，其余是淡底 —— 一眼看出"只能选一个、现在选的是哪个" */
+.wisp-choice{display:flex;gap:2px;flex:0 0 auto;padding:1px;border-radius:999px;background:rgba(140,160,190,.18)}
+.wisp-choice-opt{padding:1px 6px;border:0;border-radius:999px;background:none;color:inherit;font:inherit;font-size:9.5px;line-height:13px;cursor:pointer;opacity:.7;transition:background .1s ease,opacity .1s ease}
+.wisp-choice-opt:hover{opacity:1}
+.wisp-choice-opt[data-on="true"]{background:var(--wisp-accent,#4a7cf7);color:#fff;opacity:1}
 .wisp-switch{flex:0 0 auto;width:22px;height:12px;border-radius:6px;background:rgba(140,160,190,.4);position:relative;transition:background .16s ease}
 .wisp-switch[data-on="true"]{background:var(--wisp-accent,#4a7cf7);box-shadow:0 0 0 2px rgba(74,124,247,.14)}
 .wisp-switch i{position:absolute;top:2px;left:2px;width:8px;height:8px;border-radius:50%;background:#fff;box-shadow:0 1px 2px rgba(0,0,0,.28);transition:transform .16s ease}
@@ -872,7 +1033,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-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') {
@@ -937,8 +1098,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
@@ -969,12 +1133,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.
 
@@ -1282,6 +1496,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`,
@@ -1289,7 +1519,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()
@@ -1301,7 +1533,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" 却没有入口，与
@@ -1311,6 +1543,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'
 
@@ -1341,9 +1605,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
@@ -1367,7 +1645,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, () => {
@@ -1378,8 +1656,13 @@ 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（命中层）。 */
+      leanEl.appendChild(shine)
+      leanEl.appendChild(img)
+      motionEl.appendChild(leanEl)
+      bodyEl.appendChild(motionEl)
+      bodyEl.appendChild(hitEl)
       root.appendChild(bodyEl)
       layer.appendChild(root)
       setSprite('idle')
@@ -1436,10 +1719,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')
@@ -1467,6 +1826,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`.
@@ -1700,6 +2063,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)
@@ -1711,6 +2078,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)
@@ -1983,18 +2351,23 @@ 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
@@ -2008,9 +2381,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()：记忆的是"用户把她放在哪"，她自己的溜达
           // 不该覆盖那个意图，否则刷新后她会出现在一个用户从没选过的位置。
         })
@@ -2066,13 +2440,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
@@ -2107,12 +2483,23 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (!moved) return
         coords.x = clamp(origin.x + dx, 0, maxX())
         coords.y = clamp(origin.y + dy, 0, maxY())
+        /* 拖动时她朝**运动的反方向**倾：被拎着走的东西，顶是往后倒的。
+           只看"这一次事件走了多远"就等价于速度，不用存历史、不用积分 ——
+           而且它天然跟着指针事件的频率走，慢拖就是小角度。 */
+        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()
@@ -2152,15 +2539,50 @@ 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 (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 })
+      /* 指针移出窗口、或者你切走应用之后，不会再有点事件来把它归零 ——
+         没有这一下，她会一直朝着最后那个位置歪着。 */
+      const resetTilt = () => setTilt(0)
+      window.addEventListener('blur', resetTilt)
+
       /* 键盘入口：Enter / Space / 菜单键 / Shift+F10 打开菜单。
          Space 默认会滚动页面，Enter 在表单里会提交 —— 都要拦。 */
       /* 方向键微调位置。
@@ -2259,6 +2681,45 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
 
       /* 开关行：真开关的样子 + role=menuitemcheckbox + aria-checked。
          点完**不关菜单** —— 拨开关时菜单消失是最烦人的交互之一。 */
+      /* 三选一（语言）。做成一行里的一排小胶囊：比三个开关清楚 ——
+         "同时只能选一个"这件事，胶囊组是自明的，开关组不是。 */
+      const choiceRow = (spec, into) => {
+        const row = document.createElement('div')
+        row.className = 'wisp-menu-item wisp-menu-row wisp-choice-row'
+        row.dataset.choice = spec.key
+        const label = document.createElement('span')
+        label.textContent = spec.label
+        row.appendChild(glyph(spec.glyph || ''))
+        row.appendChild(label)
+        const group = document.createElement('span')
+        group.className = 'wisp-choice'
+        group.setAttribute('role', 'radiogroup')
+        group.setAttribute('aria-label', spec.label)
+        const current = cfg[spec.key] === undefined ? 'auto' : String(cfg[spec.key])
+        for (const opt of spec.options) {
+          const btn = document.createElement('button')
+          btn.className = 'wisp-choice-opt'
+          btn.setAttribute('type', 'button')
+          btn.setAttribute('role', 'radio')
+          btn.setAttribute('tabindex', '-1')
+          btn.setAttribute('aria-checked', opt.value === current ? 'true' : 'false')
+          btn.dataset.value = opt.value
+          btn.dataset.on = opt.value === current ? 'true' : 'false'
+          btn.textContent = opt.label
+          btn.addEventListener('pointerdown', (ev) => ev.stopPropagation())
+          btn.addEventListener('click', (ev) => {
+            ev.preventDefault(); ev.stopPropagation()
+            try { applyConfig({ [spec.key]: opt.value }) } catch (err) { /* ignore */ }
+            refreshSurfaces()          // 立刻重画：语言切换要当场看得见
+          })
+          group.appendChild(btn)
+          menuButtons.push(btn)
+        }
+        row.appendChild(group)
+        into.appendChild(row)
+        return row
+      }
+
       const switchRow = (spec, into) => {
         const on = cfg[spec.key] === true
         const btn = document.createElement('button')
@@ -2400,6 +2861,7 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
       const renderChildren = (children, into) => {
         for (const child of children) {
           if (child.kind === 'switch') { switchRow(child, into); continue }
+        if (child.kind === 'choice') { choiceRow(child, into); continue }
           if (child.kind === 'corners') { cornerGrid(into); continue }
           actionRow(child, into)
         }
@@ -2827,6 +3289,28 @@ 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: '文',
+              options: [
+                { value: 'auto', label: '跟随界面' },
+                { value: 'zh', label: '中文' },
+                { 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，点完菜单不关（就在原地更新） */
@@ -3229,11 +3713,21 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
         if (cfg.persist && partial && typeof partial === 'object' && partial.size !== undefined) {
           writeStored(PREFS_KEY, { size: cfg.size })
         }
+        /* 语言选择存到**语言键**上（不是 PREFS_KEY）：它在**加载时**就会被读，
+           所以下次打开才生效。菜单里的胶囊切的是"以后说哪种话"。 */
+        if (partial && typeof partial === 'object' && typeof partial.lang === 'string') {
+          try { window.localStorage.setItem('dsh-wisp-lang', cfg.lang) } catch (e) { /* 存不了就算了 */ }
+        }
         // A bigger companion occupies a bigger box, so the stored position has
         // to be re-clamped or she would grow off the edge.
         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()
@@ -3291,7 +3785,15 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
           .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,
+                at: nowMs(),
+              }
             } else if (compareVersions(VERSION, res.latest) < 0) {
               /* from / sources 一起留着：两个源不一致时（npm 暂存、GitHub 已更新），
                  "这个数字是哪儿来的"比数字本身更需要能查。 */
@@ -3312,9 +3814,95 @@ 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
+          })
+      }
+
       const updateLine = (res) => {
         if (res.state === 'available') return pick(LINES.updateAvailable) + res.latest
         if (res.state === 'current') return pick(LINES.updateCurrent)
+        /* 失败要说清是哪一种：没有通道 / 连不上 / 宿主没应答。
+           `no-web-service` 是"这个壳根本没有联网入口"，不是"网络不好"——
+           以前两者共用一句"没查到更新"，于是诊断只能靠猜。 */
+        if (res.state === 'unsupported' || res.reason === 'no-web-service') return pick(LINES.updateNoChannel)
+        if (res.reason === 'call-failed') return pick(LINES.updateNoHost)
         return pick(LINES.updateFailed)
       }
 
@@ -3380,6 +3968,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(),
@@ -3474,6 +4063,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 是"每个采样点上最上面那个铺满视口的画底色的元素"，
@@ -3511,7 +4115,10 @@ body[data-ds-dark-theme] .wisp-layer{--wisp-say-fg:#eaf2f8;--wisp-say-bg:rgba(20
             },
             streak: streakOf(memory.days),
             /* 语言判定的输入与结果 —— 中英文走岔时能一眼看清是哪一层不对 */
-            lang: { tag: LANG_TAG, zh: IS_ZH, stored: langStored, html: langHtml, pools: Object.keys(LINES_EN).length },
+            lang: {
+              tag: LANG_TAG, zh: isZhNow(), choice: (cfg && typeof cfg.lang === 'string') ? cfg.lang : 'auto',
+              stored: langStored, html: langHtml, pools: Object.keys(LINES_EN).length,
+            },
             awaySince: Math.round(awayAt),
             /* 今天记了什么 —— 不用猜"她为什么说今天跑了 7 轮" */
             today: { ...watchToday() },
@@ -3573,6 +4180,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)