dsh-plugin-vrmpet3d 0.0.0-stage → 0.1.0

package/desktop/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "vrmpet3d-desktop-window",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Electron entry for the pet's always-on-top window, started by the plugin's host half.",
+  "main": "main.js"
+}

package/desktop/preload.js

@@ -0,0 +1,66 @@
+// The bridge between the pet's window and the page inside it.
+//
+// Deliberately tiny, and deliberately the ONLY way the page can talk to Electron: the page
+// is a normal web page loading the plugin's own sources, and it runs with
+// `contextIsolation: true` and no Node integration. Everything crossing this bridge is a
+// plain number or a boolean, so a compromised page cannot reach the filesystem, the
+// process, or any other window.
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('vrmpet3dDesktop', {
+  /**
+   * Ask for the launch configuration: which model to show, where the asset route lives.
+   * Sent as an invoke so the page can await it before mounting anything.
+   */
+  config: () => ipcRenderer.invoke('vrmpet3d:config'),
+
+  /** The global cursor position, pushed by the main process at frame rate. */
+  onCursor: (callback) => {
+    if (typeof callback !== 'function') return;
+    ipcRenderer.on('vrmpet3d:cursor', (_event, point) => callback(point));
+  },
+
+  /**
+   * Tell the main process where the pet is, so it can decide between receiving clicks and
+   * passing them through. `dragging` keeps the window interactive for the whole gesture
+   * rather than only while the cursor happens to be over the pet.
+   */
+  reportRect: (rect) => ipcRenderer.send('vrmpet3d:rect', rect),
+
+  /** Announce that the pet is mounted and drawing, with the facts the launcher reports. */
+  ready: (info) => ipcRenderer.send('vrmpet3d:ready', info),
+
+  /**
+   * Ask for a MODEL FILE, with a NATIVE file picker.
+   *
+   * A FILE, not a folder, and the operator's reason is the design: 「选择VRM模型所在的文件，并导入到插件的本地配置
+   * 中去，不再是选中一个文件夹了，万一文件夹移位了，也会出bug」. The launcher answers with the chosen path — or null
+   * when the user cancelled — and the PAGE hands it to the HOST over `/vrmpet3d/models`, which COPIES it into the
+   * plugin's own storage. The host stays the only writer of that list, and the `VRMPET3D_MODEL_FILES_FILE` /
+   * `VRMPET3D_IMPORT_DIR` overrides the suites rely on are not bypassed.
+   */
+  pickModelFile: () => ipcRenderer.invoke('vrmpet3d:pick-path', { kind: 'model' }),
+
+  /**
+   * The same dialog for an imported MOTION folder (`/vrmpet3d/motions`), which stays a DIRECTORY: a motion pack is
+   * a folder of clips filed by state, and the host copies the folder rather than a single file out of it.
+   *
+   * One channel for both, with `kind` deciding a FILE dialog from a folder one and the title each shows.
+   */
+  pickMotionDir: () => ipcRenderer.invoke('vrmpet3d:pick-path', { kind: 'motion' }),
+
+  /**
+   * Tell the launcher that a VIEW ORBIT is starting or ending — and let IT take the pointer lock.
+   *
+   * The page cannot do it itself, and that is a measurement rather than a rule of thumb: this window is created
+   * `focusable: false`, and Chromium refuses a lock request from a document that is not focused (「The root
+   * document of this element is not valid for pointer lock.」). Even once the launcher has focused it, a request
+   * that the PAGE makes has crossed an IPC boundary, and that is not the moment Chromium wants. So the launcher
+   * owns both halves: it focuses the window and requests the lock with Electron's `userGesture` flag, and it
+   * exits the lock when the drag ends. The page only READS the result (`pointerlockchange`).
+   */
+  orbit: (active) => ipcRenderer.send('vrmpet3d:orbit', active === true),
+
+  /** The one control the page has over its own window. */
+  quit: () => ipcRenderer.send('vrmpet3d:quit'),
+});

package/desktop/probe-motion-picker.js

@@ -0,0 +1,122 @@
+/**
+ * The 状态与动作 clip picker's probe: ONE script, evaluated in the settings window by `desktop/main.js`.
+ *
+ * It lives in its own file for the reason `probe-parts-editor.js` documents: a template literal inside `main.js`
+ * is one stray backtick away from breaking the LAUNCHER rather than a test, and a plain file can be proved to
+ * parse by the suite before anything is spawned.
+ *
+ * WHY IT EXISTS. The operator reported "the last clip cannot be selected" on 2026-10-12, and the cause was in
+ * the page's own collection step: `onMotionToggle` gathered EVERY checked checkbox in the state's row, which
+ * included each ticked clip's 凝视 switch — and a checkbox written without a `value` attribute has the DOM
+ * default `'on'`, so ticking a clip stored the literal string `on` as a clip id. Those junk entries then took
+ * slots in the per-state list, and the clip the operator had just ticked was the one pushed out. Nothing outside
+ * the page can see that: the ids arrive at the host as a perfectly valid-looking POST.
+ *
+ * So this probe drives the real box and compares two numbers that must agree — what the PAGE thinks is selected
+ * against what the CORE will keep — and reports the junk. Nothing here is asserted; the numbers travel to
+ * `scripts/verify-desktop.mjs`, where the suite decides.
+ *
+ * It is an EXPRESSION (an immediately-invoked async arrow), so `executeJavaScript` awaits it and hands back the
+ * resolved JSON string.
+ */
+(async () => {
+  const state = () => globalThis.__VRMPET3D_CONFIG_STATE__ || {};
+  const row = () => document.querySelector('#motion-list .motion-state[data-state="resting"]');
+  const tickBoxes = () => Array.from(row() ? row().querySelectorAll('.picks label.pick input[type=checkbox]') : []);
+  const gazeBoxes = () => Array.from(row() ? row().querySelectorAll('label.clip-gaze input[type=checkbox]') : []);
+
+  const out = { error: null };
+  if (!row()) { out.error = 'no 空闲 box set'; return JSON.stringify(out); }
+
+  /**
+   * THE FOLDER ↔ STATE SCOPING, measured on every state at once.
+   *
+   * Operator's request (2026-10-12): the folders under `assets/motions` are not a filing convention, they are
+   * the mapping — "把对应的动作直接解析到指定目录，这样在选择动作的时候就不会出现很长一串". So each state's box set is
+   * offered only its own folder's clips. What is measured here is that promise, per state: which folder the
+   * state declares, and whether every box drawn in that row belongs to it. With no `stateFolders` in the
+   * payload (an older host) nothing is declared and every state is offered everything — the compatible answer.
+   * The suite's stub now declares ONE mapping as well, because the shipped pack declares six and an
+   * undeclared-everywhere stub is what let the empty-list defect ship.
+   */
+  const mappings = (state().motions || {}).stateFolders || {};
+  out.stateFolders = mappings;
+  out.scoped = (state().motions ? (state().motions.perState || {}) : {});
+  // The catalogue as the PAGE holds it, published as id → name, so this needs no second fetch and no guess.
+  const byId = new Map(Object.entries((state().motions || {}).offeredNames || {}));
+  /**
+   * A state's folders as a LIST, whatever the payload carried.
+   *
+   * A manifest value may be ONE folder or SEVERAL (`"resting": ["idle", "dance"]`), and the host normalises it
+   * to a list before serving it. The probe reads either shape, because it measures the PAGE: a page that
+   * compared that list to a single folder name is the defect it reported on 2026-10-12.
+   */
+  const folderList = (value) => (Array.isArray(value) ? value : (value ? [value] : []))
+    .filter((name) => typeof name === 'string' && name);
+  out.rows = {};
+  for (const name of Object.keys(out.scoped)) {
+    const stateRow = document.querySelector(`#motion-list .motion-state[data-state="${name}"]`);
+    if (!stateRow) continue;
+    const all = Array.from(stateRow.querySelectorAll('.picks label.pick input[type=checkbox]'));
+    const values = all.map((box) => box.value);
+    const folder = mappings[name] || null;
+    const folders = folderList(mappings[name]);
+    /**
+     * What must never be in a scoped row: a clip from ANOTHER folder that the user did not tick. A ticked clip
+     * from outside IS drawn, deliberately — a stored mapping is never hidden from the person who made it — so
+     * the check is on the unticked rows, which are the list being read when choosing.
+     */
+    const ticked = new Set(all.filter((box) => box.checked).map((box) => box.value));
+    const outside = folders.length
+      ? values.filter((id) => !ticked.has(id)
+        && !folders.some((dir) => String(byId.get(id) || '').indexOf(dir + '/') === 0))
+      : [];
+    out.rows[name] = { folder, folders, drawn: values.length, outsideFolder: outside };
+  }
+
+  const boxes = tickBoxes();
+  out.offered = boxes.length;
+  out.gazeRows = gazeBoxes().length;
+  /**
+   * What the page's own published state says is selected, and what the core would KEEP from the same list.
+   *
+   * `motions.ticked` is `core.motionIdList(preferences.motions).length` and `motions.stateIds` is the cleaned
+   * list for this state, so a junk id shows up here as a value that is not one of the offered ids — which is the
+   * check that would have caught the `on` entries immediately.
+   */
+  out.tickedBefore = (state().motions || {}).ticked;
+  const offeredIds = boxes.map((box) => box.value);
+  out.offeredIds = offeredIds;
+  out.junkBefore = (((state().motions || {}).stateIds || {}).resting || [])
+    .filter((id) => offeredIds.indexOf(id) === -1);
+
+  // Tick the LAST clip, exactly as the operator did — a real click on a real box.
+  const last = boxes[boxes.length - 1];
+  if (!last) { out.error = 'the state offers no clips'; return JSON.stringify(out); }
+  out.lastId = last.value;
+  out.lastDisabled = last.disabled;
+  if (!last.checked) last.click();
+
+  /**
+   * Wait for the page to republish rather than reading the state straight away.
+   *
+   * The published object is rebuilt on a poll, so reading it immediately after the click answers what the page
+   * looked like a moment AGO — the same trap `probe-parts-editor.js` documents for the 部位 table.
+   */
+  const wanted = offeredIds.length;
+  for (let attempt = 0; attempt < 40; attempt += 1) {
+    const seen = (((state().motions || {}).stateIds || {}).resting || []).length;
+    if (seen >= wanted) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  const after = state().motions || {};
+  out.tickedAfter = after.ticked;
+  out.stateIdsAfter = ((after.stateIds || {}).resting || []).slice();
+  out.junkAfter = out.stateIdsAfter.filter((id) => offeredIds.indexOf(id) === -1);
+  // And the DOM's own answer: a tick that did not stick is what the operator actually saw.
+  const sameBox = tickBoxes().filter((box) => box.value === out.lastId)[0];
+  out.lastStillTicked = Boolean(sameBox && sameBox.checked);
+  out.checkedInDom = tickBoxes().filter((box) => box.checked).map((box) => box.value);
+  return JSON.stringify(out);
+})();

package/desktop/probe-parts-editor.js

@@ -0,0 +1,247 @@
+/**
+ * The 部位 editor's probe: ONE script, evaluated in the settings window by `desktop/main.js`.
+ *
+ * It lives in its own file because it used to be a template literal INSIDE main.js — and a stray backtick in a
+ * comment (twice: once in a comment mentioning a route, once in one mentioning a `<datalist>`) ended that literal
+ * early. The result was not a test failure but a BROKEN LAUNCHER: `main.js` no longer parsed, so the floating
+ * window could not open at all, and the only symptom was an Electron error dialog on the operator's screen. A
+ * plain file cannot be broken that way, and `node --check desktop/probe-parts-editor.js` can prove it parses —
+ * which `scripts/verify-desktop.mjs` now does before it spawns anything.
+ *
+ * It is an EXPRESSION (an immediately-invoked async arrow), so `executeJavaScript` awaits it and hands back the
+ * resolved JSON string.
+ *
+ * Nothing here is asserted: the numbers travel to `scripts/verify-desktop.mjs`, where the suite decides.
+ */
+(async () => {
+  const state = () => globalThis.__VRMPET3D_CONFIG_STATE__ || {};
+  const parts = () => (state().parts || {});
+  const rows = () => Array.from(document.querySelectorAll('#part-body tr:not(.part-detail)'));
+  // COUNTED FROM THE DOM, not from the published state: that state is republished on a poll, so reading it
+  // straight after a click answers what the page looked like a moment AGO — measured as "新增部位 adds a part
+  // (5 -> 5)" while the row it had just added was right there in the table.
+  const out = { labelsBefore: (parts().labels || []).slice() };
+  out.before = rows().length;
+  const add = document.getElementById('part-add');
+  if (!add) { out.error = 'no 新增部位 button'; return JSON.stringify(out); }
+  add.click();
+  out.afterAdd = rows().length;
+  const last = rows()[rows().length - 1];
+  if (!last) { out.error = 'no row after adding'; return JSON.stringify(out); }
+  /**
+   * THE BROWSER PANEL, driven the way the operator complained about.
+   *
+   * The report was "添加结构的下拉框无法滚动，也没有滚动条" — a native input+datalist popup, drawn by Chromium and
+   * impossible to scroll or inspect from here. The panel that replaced it is the page's own DOM, so these are the
+   * things that make it usable: it opens, it is FULL of the model's names, it really scrolls (a scrollTop that
+   * moves, against a box shorter than its content), and clicking a row adds that structure to the part.
+   */
+  const browse = rows()[rows().length - 1].querySelector('.part-browse');
+  if (browse) browse.click();
+  const list = document.getElementById('part-picker-list');
+  const panel = document.getElementById('part-picker');
+  out.pickerOpen = Boolean(panel) && panel.hidden === false;
+  const names = list ? Array.from(list.querySelectorAll('.part-picker-row')) : [];
+  out.pickerRows = names.length;
+  out.pickerSample = names.slice(0, 3).map((row) => row.getAttribute('data-structure'));
+  out.pickerScrollHeight = list ? list.scrollHeight : 0;
+  out.pickerClientHeight = list ? list.clientHeight : 0;
+  if (list) {
+    list.scrollTop = 60;
+    out.pickerScrolledTo = list.scrollTop;
+  }
+  // The filter narrows the list without touching the table beneath it.
+  const filter = document.getElementById('part-picker-filter');
+  if (filter) {
+    filter.value = 'hair';
+    filter.dispatchEvent(new Event('input'));
+    out.pickerFilteredRows = list ? list.querySelectorAll('.part-picker-row').length : 0;
+    filter.value = '';
+    filter.dispatchEvent(new Event('input'));
+  }
+  // And a click on a row is how a structure is added from the browser.
+  const target = list ? list.querySelector('.part-picker-row') : null;
+  out.pickerPicked = target ? target.getAttribute('data-structure') : null;
+  if (target) target.click();
+  out.chipsFromPicker = rows()[rows().length - 1].querySelectorAll('.chip').length;
+  const closePicker = document.getElementById('part-picker-close');
+  if (closePicker) closePicker.click();
+  out.pickerClosed = Boolean(panel) && panel.hidden === true;
+  /**
+   * And 浏览… opens it AGAIN after 关闭. The structure browser keeps its open state in module state and a static
+   * panel, so it has no stale-reference trap to fall into — this is the assertion that says so, right next to the one
+   * that caught it in the expression picker.
+   */
+  const browseAgain = rows()[rows().length - 1].querySelector('.part-browse');
+  if (browseAgain) browseAgain.click();
+  out.pickerReopened = Boolean(panel) && panel.hidden === false;
+  if (closePicker) closePicker.click();
+  out.pickerClosedAgain = Boolean(panel) && panel.hidden === true;
+  // Back to a clean part for the gestures below, which are about the text box and the chips.
+  rows()[rows().length - 1].querySelectorAll('.chip-drop').forEach((drop) => drop.click());
+  const box = rows()[rows().length - 1].querySelector('.part-add-structure');
+  if (!box) { out.error = 'no structure box'; return JSON.stringify(out); }
+  box.value = 'LiuHai';
+  box.dispatchEvent(new Event('change'));
+  let row = rows()[rows().length - 1];
+  const chip = row.querySelector('.chip');
+  out.chip = chip ? chip.firstChild.textContent : null;
+  out.chipHint = chip ? (chip.querySelector('.note') ? chip.querySelector('.note').textContent.trim() : null) : null;
+  out.structures = row.querySelectorAll('.chip').length;
+  const mode = row.querySelector('.chip-mode');
+  out.modeBefore = mode ? mode.textContent : null;
+  if (mode) mode.click();
+  row = rows()[rows().length - 1];
+  const modeAfter = row.querySelector('.chip-mode');
+  out.modeAfter = modeAfter ? modeAfter.textContent : null;
+  const drop = row.querySelector('.chip-drop');
+  if (drop) drop.click();
+  row = rows()[rows().length - 1];
+  out.chipsAfterDrop = row.querySelectorAll('.chip').length;
+  /**
+   * RENAME and DELETE, the other two things the section promises.
+   *
+   * Both go through a full repaint of the table, so every read below re-queries its row: holding one across a
+   * change is what made the first version of this probe report "5 -> 5".
+   */
+  const label = rows()[rows().length - 1].querySelector('.part-label');
+  if (label) {
+    label.value = '刘海';
+    label.dispatchEvent(new Event('change'));
+  }
+  out.renamedLabel = rows()[rows().length - 1].querySelector('.part-label').value;
+  out.pickerHasModelNames = out.pickerSample.some((entry) => /head|hair|arm|tail|eye/i.test(String(entry)));
+  const remove = rows()[rows().length - 1].querySelector('.part-remove');
+  if (remove) remove.click();
+  out.afterDelete = rows().length;
+  out.after = rows().length;
+  out.rowsDrawn = rows().length;
+  out.publishedCount = parts().count;
+
+  /**
+   * THE JUMP — the report this block exists for now: "在部位中勾选或者取消表情时，每次点击都会让页面返回到最上面一条".
+   *
+   * The page is scrolled down, an expression is ticked from a row's dropdown, and the page has to STAY PUT. The
+   * scroll offset is read from `document.scrollingElement` before and after, because the cause was the document
+   * momentarily collapsing when a repaint emptied its `<tbody>` — a fact no assertion about the stored value can
+   * see.
+   *
+   * The menu itself is read back as well: one button per row, the choices inside a bounded scrollable panel, and
+   * no expression checkbox left in the row (`input[data-name]` outside a `.pick-menu` must be zero).
+   */
+  const scroller = document.scrollingElement || document.documentElement;
+  out.pageScrolls = scroller.scrollHeight > scroller.clientHeight + 20;
+  scroller.scrollTop = out.pageScrolls ? 140 : 0;
+  out.scrollBefore = scroller.scrollTop;
+  const pickButton = document.querySelector('#part-body .pick-select');
+  out.pickTriggerBefore = pickButton ? pickButton.textContent : null;
+  if (pickButton) pickButton.click();
+  const menu = document.querySelector('.pick-menu');
+  out.menuOpen = Boolean(menu);
+  out.menuBoxes = menu ? menu.querySelectorAll('input[data-name]').length : 0;
+  out.menuScrolls = menu ? menu.scrollHeight > menu.clientHeight : false;
+  /**
+   * BOUNDED, measured here rather than from the page's published state: the page publishes on its own poll, so a menu
+   * this probe has just opened may not be in that snapshot yet. `scrollHeight > clientHeight` is the wrong question
+   * anyway — it is false on a four-expression model, where the CSS ceiling is still what keeps a twenty-expression
+   * one from growing the row.
+   */
+  const menuStyle = menu && window.getComputedStyle ? window.getComputedStyle(menu) : null;
+  out.menuOverflow = menuStyle ? menuStyle.overflowY : null;
+  out.menuMaxHeight = menuStyle ? menuStyle.maxHeight : null;
+  out.menuBounded = Boolean(menuStyle) && menuStyle.overflowY === 'auto' && /px$/.test(String(menuStyle.maxHeight));
+  out.inlineBoxes = document.querySelectorAll('#emotion-body input[data-name], #part-body input[data-name]').length
+    - out.menuBoxes;
+  const tick = menu ? menu.querySelector('input[data-name]') : null;
+  out.tickedName = tick ? tick.getAttribute('data-name') : null;
+  if (tick) {
+    tick.checked = true;
+    tick.dispatchEvent(new Event('change'));
+  }
+  out.pickTriggerAfter = pickButton ? pickButton.textContent : null;
+  out.scrollAfter = scroller.scrollTop;
+  out.stayedPut = Math.abs(scroller.scrollTop - out.scrollBefore) <= 2;
+
+  /**
+   * AND THE MENU OPENS AGAIN — the reported bug: "选中一个表情后，再点表情的下拉列表就无效了，必须刷新页面重新进".
+   *
+   * Closing removed the panel but left the row's own reference to it, so every later click on that button took the
+   * "close" branch and the row was dead until a repaint (a page reload, since a tick no longer repaints). Three
+   * closings are driven here because they take three different paths out: the trigger itself, Escape, and an outside
+   * pointerdown — an orphaned outside-click listener is the other half of the same defect.
+   */
+  const menuOf = () => document.querySelector('.pick-menu');
+  if (pickButton) pickButton.click();                       // close it the way the user would
+  out.closedByTrigger = !menuOf();
+  if (pickButton) pickButton.click();                       // …and open it again: this is the bug
+  out.reopenedAfterTrigger = Boolean(menuOf());
+  // The rebuilt panel must show the live row, which still has the expression ticked from above.
+  const reopenedBox = menuOf() ? menuOf().querySelector('input[data-name]') : null;
+  out.reopenedTicked = reopenedBox ? reopenedBox.checked : null;
+  document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+  out.closedByEscape = !menuOf();
+  if (pickButton) pickButton.click();
+  out.reopenedAfterEscape = Boolean(menuOf());
+  /**
+   * The away listener is attached a TICK AFTER the menu opens (so the click that opened it is not read as an outside
+   * click), so the outside click has to happen after that tick — dispatching it immediately is the mistake this
+   * block made first, and the three failures that followed were all downstream of it.
+   */
+  await new Promise((resolve) => setTimeout(resolve, 30));
+  document.body.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true }));
+  out.closedByOutside = !menuOf();
+  if (pickButton) pickButton.click();
+  out.reopenedAfterOutside = Boolean(menuOf());
+
+  // Put the row back to 无 so the profile the later checks see is the shipped one, then close the menu.
+  const lastTick = menuOf() ? menuOf().querySelector('input[data-name]') : null;
+  if (lastTick) {
+    lastTick.checked = false;
+    lastTick.dispatchEvent(new Event('change'));
+  }
+  if (pickButton) pickButton.click();
+  out.menuClosedAtEnd = !menuOf();
+  out.pickTriggerRestored = pickButton ? pickButton.textContent : null;
+
+  /**
+   * AND THE SOURCE TAKES THE BUILT-IN VOICE OFF THE 部位 TABLE — the second half of 「如果设置了AI碎碎念，就停止输出内置的
+   * 碎碎念」 (operator, 2026-10-12).
+   *
+   * 胸部 ships answering 变态！/大色狼！ with nothing written in the user's settings, and its box placeholder is what
+   * PROMISES that. The promise is a property of the SOURCE, so a source that is not 内置短语 has to take it away.
+   *
+   * It is driven through the STORE, and that is the honest path for THIS page: the 台词来源 picker lives on the other
+   * settings page (通用设置), so a model page can never see it move — there is no `#pref-speech-source` here to drive.
+   * What this page does see is another document writing the store, which is exactly what its `storage` listener
+   * handles (two open settings windows, or an edit from the app's own panel). The DOM is read back afterwards
+   * because the published state is republished on a poll and would answer what the page looked like a moment ago.
+   *
+   * The store is put back at the end, because a probe must not leave the profile in a state the next suite reads.
+   */
+  const storeKey = (globalThis.__VRMPET3D_CORE__ || {}).STORAGE_KEY || 'dsh.vrmpet3d.v1';
+  const storeBefore = globalThis.localStorage.getItem(storeKey);
+  const openWithSource = (source) => {
+    let stored = {};
+    try { stored = JSON.parse(storeBefore || '{}') || {}; } catch (_error) { stored = {}; }
+    stored.speech = Object.assign({}, stored.speech, { source: source });
+    globalThis.localStorage.setItem(storeKey, JSON.stringify(stored));
+    globalThis.dispatchEvent(new StorageEvent('storage', { key: storeKey }));
+  };
+  const placeholderOf = (label) => {
+    const row = rows().filter((entry) => {
+      const box = entry.querySelector('.part-label');
+      return box && box.value === label;
+    })[0];
+    const detail = row ? row.nextElementSibling : null;
+    const box = detail ? detail.querySelector('.part-lines') : null;
+    return box ? box.placeholder : null;
+  };
+  out.partLinesBuiltin = placeholderOf('胸部');
+  openWithSource('ai');
+  out.partLinesAi = placeholderOf('胸部');
+  if (storeBefore === null) globalThis.localStorage.removeItem(storeKey);
+  else globalThis.localStorage.setItem(storeKey, storeBefore);
+  globalThis.dispatchEvent(new StorageEvent('storage', { key: storeKey }));
+  out.partLinesRestored = placeholderOf('胸部');
+  return JSON.stringify(out);
+})()

package/lib/brotli.js

@@ -0,0 +1,74 @@
+// Brotli decompression for the bundled motion pack's compressed clips.
+//
+// WHY BROTLI, AND WHY NOT LZMA2. The operator's dance clips are large (their first one is 8.0 MB), so the pack
+// stores them compressed and the bytes are unpacked into memory on the way to the renderer. LZMA2 would be
+// about 10% smaller — 46% of the original against brotli's 51% on a real clip — but Node's `zlib` does NOT
+// speak LZMA (measured 2026-10-12: `unzipSync`/`inflateSync`/`gunzipSync` all fail with Z_DATA_ERROR on a file
+// the reference liblzma wrote), and this plugin ships with NO npm dependencies, so LZMA would mean maintaining
+// a hand-written LZMA2 decoder in `lib/xz.js`. That decoder was written and does NOT yet decode real binary
+// content correctly, so it is NOT in this path: a decompressor that returns plausible garbage would hand the
+// renderer a malformed model, which is worse than not supporting the format at all.
+//
+// Brotli, by contrast, is IN Node and in every Chromium the pet runs in. On the operator's own dance clip:
+// 8,080,556 bytes -> 2,836,574 (35%), byte-identical, in about 13 seconds.
+//
+// Node is the only side that needs this file: the HOST unpacks the clip and serves plain VRMA bytes, so the
+// browser half never learns that a clip arrived compressed. See `motionBytesFor` in lib/index.js.
+import { brotliDecompressSync } from 'node:zlib';
+
+/** How large an unpacked clip may be before the host refuses it, as a decompression-bomb guard. */
+export const MOTION_PACK_LIMIT = 512 * 1024 * 1024;
+
+/** The extension a compressed clip carries, appended to the format's own: `x.vrma.br`. */
+export const COMPRESSED_MOTION_EXTENSION = '.br';
+
+/**
+ * The suffix appended WITHOUT a dot, for a caller composing "the compressed twin of this name".
+ *
+ * `COMPRESSED_MOTION_EXTENSION` is what a reader sees in a file name; this is what a catalogue builds to ask
+ * "is there an archive beside this clip?". Keeping both spelled out is what stops one of them drifting into the
+ * other's job — a schedule that appends `.br` here would look for `x.vrma..br`.
+ */
+export const COMPRESSED_SUFFIX = 'br';
+
+/**
+ * Decompress one brotli-compressed clip.
+ *
+ * @param {Buffer|Uint8Array} bytes the file exactly as it sits on disk.
+ * @param {object} [options]
+ * @param {number} [options.limit] most bytes to produce before refusing.
+ * @returns {Buffer} the original bytes.
+ * @throws {Error} with a message a caller can show — never a half-decoded clip.
+ */
+export function decompressBrotli(bytes, options = {}) {
+  const limit = Number.isFinite(options.limit) ? options.limit : MOTION_PACK_LIMIT;
+  if (!bytes || typeof bytes.length !== 'number' || bytes.length === 0) {
+    throw new Error('the compressed clip is empty');
+  }
+  let out;
+  try {
+    out = brotliDecompressSync(bytes, { maxOutputLength: limit });
+  } catch (error) {
+    /**
+     * `maxOutputLength` is what turns a decompression bomb into a refusal rather than an out-of-memory crash,
+     * and Node reports it by code. The message is rewritten because the raw one ("Cannot create a Buffer
+     * larger than...") says nothing about which clip or why.
+     */
+    if (error && error.code === 'ERR_BUFFER_TOO_LARGE') {
+      throw new Error(`the clip unpacks to more than ${limit} bytes`);
+    }
+    throw new Error(`the compressed clip could not be unpacked: ${(error && error.message) || error}`);
+  }
+  return out;
+}
+
+/**
+ * Does this file name describe a brotli-compressed clip?
+ *
+ * Total and cheap, like every other format check in this plugin: the extension decides, and the bytes are
+ * never sniffed to guess. A file whose name says `.br` but whose bytes are not brotli is REFUSED by
+ * `decompressBrotli` with a reason, which is the honest outcome — the alternative is loading it as a model.
+ */
+export function isCompressedMotionName(fileName) {
+  return typeof fileName === 'string' && fileName.toLowerCase().endsWith(COMPRESSED_MOTION_EXTENSION);
+}