dsh-plugin-vrmpet3d 0.1.0 → 0.1.1

package/lib/core.js

@@ -71,16 +71,32 @@
    * The `{duration}` token and its machinery stay — a line the user writes may still carry it (see
    * {@link STATUS_DURATION_TOKEN}) — but the shipped line is DSH's token-free 「深度求索中 ···」, which is also what the
    * app shows while the latest turn is not open.
+   *
+   * ONE TABLE PER LANGUAGE, keyed state → language, the same shape `SPEECH_LINES` uses for its pools and for the
+   * same reason: a status line is TEXT THE USER READS, so an interface in English that still said 「任务达成」 would
+   * be a half-translated one. The two halves are written rather than translated word for word, and the Chinese is
+   * the operator's own wording, unchanged since 2026-10-13.
+   *
+   * An EDIT wins over both: `statusEntryFor` only reaches for these while the user's own box is empty, so a line
+   * typed by hand is one line in one language and stays exactly that, in either interface language. That is the
+   * whole reason this is a per-language DEFAULT rather than a second field in the settings.
    */
   var DEFAULT_STATUS_TEXT = {
-    resting: '',
-    working: '深度求索中 ···',
-    waiting: '我有问题要问你',
-    done: '任务达成',
-    error: '遇到问题了...',
-    offline: '',
+    resting: { zh: '', en: '' },
+    working: { zh: '深度求索中 ···', en: 'Working ···' },
+    waiting: { zh: '我有问题要问你', en: 'I have a question for you' },
+    done: { zh: '任务达成', en: 'Task complete' },
+    error: { zh: '遇到问题了...', en: 'Something went wrong...' },
+    offline: { zh: '', en: '' },
   };
 
+  /** One state's shipped line in one language; `''` for a state that says nothing by default. */
+  function defaultStatusText(state, language) {
+    var entry = DEFAULT_STATUS_TEXT[state];
+    if (!entry || typeof entry !== 'object') return '';
+    return typeof entry[language === 'en' ? 'en' : 'zh'] === 'string' ? entry[language === 'en' ? 'en' : 'zh'] : '';
+  }
+
   /**
    * The token a status line may carry where the live elapsed time goes, and the units it is written with.
    *
@@ -96,6 +112,155 @@
     en: { hour: 'h ', minute: 'm ', second: 's' },
   };
 
+  /**
+   * The three answers to 「界面语言」, and the ONE rule that turns them into the language a surface draws in.
+   *
+   * `auto` is the shipped answer and means "whatever the surface is already running in": DSH's own locale inside
+   * the app, the browser's on a host-served page, and on a surface that can see neither (a suite, a headless
+   * host) English — the plugin's own fallback rather than a guess about the operator.
+   *
+   * The other two are the user overruling that, and they exist because the two questions are NOT the same one:
+   * DSH can be running in English while its owner wants the pet in Chinese, and the first-run guide is read once,
+   * before any of that has settled. Operator, 2026-10-15: 「把全部界面做中英双语自动识别，并在通用设置和初始安装
+   * 引导页的第一页欢迎页面中加上语言选择」.
+   *
+   * `auto` is STORED as `auto`, never resolved on write. A profile that stored the resolved 'zh' would freeze the
+   * language on the day it was created, and the user who later switched DSH to English would keep a Chinese pet
+   * with no way to tell that from a deliberate choice — the same mistake `DEFAULTS.petSurface` documents for
+   * 显示位置, and it is why this is a preference the CLEANER knows about rather than a value a page writes.
+   */
+  var LANGUAGE_SETTINGS = ['auto', 'zh', 'en'];
+
+  /** `'auto'` for anything that is not one of the three — an unknown stored value is a reset, not an error. */
+  function cleanLanguage(value) {
+    return LANGUAGE_SETTINGS.indexOf(value) === -1 ? 'auto' : value;
+  }
+
+  /**
+   * Which of the two languages this surface draws in, given the user's setting and what the environment says.
+   *
+   * `hints` is a LIST, most authoritative first — DSH's locale, then the document's own `lang`, then
+   * `navigator.language` — and the FIRST hint that says anything decides. That order is the rule and not a detail:
+   * DSH is the application the pet lives inside, so its language outranks the browser's, and a page DSH has
+   * already marked `lang="zh"` outranks a browser whose own preference is en-US.
+   *
+   * The first hint decides the ZH-or-not question instead of the chain continuing past it, because this plugin has
+   * exactly two languages. A hint of `fr` is not a reason to go looking for a Chinese one further down the chain;
+   * it is a reason to fall back to English, which is also what `auto` with nothing to go on means.
+   */
+  function resolveLanguage(preference, hints) {
+    var wanted = cleanLanguage(preference);
+    if (wanted !== 'auto') return wanted;
+    var list = Array.isArray(hints) ? hints : [hints];
+    for (var i = 0; i < list.length; i += 1) {
+      var hint = list[i];
+      if (typeof hint !== 'string' || !hint) continue;
+      return /^(zh|cn|chinese)/i.test(hint.trim()) ? 'zh' : 'en';
+    }
+    return 'en';
+  }
+
+  /**
+   * The environment's own two hints, in the order they outrank each other — what a surface that has no DSH locale
+   * to ask uses. `scope` exists so a suite can hand in a fake window instead of moving the real one.
+   *
+   * The BROWSER comes first, and the document's own `lang` second, which is the opposite of the order the app's
+   * widget uses — deliberately. Every page this plugin serves ships `<html lang="zh">` (the plugin was written in
+   * Chinese), so a page that read its own markup first could never be auto-detected as English: the hint would be
+   * its own default rather than anything about the user. `navigator.language` is the browser's answer and in the
+   * floating window it is Electron's, i.e. the machine's.
+   */
+  function browserLanguageHints(scope) {
+    var win = scope || (typeof globalThis !== 'undefined' ? globalThis : null);
+    var doc = win && win.document;
+    var nav = win && win.navigator;
+    return [
+      nav ? (nav.language || (nav.languages && nav.languages[0])) : null,
+      doc && doc.documentElement ? doc.documentElement.lang : null,
+    ];
+  }
+
+  /**
+   * One surface's own wording, in the two languages, chosen by {@link resolveLanguage}.
+   *
+   * Every surface keeps its OWN table — `lib/menu.js`'s `LABELS`, `lib/model-picker.js`'s `TEXT`, the settings
+   * pages' `TEXT` — rather than one global dictionary, because that is already this repository's shape (a surface
+   * owns the words it draws) and because a single table for six surfaces would make every one of them edit the
+   * same file. What IS shared is the SHAPE: `{ zh: {...}, en: {...} }`, this accessor, and {@link applyI18n}.
+   *
+   * A language half that is missing or empty falls back to the other one rather than to blank: a half-translated
+   * surface reads as Chinese in one spot, which is a bug somebody reports, where a blank label is a page that
+   * looks broken. `textOf` below is what makes a GAP visible, and a suite is what keeps one from shipping.
+   */
+  function textFor(table, language) {
+    if (!table || typeof table !== 'object') return {};
+    var wanted = language === 'en' ? table.en : table.zh;
+    var other = language === 'en' ? table.zh : table.en;
+    if (wanted && typeof wanted === 'object') return wanted;
+    return other && typeof other === 'object' ? other : {};
+  }
+
+  /** One entry out of a surface's table. A missing key returns the KEY, so a gap is visible on screen. */
+  function textOf(table, language, key) {
+    var value = textFor(table, language)[key];
+    return typeof value === 'string' ? value : key;
+  }
+
+  /**
+   * Fill a document's marked-up text from one surface's table.
+   *
+   * The markup carries the CHINESE text as well as the key, and that is on purpose: this plugin's pages all ship a
+   * bootstrap watchdog for the case where a script never ran, so a page whose script DID not run should still say
+   * something in one language rather than show nothing. `verify-desktop.mjs` asserts the two agree, which is what
+   * stops the markup and the table from drifting apart.
+   *
+   * Four attributes, one per place text lives: `data-i18n` writes `textContent`, `data-i18n-html` writes
+   * `innerHTML` and is for OUR OWN sentence with a `<strong>` in it (never for anything a user or a model wrote),
+   * and `data-i18n-placeholder` / `data-i18n-title` / `data-i18n-aria` write those three attributes.
+   *
+   * A key the table does not have leaves the markup ALONE rather than printing the key: the visible text stays the
+   * Chinese fallback, and the missing entry is the suite's business, not the user's.
+   *
+   * @returns {number} how many places were rewritten, so a suite can tell "applied nothing" from "no markup".
+   */
+  function applyI18n(root, table, language) {
+    var doc = root && typeof root.querySelectorAll === 'function'
+      ? root
+      : (typeof globalThis !== 'undefined' ? globalThis.document : null);
+    if (!doc || typeof doc.querySelectorAll !== 'function') return 0;
+    var words = textFor(table, language);
+    var selector = '[data-i18n],[data-i18n-html],[data-i18n-placeholder],[data-i18n-title],[data-i18n-aria]';
+    var nodes;
+    try {
+      nodes = doc.querySelectorAll(selector);
+    } catch (error) {
+      return 0;
+    }
+    var applied = 0;
+    var write = function (node, attribute, key, html) {
+      var value = words[key];
+      if (typeof value !== 'string') return;
+      if (attribute === 'data-i18n') node.textContent = value;
+      else if (html) node.innerHTML = value;
+      else node.setAttribute(attribute, value);
+      applied += 1;
+    };
+    for (var i = 0; i < nodes.length; i += 1) {
+      var node = nodes[i];
+      var key = node.getAttribute('data-i18n');
+      if (key) write(node, 'data-i18n', key, false);
+      key = node.getAttribute('data-i18n-html');
+      if (key) write(node, 'data-i18n-html', key, true);
+      key = node.getAttribute('data-i18n-placeholder');
+      if (key) write(node, 'placeholder', key, false);
+      key = node.getAttribute('data-i18n-title');
+      if (key) write(node, 'title', key, false);
+      key = node.getAttribute('data-i18n-aria');
+      if (key) write(node, 'aria-label', key, false);
+    }
+    return applied;
+  }
+
   /**
    * The states whose prompt carries DSH's whale mark.
    *
@@ -1080,6 +1245,12 @@
   /** Default pose and behaviour knobs. */
   var DEFAULTS = {
     scope: 'global',
+    /**
+     * 界面语言 — `auto` follows the surface's own environment ({@link resolveLanguage}), and 中文 / English overrule
+     * it. It sits first in the table rather than beside the appearance rows because it is the one preference that
+     * decides how every OTHER row is spelled.
+     */
+    language: 'auto',
     size: 100,
     /**
      * WHERE the pet is shown, as the cleaner's DEFAULT rather than a string repeated beside it.
@@ -1925,6 +2096,13 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     var out = {};
     var source = raw && typeof raw === 'object' ? raw : {};
     out.scope = source.scope === 'current' ? 'current' : 'global';
+    /**
+     * 界面语言 — cleaned like every other enumerated preference: an unknown value (an older profile, a typo, a page
+     * that sent the wrong thing) is `auto`, which resolves to the surface's own environment anyway. It is NOT
+     * counted as authorship by `authoredWeight` over in `lib/settings.js`: a language is a way of looking at the
+     * pet, not something the user wrote into it.
+     */
+    out.language = cleanLanguage(source.language);
     // An unknown surface falls back to the shipped default, not to a string repeated here.
     out.petSurface = PET_SURFACES.indexOf(source.petSurface) === -1 ? DEFAULTS.petSurface : source.petSurface;
     out.size = Number.isFinite(Number(source.size)) ? clamp(Number(source.size), SIZE_RANGE.min, SIZE_RANGE.max) : DEFAULTS.size;
@@ -2480,8 +2658,8 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
   // ---------------------------------------------------------------------------
 
   /** One state's status line, exactly as the renderer draws it: text, then the tag. */
-  function statusLineFor(preferences, state) {
-    var entry = statusEntryFor(preferences, state);
+  function statusLineFor(preferences, state, language) {
+    var entry = statusEntryFor(preferences, state, language);
     if (!entry) return '';
     var tag = typeof entry.tag === 'string' ? entry.tag : '';
     return (entry.text + tag).slice(0, STATUS_LIMITS.textLength + STATUS_LIMITS.tagLength);
@@ -2493,11 +2671,15 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * Always an OBJECT, never null: every state has something to say or an explicit reason to say nothing,
    * and a caller that had to distinguish "unconfigured" from "configured empty" would get it wrong in the
    * one case that matters (a user who cleared a line).
+   *
+   * `language` picks WHICH shipped default fills an empty box — see {@link DEFAULT_STATUS_TEXT}. It is the third
+   * parameter and optional, so a caller that does not know the surface's language keeps the Chinese default the
+   * suites and the older call sites already pin.
    */
-  function statusEntryFor(preferences, state) {
+  function statusEntryFor(preferences, state, language) {
     var map = preferences && preferences.status && typeof preferences.status === 'object' ? preferences.status : {};
     var stored = map[state] && typeof map[state] === 'object' ? map[state] : {};
-    var fallback = Object.prototype.hasOwnProperty.call(DEFAULT_STATUS_TEXT, state) ? DEFAULT_STATUS_TEXT[state] : '';
+    var fallback = defaultStatusText(state, language);
     var text = typeof stored.text === 'string' ? stored.text : fallback;
     var fallbackAnimation = Object.prototype.hasOwnProperty.call(DEFAULT_STATUS_ANIMATION, state)
       ? DEFAULT_STATUS_ANIMATION[state]
@@ -3626,11 +3808,17 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
    * clause is DROPPED — DSH's own token-free 「深度求索中」 rather than a number invented here. Passed per call so the
    * two surfaces (the app's pet and the floating window) can only differ by what they are told, never by the rule.
    *
+   * `language` is the SIXTH parameter and it reaches two places: which shipped default an empty box falls back to
+   * ({@link DEFAULT_STATUS_TEXT}), and the units a `{duration}` clause is written in — DSH writes 1分30秒 in one
+   * language and 1m 30s in the other, so a line translated without its clock would read as a foreign number.
+   * Optional, like the status-entry language above: a caller that has no language to pass keeps the Chinese answer
+   * every existing suite pins.
+   *
    * @returns {{state: string, text: string, tag: string, animation: string, seconds: number}|null}
    */
-  function statusFor(preferences, state, enteredAt, now, clock) {
+  function statusFor(preferences, state, enteredAt, now, clock, language) {
     if (STATUS_STATES.indexOf(state) === -1) return null;
-    var entry = statusEntryFor(preferences, state);
+    var entry = statusEntryFor(preferences, state, language);
     if (!entry.text && !entry.tag) return null;
     var at = Number.isFinite(now) ? now : Date.now();
     /**
@@ -3683,7 +3871,7 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
       }
       text = elapsed === null
         ? durationClauseRemoved(text)
-        : text.split(STATUS_DURATION_TOKEN).join(formatRunDuration(elapsed));
+        : text.split(STATUS_DURATION_TOKEN).join(formatRunDuration(elapsed, language));
     }
     var look = statusTone(state);
     return {
@@ -7299,6 +7487,14 @@ var MOTION_STATES = STATUS_STATES.concat(INTERACTION_STATES, ['dancing']);
     STATES: STATES,
     INTERACTION_STATES: INTERACTION_STATES,
     STATUS_STATES: STATUS_STATES,
+    LANGUAGE_SETTINGS: LANGUAGE_SETTINGS,
+    cleanLanguage: cleanLanguage,
+    resolveLanguage: resolveLanguage,
+    browserLanguageHints: browserLanguageHints,
+    textFor: textFor,
+    textOf: textOf,
+    applyI18n: applyI18n,
+    defaultStatusText: defaultStatusText,
     DEFAULT_STATUS_TEXT: DEFAULT_STATUS_TEXT,
     STATUS_TAGS: STATUS_TAGS,
     STATUS_ANIMATIONS: STATUS_ANIMATIONS,

package/lib/desktop-page.js

@@ -65,6 +65,49 @@
    */
   var MENU_MARGIN = 4;
 
+  /**
+   * This page's own words, in the two languages — `{ zh: {...}, en: {...} }` with IDENTICAL key sets, the
+   * repository's per-surface shape (`lib/menu.js`'s `LABELS`, `lib/client.js`'s `STRINGS`).
+   *
+   * These four are the only strings this page PAINTS that are its own rather than the app's: the three moments
+   * of 重载模型 and 跳支舞 with nothing to dance to, all of them said in the pet's bubble (`showLocalSpeech`).
+   * The app's pet says the same four things in its badge for the same gestures, so the wording here is kept in
+   * step with that table BY HAND — a drift is one gesture answered in two different sentences. `assets/motions/dance`
+   * is a path rather than words and is written the same way in both halves.
+   *
+   * Read at CALL time through `word`: `preferences.language` can change while this window runs.
+   */
+  var TEXT = {
+    zh: {
+      reloading: '正在重载模型…',
+      reloaded: '模型已重载',
+      reloadFailed: '模型重载失败',
+      danceEmpty: '没有可用的舞蹈动作（assets/motions/dance 是空的）',
+    },
+    en: {
+      reloading: 'Reloading the model…',
+      reloaded: 'Model reloaded',
+      reloadFailed: 'Could not reload the model',
+      danceEmpty: 'No dance clip is available (assets/motions/dance is empty).',
+    },
+  };
+
+  /**
+   * One entry out of {@link TEXT}, in the language on screen — read at CALL time, never captured.
+   *
+   * `'en'` is the only value that selects the English half: every language this page resolves is exactly 'zh' or
+   * 'en' (see the mount), and anything unexpected reads the Chinese half, which is the fallback the markup and
+   * `lib/menu.js`'s own `strings()` already use. An entry missing from THAT half falls back to the other one, and
+   * an entry missing from both returns the key — a gap that SHOWS rather than `undefined` drawn in the pet's
+   * bubble, which is the rule `core.textOf` follows.
+   */
+  function word(language, key) {
+    var half = language === 'en' ? TEXT.en : TEXT.zh;
+    if (typeof half[key] === 'string') return half[key];
+    var other = language === 'en' ? TEXT.zh : TEXT.en;
+    return typeof other[key] === 'string' ? other[key] : key;
+  }
+
   /**
    * This page's own stylesheet, injected once.
    *
@@ -593,8 +636,21 @@
     // 是不对的。删掉两个单独的设置面板。」); every setting it used to offer is on one of the two settings pages.
     // ---------------------------------------------------------------------------------------
     var doc = canvas.ownerDocument || globalThis.document || null;
-    var language = options.language
-      || ((globalThis.navigator && /^zh/i.test(globalThis.navigator.language || '')) ? 'zh' : 'en');
+    /**
+     * 界面语言, resolved through the ONE shared rule rather than guessed here.
+     *
+     * An explicit `preferences.language` wins, and `auto` follows the FIRST hint that says anything — and this
+     * page has no DSH locale to ask (it is served by the launcher, not by DSH), so the hints are the browser's own
+     * two: `navigator.language`, which in this window is Electron's and therefore the machine's, and then the
+     * document's `lang`. English is what nothing-at-all answers.
+     *
+     * A core chunk that predates the rule (the stale-delivery case this repository has eaten more than once) falls
+     * back to the browser hint this page used before, so an older host costs the SHARING of the rule, not the
+     * language. The preference is re-read by `adoptLanguage` whenever the settings change.
+     */
+    var language = typeof core.resolveLanguage === 'function'
+      ? core.resolveLanguage(preferences.language, core.browserLanguageHints())
+      : ((globalThis.navigator && /^zh/i.test(globalThis.navigator.language || '')) ? 'zh' : 'en');
     installDesktopStyles(doc);
     var menu = null;
     var menuOpen = false;
@@ -725,6 +781,13 @@
      */
     function buildMenu() {
       var api = globalThis.__VRMPET3D_MENU__;
+      /**
+       * A REBUILD replaces the element rather than leaving the old one in the body: the menu carries its words
+       * from `createMenu` and cannot be re-worded in place, so `adoptLanguage` builds a new one — and a second
+       * copy would keep its own document listeners. `menuOpen`/`menuBox` are the page's own and are cleared by
+       * `closeMenu`/`onMenuClosed` before this runs.
+       */
+      if (menu && typeof menu.destroy === 'function') menu.destroy();
       if (!api || typeof api.createMenu !== 'function' || !doc) return null;
       api.injectStyle(doc, 'vrmpet3d-menu-style');
       return api.createMenu({
@@ -836,6 +899,40 @@
     }
 
     menu = buildMenu();
+    /**
+     * Follow 界面语言 — the preference, this page's environment, and its own four sentences.
+     *
+     * Called from every path that replaces `preferences` (a host snapshot, a storage write from the settings
+     * window), because the language is a preference like any other and a change made there has to reach this
+     * window without a reload. 'auto' means what the browser says here, and the browser can be re-read at any
+     * time; only a CHANGE does anything, since this rebuilds the menu.
+     *
+     * What a change touches, and why exactly these:
+     *   * `language` is read at CALL time by everything that words this page (the say request, the shipped pool
+     *     for a touched part, `core.statusFor`'s default line and its clock units, the published readout, the four
+     *     bubble sentences), so a new value reaches all of them by itself;
+     *   * the MENU carries its labels from `createMenu`, so it is rebuilt — and a menu that is OPEN is closed
+     *     first, because its rows are the old words and its closing is what gives the window its pet-sized box
+     *     back;
+     *   * the prompt is redrawn here rather than on the next frame: this page's frame loop re-renders on a cached
+     *     key, and a language change does not alter the STATE, so the cached line would otherwise keep the old
+     *     words until the state changed.
+     */
+    function adoptLanguage() {
+      var next = typeof core.resolveLanguage === 'function'
+        ? core.resolveLanguage(preferences.language, core.browserLanguageHints())
+        : ((globalThis.navigator && /^zh/i.test(globalThis.navigator.language || '')) ? 'zh' : 'en');
+      if (next === language) return;
+      language = next;
+      if (menuOpen) closeMenu();
+      menu = buildMenu();
+      statusKey = null;
+      renderStatus();
+      layout();
+      reportRect();
+      publish();
+    }
+
     /**
      * The model catalog, fetched once — and re-read whenever the store names a model this list cannot answer for
      * (`refreshCatalog`). See the snapshot handler for the import-while-running case that made that necessary.
@@ -1228,7 +1325,12 @@
         body: JSON.stringify({
           state: hostState || null,
           event: stateEventName(),
-          language: preferences.language === 'en' ? 'en' : 'zh',
+          /**
+           * The language this page is DRAWN in, not `preferences.language` raw: 'auto' is not a language, and a
+           * host asked for a line in 'auto' would have to guess at exactly the thing this page has already
+           * resolved. The host's prompt is built from this, so a line arrives in the language on screen.
+           */
+          language: language,
           part: item.id,
           structure: structure || null,
           chain: chain || null,
@@ -1413,7 +1515,7 @@
       if (!statusNode) return;
       // The TURN clock the app sent with the state, not this page's own age for it: 用时 is a claim about DSH's turn,
       // and with no turn to report the token is dropped (DSH's own token-free 「深度求索中」). See `PetMachine.statusClock`.
-      var line = core.statusFor(preferences, hostState, hostStateAt, Date.now(), hostStateClock);
+      var line = core.statusFor(preferences, hostState, hostStateAt, Date.now(), hostStateClock, language);
       if (!line) {
         statusKey = null;
         statusShown = null;
@@ -1610,12 +1712,15 @@
       if (!id) return Promise.resolve(null);
       if (typeof scene.bustModelCache === 'function') scene.bustModelCache();
       // The bubble is this page's own way of saying something transient — the same channel a touched part uses.
-      showLocalSpeech('正在重载模型…', 3);
+      // The three lines of 重载模型 come from this page's own table, and are the same three the app's pet puts in
+      // its badge for the same menu row.
+      showLocalSpeech(word(language, 'reloading'), 3);
       return loadModelSerialized(id).then(function (status) {
         layout();
         scene.applyPreferences(preferences);
         publish();
-        showLocalSpeech(status && status.ok ? '模型已重载' : ((status && status.error) || '模型重载失败'), 3);
+        showLocalSpeech(status && status.ok ? word(language, 'reloaded')
+          : ((status && status.error) || word(language, 'reloadFailed')), 3);
         return status;
       });
     }
@@ -1638,9 +1743,13 @@
           && prefixes.some(function (prefix) { return String(entry.name || '').indexOf(prefix) === 0; });
       }).map(function (entry) { return entry.id; });
       if (!ids.length) {
-        showLocalSpeech('没有可用的舞蹈动作（assets/motions/dance 是空的）', 3);
+        // The same sentence the app's pet shows in its badge for its own 跳支舞 row.
+        showLocalSpeech(word(language, 'danceEmpty'), 3);
         return Promise.resolve(null);
       }
+      var current = dancePreview && dancePreview.motionId;
+      var alternatives = ids.filter(function (id) { return id !== current; });
+      if (alternatives.length) ids = alternatives;
       var picked = ids[Math.floor(Math.random() * ids.length)];
       return fetch('/vrmpet3d/preview', {
         method: 'POST',
@@ -2448,7 +2557,7 @@
          *
          * Sent ONCE per dance: the flag resets as soon as the drawn state leaves 跳舞, so a finished clip cannot post every frame.
          */
-        if (drawn === 'dancing' && scene.playback && scene.playback.record && scene.playback.record.finished === true) {
+        if (drawn === 'dancing' && scene.playback && scene.playback.state === 'dancing' && scene.playback.record && scene.motionFinished(scene.playback.record)) {
           if (!danceEndedReported) {
             danceEndedReported = true;
             try {
@@ -3410,6 +3519,19 @@
     canvas.addEventListener('pointermove', onPointerMove);
     canvas.addEventListener('pointerup', onPointerUp);
     canvas.addEventListener('pointercancel', onPointerUp);
+    function onDoubleClick(event) {
+      if (event.button !== undefined && event.button !== 0) return;
+      if (hostState !== 'dancing' && !dancePreview) return;
+      dancePreview = null;
+      if (hostState === 'dancing') hostState = 'resting';
+      scene.setPreview(null);
+      scene.setState('resting');
+      fetch('/vrmpet3d/preview', {
+        method: 'POST', credentials: 'omit',
+        headers: { 'content-type': 'application/json' }, body: '{}',
+      }).catch(function () { return null; });
+    }
+    canvas.addEventListener('dblclick', onDoubleClick);
     canvas.addEventListener('wheel', onWheel, { passive: false });
     canvas.addEventListener('contextmenu', onContextMenu);
     /**
@@ -3558,6 +3680,12 @@
       placement.preferences = next;
       placement.setSize(client.BASE_PET_SIZE.width, client.BASE_PET_SIZE.height);
       placement.clampToViewport();
+      /**
+       * 界面语言 is a preference like the rest, and only now is the answer readable — `next.language` may be an
+       * explicit 中文/English or `auto`, which this page answers from its own environment. After the size clamp,
+       * because a language change lays the window out again.
+       */
+      adoptLanguage();
       /**
        * 重力 comes from the store like everything else, and it is PHYSICS rather than a value the scene
        * re-applies — so it has to be pushed here too. Without this line the switch would work until the next
@@ -3633,6 +3761,10 @@
         onPreview: function (preview) {
           dancePreview = preview && preview.state === 'dancing' ? preview : null;
           if (dancePreview) {
+            // Each preview notification is a NEW run, including the same sole clip.
+            danceEndedReported = false;
+            scene.setPreview(null);
+            if (scene.playback && scene.playback.state === 'dancing') scene.stopPlayback(null);
             ensureMotion(preview.motionId, false);
             return;
           }
@@ -3717,6 +3849,9 @@
         placement.preferences = next;
         placement.setSize(client.BASE_PET_SIZE.width, client.BASE_PET_SIZE.height);
         placement.clampToViewport();
+        // A storage write is the fallback path for a host without the settings route, and the settings window is
+        // where 界面语言 is chosen: the same re-resolution the snapshot path does, after the size clamp.
+        adoptLanguage();
         // The scene re-reads the whole preference set: springs and expressions are applied from it, so
         // a change made in the settings window lands on the pet through this one call.
         scene.applyPreferences(Object.assign({}, next, { motions: effectiveMotions() }));
@@ -3909,6 +4044,7 @@
         canvas.removeEventListener('pointermove', onPointerMove);
         canvas.removeEventListener('pointerup', onPointerUp);
         canvas.removeEventListener('pointercancel', onPointerUp);
+        canvas.removeEventListener('dblclick', onDoubleClick);
         canvas.removeEventListener('wheel', onWheel);
         canvas.removeEventListener('contextmenu', onContextMenu);
         if (menu && typeof menu.destroy === 'function') menu.destroy();