人物设定
diff --git a/src/settings.js b/src/settings.js
index 43fb736..8c3fd5c 100644
--- a/src/settings.js
+++ b/src/settings.js
@@ -130,18 +130,25 @@ async function mayLeave() {
}
async function importCharacter(kind) {
- document.querySelector("#import-status").textContent = "";
+ setImportStatus("");
try {
const result = await window.desktopPet.previewCharacterImport(kind);
if (result.cancelled) return;
if (result.error) throw new Error();
importToken = result.token;
document.querySelector("#import-image").src = result.preview;
+ document.querySelector("#import-image").hidden = result.type === "live2d";
document.querySelector("#import-image").alt = result.name;
document.querySelector("#import-name").textContent = result.name;
document.querySelector("#import-description").textContent = result.description;
document.querySelector("#import-preview").hidden = false;
- } catch { document.querySelector("#import-status").textContent = text("settings.importFailed"); }
+ } catch { setImportStatus("settings.importFailed"); }
+}
+
+function setImportStatus(key) {
+ const status = document.querySelector("#import-status");
+ status.dataset.statusKey = key;
+ status.textContent = key ? text(key) : "";
}
const DEFAULT_CUSTOM_BODY = "{\"text\":\"{{text}}\"}";
@@ -281,6 +288,7 @@ function refreshLanguageOptions(selectedValue = "system") {
}
function applyStaticTranslations() {
+ setImportStatus(document.querySelector("#import-status").dataset.statusKey || "");
document.documentElement.lang = activeLanguage;
document.title = text("window.settingsTitle");
document.querySelector("h1").textContent = text("settings.title");
@@ -440,10 +448,15 @@ function renderCharacterCards() {
card.classList.toggle("selected", character.id === selectedCharacterId);
card.setAttribute("aria-pressed", character.id === selectedCharacterId ? "true" : "false");
- const image = document.createElement("img");
- image.src = character.previewPath || character.spritePath || "";
- image.alt = character.name;
- image.loading = "lazy";
+ const image = document.createElement(character.type === "live2d" ? "span" : "img");
+ if (character.type === "live2d") {
+ image.className = "live2d-badge";
+ image.textContent = "Live2D";
+ } else {
+ image.src = character.previewPath || character.spritePath || "";
+ image.alt = character.name;
+ image.loading = "lazy";
+ }
const content = document.createElement("span");
const name = document.createElement("b");
@@ -453,7 +466,7 @@ function renderCharacterCards() {
description.className = "description";
description.textContent = character.description || text("settings.character.noDescription");
meta.className = "meta";
- meta.textContent = text("settings.character.meta", {
+ meta.textContent = character.type === "live2d" ? text("live2d.modelMeta", { count: character.expressions?.length || 0 }) : text("settings.character.meta", {
actions: character.stateCount || 0,
click: character.clickActionCount || 0,
});
@@ -472,6 +485,69 @@ function renderCharacterCards() {
characterGridEl.append(card);
}
document.querySelector("#remove-character").hidden = !activeCharacter.imported;
+ renderLive2D(activeCharacter);
+}
+
+function fillModelExpressions(select, names, value = -1) {
+ select.textContent = "";
+ [text("live2d.neutral"), ...names].forEach((name, index) => {
+ const option = document.createElement("option");
+ option.value = String(index - 1); option.textContent = name; select.append(option);
+ });
+ select.value = String(value);
+}
+
+function fillModelMotions(select, motions, selected = null, optional = false) {
+ select.textContent = "";
+ if (optional) {
+ const option = document.createElement("option");
+ option.value = ""; option.textContent = text("live2d.noMotion"); select.append(option);
+ }
+ for (const [group, count] of Object.entries(motions || {})) {
+ for (let index = 0; index < count; index++) {
+ const option = document.createElement("option");
+ option.value = JSON.stringify({ group, index });
+ option.textContent = `${group || text("live2d.motion")} ${index + 1}`; select.append(option);
+ }
+ }
+ if (optional) select.value = selected && Object.hasOwn(motions || {}, selected.group) && selected.index < motions[selected.group]
+ ? JSON.stringify({ group: selected.group, index: selected.index }) : "";
+}
+
+function selectedReplyMotion(mood) {
+ try { return JSON.parse(document.querySelector(`#live2d-motion-${mood}`).value || "null"); }
+ catch { return null; }
+}
+
+function renderLive2D(character) {
+ document.querySelector("#live2d-panel").hidden = character.type !== "live2d";
+ if (character.type !== "live2d") return;
+ document.querySelector("#live2d-gaze").checked = config.persona?.live2dGaze !== false;
+ document.querySelector("#live2d-idle").checked = config.persona?.live2dIdle !== false;
+ const names = character.expressions || [];
+ fillModelExpressions(document.querySelector("#live2d-expression"), names);
+ for (const kind of ["head", "greet"]) {
+ const touch = config.persona?.live2dTouches?.[kind];
+ const index = touch?.expression ?? -1;
+ fillModelExpressions(document.querySelector(`#live2d-touch-${kind}`), names, index < names.length ? index : -1);
+ fillModelMotions(document.querySelector(`#live2d-motion-touch-${kind}`), character.motions, touch?.motion, true);
+ }
+ for (const mood of ["happy", "shy", "review", "failed"]) {
+ const index = config.persona?.live2dExpressions?.[mood] ?? -1;
+ fillModelExpressions(document.querySelector(`#live2d-${mood}`), names, index < names.length ? index : -1);
+ fillModelMotions(document.querySelector(`#live2d-motion-${mood}`), character.motions, config.persona?.live2dMotions?.[mood], true);
+ }
+ const motionSelect = document.querySelector("#live2d-motion");
+ fillModelMotions(motionSelect, character.motions);
+ document.querySelector("#preview-motion").disabled = !motionSelect.options.length;
+ refreshRuntimeStatus();
+}
+
+async function refreshRuntimeStatus() {
+ try {
+ const state = await window.desktopPet.getLive2DRuntime();
+ document.querySelector("#live2d-runtime-status").textContent = text(state.ready ? "live2d.runtimeReady" : "live2d.runtimeNeeded");
+ } catch { document.querySelector("#live2d-runtime-status").textContent = text("live2d.runtimeFailed"); }
}
function renderConfig(preserveDraft = false) {
@@ -644,6 +720,15 @@ function readConfigForm(includeEmptyKey = false) {
speakingStyle: personaSpeakingStyleEl.value.trim(),
background: personaBackgroundEl.value.trim(),
extraRules: personaExtraRulesEl.value.trim(),
+ live2dGaze: document.querySelector("#live2d-gaze").checked,
+ live2dIdle: document.querySelector("#live2d-idle").checked,
+ live2dTouches: Object.fromEntries(["head", "greet"].map((kind) => [kind, {
+ expression: Number(document.querySelector(`#live2d-touch-${kind}`).value || -1),
+ motion: selectedReplyMotion(`touch-${kind}`),
+ }])),
+ live2dExpressions: Object.fromEntries(["happy", "shy", "review", "failed"].map((mood) =>
+ [mood, Number(document.querySelector(`#live2d-${mood}`).value || -1)])),
+ live2dMotions: Object.fromEntries(["happy", "shy", "review", "failed"].map((mood) => [mood, selectedReplyMotion(mood)])),
};
const affection = {
enabled: affectionEnabledEl.checked,
@@ -901,6 +986,27 @@ window.addEventListener("beforeunload", (event) => {
});
document.querySelector("#import-folder").addEventListener("click", () => importCharacter("folder"));
document.querySelector("#import-zip").addEventListener("click", () => importCharacter("zip"));
+document.querySelector("#import-live2d").addEventListener("click", () => importCharacter("live2d"));
+document.querySelector("#download-core").addEventListener("click", () => window.desktopPet.openLive2DDownload());
+document.querySelector("#import-core").addEventListener("click", async () => {
+ try {
+ const result = await window.desktopPet.importLive2DRuntime();
+ if (result.cancelled) return;
+ if (!result.ok) throw new Error();
+ await refreshRuntimeStatus();
+ } catch { document.querySelector("#live2d-runtime-status").textContent = text("live2d.runtimeFailed"); }
+});
+document.querySelector("#preview-expression").addEventListener("click", async () => {
+ try { await window.desktopPet.performModelAction({ type: "expression", index: Number(document.querySelector("#live2d-expression").value) }); }
+ catch { document.querySelector("#live2d-action-status").textContent = text("live2d.actionFailed"); }
+});
+document.querySelector("#preview-motion").addEventListener("click", async () => {
+ try {
+ const action = JSON.parse(document.querySelector("#live2d-motion").value);
+ const result = await window.desktopPet.performModelAction({ type: "motion", ...action });
+ document.querySelector("#live2d-action-status").textContent = result ? "" : text("live2d.actionFailed");
+ } catch { document.querySelector("#live2d-action-status").textContent = text("live2d.actionFailed"); }
+});
document.querySelector("#cancel-import").addEventListener("click", () => { importToken = null; document.querySelector("#import-preview").hidden = true; });
document.querySelector("#confirm-import").addEventListener("click", async () => {
try {
@@ -908,8 +1014,8 @@ document.querySelector("#confirm-import").addEventListener("click", async () =>
if (!result.ok) throw new Error();
applyChatState(result);
document.querySelector("#import-preview").hidden = true;
- document.querySelector("#import-status").textContent = text("settings.imported");
- } catch { document.querySelector("#import-status").textContent = text("settings.importFailed"); }
+ setImportStatus("settings.imported");
+ } catch { setImportStatus("settings.importFailed"); }
});
document.querySelector("#remove-character").addEventListener("click", async () => {
if (!(await mayLeave())) return;
diff --git a/src/styles.css b/src/styles.css
index 5e36702..f712395 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -30,9 +30,37 @@ body {
cursor: grabbing;
}
+#model-stage {
+ position: absolute;
+ left: 50%;
+ bottom: 0;
+ transform: translateX(-50%);
+ width: var(--pet-width, 192px);
+ height: var(--pet-height, 208px);
+ pointer-events: none;
+}
+#model-stage iframe { width: 100%; height: 100%; border: 0; }
+#model-status {
+ position: absolute;
+ z-index: 2;
+ bottom: 55px;
+ left: 50%;
+ transform: translateX(-50%);
+ width: min(230px, calc(100% - 24px));
+ padding: 12px;
+ border: 1px solid #d8dfe0;
+ border-radius: 6px;
+ background: #fff;
+ color: #315d64;
+ font: 12px/1.5 var(--pet-font);
+ pointer-events: auto;
+ cursor: pointer;
+}
+#model-status[hidden], #model-stage[hidden] { display: none; }
+
#speech-panel {
position: absolute;
- top: 8px;
+ bottom: calc(var(--pet-height, 208px) + 10px);
left: 50%;
width: min(296px, calc(100vw - 18px));
transform: translateX(-50%);
@@ -40,6 +68,7 @@ body {
flex-direction: column;
gap: 6px;
}
+body[data-companion-open="true"] #speech-panel { bottom: calc(var(--pet-height, 208px) + 98px); }
#speech-card {
position: relative;
@@ -64,7 +93,7 @@ body {
text-overflow: ellipsis;
white-space: nowrap;
color: #64716e;
- font: 500 11px/1.2 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+ font: 500 11px/1.2 var(--pet-font);
}
.icon-button {
display: inline-flex;
@@ -91,7 +120,7 @@ body {
min-height: 34px;
padding: 3px 12px 9px;
color: #3d3730;
- font: 500 12.5px/1.35 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+ font: 500 12.5px/1.35 var(--pet-font);
text-align: left;
white-space: pre-wrap;
overflow: auto;
@@ -126,27 +155,59 @@ body {
pointer-events: auto;
}
#last-reply { width: 30px; height: 30px; background: rgba(255, 255, 255, 0.95); border-radius: 6px; }
+#pet-menu { width: 30px; height: 30px; background: rgba(255, 255, 255, 0.95); border: 1px solid rgba(49, 110, 116, 0.25); border-radius: 6px; }
#last-reply:disabled { visibility: hidden; }
#talk {
+ width: 32px;
height: 30px;
padding: 0 10px;
border: 1px solid rgba(49, 110, 116, 0.25);
border-radius: 8px;
background: rgba(255, 255, 255, 0.95);
color: #316e74;
- font: 500 12px/1 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+ font: 500 12px/1 var(--pet-font);
pointer-events: auto;
cursor: pointer;
}
+#companion-input {
+ position: absolute;
+ left: 50%;
+ bottom: calc(var(--pet-height, 208px) + 10px);
+ transform: translateX(-50%);
+ box-sizing: border-box;
+ width: min(296px, calc(100vw - 18px));
+ height: 72px;
+ display: flex;
+ gap: 6px;
+ padding: 8px;
+ border: 1px solid #cbdcda;
+ border-radius: 8px;
+ background: rgba(255, 255, 255, .97);
+ box-shadow: 0 4px 12px #273a3d18;
+ pointer-events: auto;
+}
+#companion-text { flex: 1; min-width: 0; border: 0; background: transparent; resize: none; padding: 3px; color: #293b3d; font: 13px/1.5 var(--pet-font); user-select: text; }
+#companion-text:focus { outline: none; }
+#companion-input:focus-within { border-color: #47877c; }
+.companion-input-actions { display: flex; flex-direction: column; justify-content: space-between; }
+#companion-send { background: #dceee9; }#companion-send img { transform: rotate(180deg); }
+#companion-feedback { position: absolute; bottom: 0; left: 12px; font: 10px/1.4 var(--pet-font); color: #9a434e; }
+#companion-presence { display: flex; gap: 3px; padding: 8px; border-radius: 6px; background: #ffffffed; }
+#companion-presence i { width: 4px; height: 4px; border-radius: 50%; background: #538478; animation: presence 1.5s ease-in-out infinite; }
+#companion-presence i:nth-child(2) { animation-delay: .15s; }#companion-presence i:nth-child(3) { animation-delay: .3s; }
+#companion-stop { background: #fff; width: 30px; height: 30px; }
+@keyframes presence { 0%, 80%, 100% { opacity: .35; } 40% { opacity: 1; } }
+@media (prefers-reduced-motion: reduce) { #companion-presence i { animation: none; } }
+[hidden] { display: none !important; }
#talk:hover { background: #edf6f5; }
#talk:focus-visible { outline: 2px solid #316e74; outline-offset: 2px; }
-.has-voice-controls #speech-bubble { max-height: 78px; }
#voice-controls {
box-sizing: border-box;
- height: 28px;
- padding: 0 4px 0 9px;
+ height: 30px;
border-radius: 6px;
background: rgba(255, 255, 255, 0.95);
pointer-events: auto;
}
+#voice-controls #voice-toggle { min-width: 30px; width: 30px; height: 30px; padding: 4px; border: 0; background: transparent; }
+#voice-controls #voice-status { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
diff --git a/src/voice-controls.css b/src/voice-controls.css
index 801e552..d55858a 100644
--- a/src/voice-controls.css
+++ b/src/voice-controls.css
@@ -5,7 +5,7 @@
gap: 8px;
min-width: 0;
color: #526368;
- font: 12px/1.3 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+ font: 12px/1.3 var(--pet-font);
}
.voice-controls[hidden] { display: none !important; }
.voice-controls span { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
diff --git a/src/voice-controls.js b/src/voice-controls.js
index 5b7d9d2..36cfa53 100644
--- a/src/voice-controls.js
+++ b/src/voice-controls.js
@@ -16,8 +16,11 @@
const wasNearBottom = messages && messages.scrollHeight - messages.scrollTop - messages.clientHeight < 60;
controls.hidden = !voice.enabled || (!active && !voice.canReplay);
document.body.classList.toggle("has-voice-controls", !controls.hidden);
- button.textContent = t(active ? "voice.stop" : "voice.replay");
+ if (controls.dataset.compact === "true") {
+ button.querySelector("img").src = `./icons/${active ? "square" : "volume-2"}.svg`;
+ } else button.textContent = t(active ? "voice.stop" : "voice.replay");
button.title = t(active ? "voice.stop" : "voice.replayTitle");
+ button.setAttribute("aria-label", button.title);
button.disabled = pending || (!active && !voice.canReplay);
status.textContent = t(active ? `voice.${voice.status}` : state.voiceError ? "voice.failed" : "voice.ready");
if (wasNearBottom) messages.scrollTop = messages.scrollHeight;
diff --git a/tests/bubble-controls.test.js b/tests/bubble-controls.test.js
index 1e0ebaf..7ce206d 100644
--- a/tests/bubble-controls.test.js
+++ b/tests/bubble-controls.test.js
@@ -78,11 +78,12 @@ test("mouse focus does not keep an unpinned reply open after the pointer leaves"
test("reply, history and recall controls are separate and labels are translated", () => {
const calls = [];
- const pet = loadPet({ openQuickChatWindow: () => calls.push("quick"), openChatWindow: () => calls.push("history"), showLastReply: () => calls.push("recall") });
+ const pet = loadPet({ openChatWindow: () => calls.push("history"), showLastReply: () => calls.push("recall") });
+ pet.context.window.DesktopPetCompanionInput = { open: () => calls.push("inline") };
assert.equal(pet.bubble.events.click, undefined);
for (const language of ["en-US", "zh-CN", "ja-JP"]) {
pet.run(`activeLanguage = ${JSON.stringify(language)}; updateBubbleControls()`);
- for (const id of ["bubble-reply", "bubble-history", "bubble-pin", "bubble-dismiss", "last-reply"]) {
+ for (const id of ["bubble-reply", "bubble-history", "bubble-pin", "bubble-dismiss", "last-reply", "pet-menu"]) {
const node = pet.nodes.get(`#${id}`);
assert.ok(node.title);
assert.doesNotMatch(node.title, /pet\./);
@@ -90,7 +91,19 @@ test("reply, history and recall controls are separate and labels are translated"
}
}
for (const id of ["bubble-reply", "bubble-history", "last-reply"]) pet.nodes.get(`#${id}`).events.click();
- assert.deepEqual(calls, ["quick", "history", "recall"]);
+ assert.deepEqual(calls, ["inline", "history", "recall"]);
+});
+
+test("the visible pet menu opens once without changing expressions or conversation state", () => {
+ let opened = 0;
+ const pet = loadPet({ showContextMenu: () => opened++ });
+ for (const type of ["sprite", "live2d"]) {
+ pet.run(`character = {...character, type:${JSON.stringify(type)}}; settings.expressionMode="clickOnly"`);
+ const before = pet.run('JSON.stringify({state,frameIndex,clickExpressionIndex,conversationActive})');
+ pet.nodes.get("#pet-menu").events.click();
+ assert.equal(pet.run('JSON.stringify({state,frameIndex,clickExpressionIndex,conversationActive})'), before);
+ }
+ assert.equal(opened, 2);
});
test("an old initial state cannot reenable recall during a newer request", async () => {
diff --git a/tests/chat-continuity.test.js b/tests/chat-continuity.test.js
index 801c23c..817a28b 100644
--- a/tests/chat-continuity.test.js
+++ b/tests/chat-continuity.test.js
@@ -37,13 +37,14 @@ test("draft edit broadcasts are bounded and acknowledge the originating composer
app.run(`globalThis.sent = []; globalThis.sender = {send:(topic,state)=>sent.push({topic,state})};
chatWindow = {isDestroyed:()=>false,webContents:sender};
quickChatWindow = {isDestroyed:()=>false,webContents:{send:(topic,state)=>sent.push({topic,state})}};
- mainWindow = {webContents:{send:()=>sent.push("pet")}};
+ mainWindow = {isDestroyed:()=>false,webContents:{send:(topic,state)=>sent.push({topic,state})}};
setChatDraft({sender},{characterId:"default",revision:0,text:"x".repeat(1500),edit:1});`);
- assert.equal(app.run("sent.length"), 2);
+ assert.equal(app.run("sent.length"), 3);
assert.equal(app.run("sent[0].state.text.length"), 1200);
assert.equal(app.run("sent[0].topic"), "chat-draft-updated");
- assert.equal(app.run("sent[0].state.acknowledgedEdit"), 1);
- assert.equal(app.run("sent[1].state.acknowledgedEdit"), undefined);
+ assert.equal(app.run("sent[0].state.acknowledgedEdit"), undefined);
+ assert.equal(app.run("sent[1].state.acknowledgedEdit"), 1);
+ assert.equal(app.run("sent[2].state.acknowledgedEdit"), undefined);
});
for (const file of files) {
diff --git a/tests/companion-input.test.js b/tests/companion-input.test.js
new file mode 100644
index 0000000..2d5416f
--- /dev/null
+++ b/tests/companion-input.test.js
@@ -0,0 +1,77 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { loadRenderer, loadMain } = require("./helpers");
+const flush = () => new Promise(resolve => setImmediate(resolve));
+const state = (text = "", characterId = "default", revision = 0) => ({
+ revision, draft: { text, characterId, revision, version: 0 }, character: { id: characterId, name: "Character" }, history: [],
+});
+function setup(api = {}) {
+ let receive;
+ const ui = loadRenderer("companion-input.js", {
+ setCompanionInputOpen: async open => open,
+ onChatStateUpdated: callback => { receive = callback; }, ...api,
+ }, "index.html");
+ return { ...ui, receive, input: ui.nodes.get("#companion-text"),
+ submit: () => ui.nodes.get("#companion-input").events.submit({ preventDefault() {} }) };
+}
+
+test("inline composer submits once, folds away, and restores failed drafts without stealing focus", async () => {
+ let finish, requests = 0;
+ const ui = setup({ sendChatMessage: () => { requests++; return new Promise(resolve => { finish = resolve; }); } });
+ ui.receive(state("A quiet evening"));
+ await ui.run("window.DesktopPetCompanionInput.open()");
+ assert.equal(ui.context.document.body.dataset.companionOpen, "true");
+ ui.submit(); ui.submit();
+ assert.equal(requests, 1);
+ assert.equal(ui.nodes.get("#companion-input").hidden, true);
+ assert.equal(ui.context.document.body.dataset.companionOpen, "false");
+ assert.equal(ui.input.value, "");
+ finish({ ok: false, revision: 0 }); await flush();
+ assert.equal(ui.input.value, "A quiet evening");
+ assert.equal(ui.nodes.get("#companion-input").hidden, true);
+});
+
+test("closing keeps a draft, while IME Enter and Shift+Enter never submit", async () => {
+ let requests = 0;
+ const ui = setup({ sendChatMessage: () => { requests++; } });
+ ui.receive(state("Unsent"));
+ await ui.run("window.DesktopPetCompanionInput.open()");
+ ui.input.events.keydown({ key: "Enter", isComposing: true });
+ ui.input.events.keydown({ key: "Enter", keyCode: 229 });
+ ui.input.events.keydown({ key: "Enter", shiftKey: true });
+ ui.input.events.keydown({ key: "Escape", preventDefault() {} });
+ assert.equal(requests, 0);
+ assert.equal(ui.input.value, "Unsent");
+ assert.equal(ui.nodes.get("#companion-input").hidden, true);
+});
+
+test("late request failures cannot replace another character's inline draft", async () => {
+ let reject;
+ const ui = setup({ sendChatMessage: () => new Promise((_, fail) => { reject = fail; }) });
+ ui.receive(state("Old")); ui.submit();
+ ui.receive(state("New character draft", "luna", 1));
+ reject(new Error("closed")); await flush();
+ assert.equal(ui.input.value, "New character draft");
+});
+
+test("opening attention and pending speech follow live state without additional requests", async () => {
+ const ui = setup();
+ ui.receive(state());
+ await ui.run("window.DesktopPetCompanionInput.open()");
+ assert.equal(ui.context.document.body.dataset.companionState, "attentive");
+ ui.receive({ ...state(), busy: true });
+ assert.equal(ui.context.document.body.dataset.companionState, "thinking");
+ assert.equal(ui.nodes.get("#companion-stop").hidden, false);
+ ui.receive({ ...state(), voice: { status: "playing" } });
+ assert.equal(ui.context.document.body.dataset.companionState, "speaking");
+ ui.receive(state());
+ assert.equal(ui.context.document.body.dataset.companionState, "attentive");
+});
+
+test("inline layout reserves input space without changing stored pet scale", () => {
+ const app = loadMain();
+ const before = app.run("displaySize().height");
+ app.run("companionInputOpen = true");
+ assert.equal(app.run("displaySize().height"), before + 88);
+ assert.equal(app.run("settings.scale"), 1);
+});
diff --git a/tests/electron-smoke.cjs b/tests/electron-smoke.cjs
index 260b625..fb36f5e 100644
--- a/tests/electron-smoke.cjs
+++ b/tests/electron-smoke.cjs
@@ -5,10 +5,11 @@ const os = require("node:os");
const path = require("node:path");
const http = require("node:http");
const { spawn } = require("node:child_process");
-const { restorePlacement } = require("../src/window-placement");
+const appRoot = process.env.PET_SMOKE_APP || path.join(__dirname, "..");
+const { restorePlacement } = require(path.join(appRoot, "src/window-placement"));
const dataDir = process.env.PET_SMOKE_DATA || fs.mkdtempSync(path.join(os.tmpdir(), "desktop-pet-smoke-"));
-const screenshots = path.join(__dirname, "../out/smoke");
+const screenshots = path.join(__dirname, process.env.PET_SMOKE_APP ? "../out/smoke-packaged" : "../out/smoke");
app.setPath("userData", dataDir);
app.disableHardwareAcceleration();
@@ -66,6 +67,16 @@ const server = http.createServer((req, res) => {
});
const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function menuFromButton(pet) {
+ const original = Menu.prototype.popup;
+ let menu;
+ Menu.prototype.popup = function (options) { assert.equal(options.window, pet); menu = this; };
+ try {
+ await evaluate(pet, () => document.querySelector("#pet-menu").click());
+ await until(() => menu, "visible pet menu");
+ return menu;
+ } finally { Menu.prototype.popup = original; }
+}
async function until(check, label, timeout = 15000) {
const deadline = Date.now() + timeout;
while (Date.now() < deadline) {
@@ -89,19 +100,20 @@ async function findWindow(file) {
return window;
}
async function screenshot(window, name) {
+ await evaluate(window, () => document.fonts.ready.then(() => true));
fs.mkdirSync(screenshots, { recursive: true });
fs.writeFileSync(path.join(screenshots, `${name}.png`), (await window.webContents.capturePage()).toPNG());
}
async function run() {
if (process.env.PET_SMOKE_PHASE === "second-instance") {
- require("../src/main.js");
+ require(path.join(appRoot, "src/main.js"));
assert.equal(app.hasSingleInstanceLock(), false, "A second instance acquired the profile lock");
// Quit may finish after ready on Linux; the parent verifies the natural exit.
await new Promise((resolve, reject) => setTimeout(() => reject(new Error("Second instance did not quit")), 5000));
}
if (process.env.PET_SMOKE_PHASE === "restart") {
- require("../src/main.js");
+ require(path.join(appRoot, "src/main.js"));
await app.whenReady();
const pet = await findWindow("index.html");
const placement = JSON.parse(fs.readFileSync(path.join(dataDir, "window-placement.json"), "utf8"));
@@ -144,15 +156,34 @@ async function run() {
console.log("Electron restart PASS: position and saved settings restored; confirmed quit exits without saving discarded edits.");
} catch (error) { console.error(error); app.exit(1); }
});
- app.quit();
+ (await menuFromButton(pet)).items.find(item => item.accelerator === "CommandOrControl+Q").click();
await new Promise((resolve, reject) => setTimeout(() => reject(new Error("Confirmed quit did not exit")), 5000));
}
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
- require("../src/main.js");
+ require(path.join(appRoot, "src/main.js"));
await app.whenReady();
const pet = await findWindow("index.html");
const settings = await findWindow("settings.html");
+ for (const window of [pet, settings]) {
+ const loaded = await evaluate(window, async () => {
+ const results = [];
+ for (const [family, text] of [["Desktop Pet CJK SC", "角色对话"], ["Desktop Pet CJK JP", "会話かなカナ"]]) {
+ const faces = await document.fonts.load(`16px "${family}"`, text);
+ results.push(faces.length > 0 && faces.every(face => face.status === "loaded"));
+ }
+ return results;
+ });
+ assert.deepEqual(loaded, [true, true], "Bundled CJK fonts must load under the page CSP");
+ }
const endpoint = `http://127.0.0.1:${server.address().port}`;
+ const petMenu = await menuFromButton(pet);
+ assert.ok(petMenu.items.some(item => item.accelerator === "CommandOrControl+Q"));
+ assert.equal(await evaluate(pet, () => {
+ const button = document.querySelector("#pet-menu");
+ const rect = button.getBoundingClientRect();
+ return button.getAttribute("aria-haspopup") === "menu" && !!button.title && rect.right <= innerWidth
+ && button.contains(document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2));
+ }), true);
assert.ok(Menu.getApplicationMenu().items.some((item) => item.role?.toLowerCase() === "editmenu"));
const savedClipboard = clipboard.availableFormats().map((format) => [format, clipboard.readBuffer(format)]);
try {
@@ -275,7 +306,7 @@ async function run() {
});
await until(() => evaluate(chat, async () => (await window.desktopPet.getChatState()).config.memory.notes.length === 1), "memory ready for restart");
- await evaluate(pet, () => document.querySelector("#talk").click());
+ await evaluate(pet, () => window.desktopPet.openQuickChatWindow());
let quick = await findWindow("quick-chat.html");
assert.equal(await evaluate(quick, () => document.querySelector("#character-name").textContent), "Test Character");
const draftText = "An unsent thought\nA second line";
@@ -310,7 +341,7 @@ async function run() {
const beforeQuick = quick.getBounds();
pet.setPosition(originalPetBounds.x - 100, originalPetBounds.y - 40);
await until(() => quick.getBounds().x !== beforeQuick.x, "companion input follows pet");
- const expectedQuick = require("../src/companion-layout").companionBounds(pet.getBounds(), screen.getDisplayMatching(pet.getBounds()).workArea);
+ const expectedQuick = require(path.join(appRoot, "src/companion-layout")).companionBounds(pet.getBounds(), screen.getDisplayMatching(pet.getBounds()).workArea);
assert.deepEqual(quick.getBounds(), expectedQuick);
pet.setBounds(originalPetBounds);
const recovery = Menu.getApplicationMenu().getMenuItemById("show-pet");
@@ -331,7 +362,7 @@ async function run() {
return bounds.x >= area.x && bounds.y >= area.y && bounds.x + bounds.width <= area.x + area.width && bounds.y + bounds.height <= area.y + area.height;
}, "recover pet after display change");
await delay(400);
- assert.deepEqual(quick.getBounds(), require("../src/companion-layout").companionBounds(pet.getBounds(), screen.getDisplayMatching(pet.getBounds()).workArea));
+ assert.deepEqual(quick.getBounds(), require(path.join(appRoot, "src/companion-layout")).companionBounds(pet.getBounds(), screen.getDisplayMatching(pet.getBounds()).workArea));
assert.deepEqual((await evaluate(pet, () => window.desktopPet.getChatState())).history, profileBeforeRecovery.history);
const recoveredChat = chat.getBounds();
const recoveredArea = screen.getDisplayMatching(recoveredChat).workArea;
@@ -443,7 +474,8 @@ async function run() {
await evaluate(pet, () => document.querySelector("#bubble-history").click());
await until(() => chat.isVisible(), "bubble opens history");
await evaluate(pet, () => document.querySelector("#bubble-reply").click());
- await until(() => quick.isVisible(), "bubble opens quick reply");
+ await until(() => evaluate(pet, () => !document.querySelector("#companion-input").hidden), "bubble opens inline reply");
+ await evaluate(pet, () => document.querySelector("#companion-close").click());
const beforeRecallRequests = requests.length;
const beforeRecallHistory = (await evaluate(pet, () => window.desktopPet.getChatState())).history;
await evaluate(pet, () => document.querySelector("#bubble-dismiss").click());
@@ -561,7 +593,7 @@ async function run() {
assert.equal(await evaluate(pet, () => bubbleVisible), true);
for (const window of [pet, chat, quick]) {
assert.equal(await evaluate(window, () => document.querySelector("#voice-controls").hidden), false);
- assert.equal(await evaluate(window, () => document.querySelector("#voice-toggle").textContent), "Replay");
+ assert.equal(await evaluate(window, () => document.querySelector("#voice-toggle").getAttribute("aria-label")), "Read the latest reply again with the current voice service");
}
const beforeReplay = requests.length;
await evaluate(quick, () => { document.querySelector("#voice-toggle").click(); document.querySelector("#voice-toggle").click(); });
@@ -745,7 +777,7 @@ async function run() {
let leavePrompts = 0;
dialog.showMessageBox = async () => { leavePrompts++; return { response: 0 }; };
await evaluate(settings, () => { document.querySelector("#persona-name").value = "Unsaved name"; });
- app.quit();
+ (await menuFromButton(pet)).items.find(item => item.accelerator === "CommandOrControl+Q").click();
await until(() => leavePrompts === 1, "confirm before quitting with unsaved settings");
await delay(300);
for (const window of [pet, settings, chat, quick]) assert.equal(window.isDestroyed(), false, "Cancelling quit keeps every window alive");
diff --git a/tests/font-assets.test.js b/tests/font-assets.test.js
new file mode 100644
index 0000000..1cfa26c
--- /dev/null
+++ b/tests/font-assets.test.js
@@ -0,0 +1,31 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const { createHash } = require("node:crypto");
+const root = path.join(__dirname, "..");
+
+test("bundled CJK fonts match the unmodified upstream files and retain their license", () => {
+ for (const [file, expected] of [
+ ["NotoSansSC-Regular.otf", "fc0fda9394367c16c1af7555a2ae4d5e2e6a6f02"],
+ ["NotoSansJP-Regular.otf", "4af556abb9cc42e585aab777b01857246a110746"],
+ ]) {
+ const data = fs.readFileSync(path.join(root, "assets/fonts", file));
+ assert.equal(data.subarray(0, 4).toString(), "OTTO");
+ const blob = createHash("sha1").update(`blob ${data.length}\0`).update(data).digest("hex");
+ assert.equal(blob, expected, file);
+ }
+ assert.match(fs.readFileSync(path.join(root, "assets/fonts/OFL.txt"), "utf8"), /SIL OPEN FONT LICENSE Version 1\.1/);
+});
+
+test("every user-facing window loads local fallback fonts under a self-only font policy", () => {
+ for (const page of ["index", "chat", "quick-chat", "settings"]) {
+ const html = fs.readFileSync(path.join(root, `src/${page}.html`), "utf8");
+ assert.match(html, /href="\.\/fonts\.css"/);
+ assert.match(html, /font-src 'self';/);
+ }
+ const css = fs.readFileSync(path.join(root, "src/fonts.css"), "utf8");
+ assert.match(css, /:root:lang\(ja\)/);
+ assert.equal((css.match(/url\("\.\.\/assets\/fonts\/NotoSans(?:SC|JP)-Regular\.otf"\)/g) || []).length, 2);
+ assert.doesNotMatch(css, /https?:/);
+});
diff --git a/tests/helpers.js b/tests/helpers.js
index a967867..e9d2fe3 100644
--- a/tests/helpers.js
+++ b/tests/helpers.js
@@ -62,7 +62,10 @@ function loadRenderer(file, api = {}, htmlFile = file.replace(/\.js$/, ".html"))
children: [], append(...children) { this.children.push(...children); }, replaceChildren(...children) { this.children = children; },
focus() {}, blur() {}, remove() {}, setAttribute() {}, classList: { toggle() {}, add() {}, remove() {} },
querySelector() { return element(); },
- addEventListener(name, callback) { this.events[name] = callback; },
+ addEventListener(name, callback) {
+ const previous = this.events[name];
+ this.events[name] = previous ? (...args) => { previous(...args); return callback(...args); } : callback;
+ },
};
}
const document = {
@@ -79,17 +82,17 @@ function loadRenderer(file, api = {}, htmlFile = file.replace(/\.js$/, ".html"))
createElement: element,
};
const context = vm.createContext({
- document, console, Intl, Date,
+ document, console, Intl, Date, Event,
window: {
DesktopPetI18n: i18n,
DesktopPetValidation: require("../src/config-validation"),
DesktopPetLlmPresets: require("../src/llm-presets"),
- addEventListener() {}, close() {},
+ addEventListener() {}, dispatchEvent() {}, close() {},
desktopPet: { getChatState: () => new Promise(() => {}), onChatStateUpdated() {},
setChatDraft() {}, onChatDraftUpdated() {}, onAppQuitRequested() {}, confirmAppQuit() {}, ...api },
},
});
- if (["chat.js", "quick-chat.js"].includes(file)) {
+ if (["chat.js", "quick-chat.js", "companion-input.js"].includes(file)) {
vm.runInContext(fs.readFileSync(path.join(sourceDir, "chat-draft.js"), "utf8"), context);
}
vm.runInContext(fs.readFileSync(path.join(sourceDir, file), "utf8"), context);
diff --git a/tests/live2d-boot.cjs b/tests/live2d-boot.cjs
new file mode 100644
index 0000000..f5f91b8
--- /dev/null
+++ b/tests/live2d-boot.cjs
@@ -0,0 +1,5 @@
+const { app } = require("electron");
+const path = require("node:path");
+if (!process.env.PET_TEST_DATA) throw new Error("Isolated test data required");
+app.setPath("userData", process.env.PET_TEST_DATA);
+require(path.join(process.env.PET_SMOKE_APP || path.join(__dirname, ".."), "src/main.js"));
diff --git a/tests/live2d-bridge.test.js b/tests/live2d-bridge.test.js
new file mode 100644
index 0000000..c681dc9
--- /dev/null
+++ b/tests/live2d-bridge.test.js
@@ -0,0 +1,84 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+
+function setup() {
+ const events = {};
+ const sent = [];
+ const stage = { replaceChildren() {} };
+ const status = { addEventListener() {} };
+ const frame = { setAttribute() {}, remove() {}, contentWindow: { postMessage: message => sent.push(message) } };
+ let resume;
+ let connections = 0;
+ const context = vm.createContext({
+ document: { querySelector: selector => selector === "#model-stage" ? stage : status, createElement: () => frame },
+ window: { DesktopPetI18n: { t: key => key }, addEventListener: (event, callback) => { events[event] = callback; },
+ desktopPet: { getLive2DRuntime: async () => ({ ready: true }), onModelAction: callback => { events.action = callback; } } },
+ setTimeout: () => 0, clearTimeout() {}, setInterval: () => 0, clearInterval() {},
+ AudioContext: class {
+ resume() { return new Promise(resolve => { resume = resolve; }); }
+ createMediaElementSource() { connections++; return { connect() {}, disconnect() {} }; }
+ createAnalyser() { return { connect() {}, disconnect() {} }; }
+ },
+ });
+ vm.runInContext(fs.readFileSync(path.join(__dirname, "../src/live2d-bridge.js"), "utf8"), context);
+ return { api: context.window.DesktopPetModel, sent, events, connections: () => connections,
+ resume: () => resume(),
+ message: (type, extra = {}) => events.message({ source: frame.contentWindow, origin: "pet-live2d://viewer", data: { channel: "desktop-pet-model", type, ...extra } }) };
+}
+
+test("model readiness replays only the latest expression and current attention", async () => {
+ const ui = setup();
+ await ui.api.apply({ id: "sample", type: "live2d" }, { expressionMode: "automatic" });
+ ui.api.expression(1); ui.api.expression(4); ui.api.presence("thinking"); ui.api.cycle();
+ assert.equal(ui.sent.length, 0);
+ ui.message("boot"); ui.message("loaded");
+ assert.deepEqual(ui.sent.map(message => message.type), ["load", "options", "expression", "presence"]);
+ assert.equal(ui.sent.find(message => message.type === "expression").index, 4);
+ assert.equal(ui.sent.at(-1).state, "thinking");
+});
+
+test("hit queries accept only known regions and are cancelled on replacement or character switch", async () => {
+ const ui = setup();
+ await ui.api.apply({ id: "sample", type: "live2d" }, { expressionMode: "automatic" });
+ ui.message("boot"); ui.message("loaded");
+ let first = ui.api.locate(0.5, 0.2);
+ ui.message("location", { request: ui.sent.at(-1).request, kind: "head" });
+ assert.equal(await first, "head");
+ first = ui.api.locate(0.5, 0.2);
+ const second = ui.api.locate(0.5, 0.8);
+ assert.equal(await first, null);
+ ui.message("location", { request: ui.sent.at(-1).request, kind: "unknown" });
+ assert.equal(await second, null);
+ const pending = ui.api.locate(0.5, 0.2);
+ await ui.api.apply({ id: "sprite" }, {});
+ assert.equal(await pending, null);
+});
+
+test("drag interruption and quiet-idle settings survive ordinary state broadcasts", async () => {
+ const ui = setup();
+ const character = { id: "sample", type: "live2d" };
+ const settings = { expressionMode: "automatic", persona: { live2dIdle: false, live2dTouches: { head: { expression: 1 } } } };
+ await ui.api.apply(character, settings); ui.message("boot"); ui.message("loaded");
+ ui.api.dragging(true);
+ await ui.api.apply(character, settings);
+ assert.equal(ui.sent.at(-1).dragging, true);
+ assert.equal(ui.sent.at(-1).idle, false);
+ assert.equal(ui.sent.at(-1).touches.head.expression, 1);
+ ui.api.dragging(false);
+ assert.equal(ui.sent.at(-1).dragging, false);
+});
+
+test("stopping or switching characters during audio resume cannot reconnect old speech", async () => {
+ for (const switchCharacter of [false, true]) {
+ const ui = setup();
+ await ui.api.apply({ id: "sample", type: "live2d" }, { expressionMode: "automatic" });
+ const pending = ui.api.attachAudio({ paused: false });
+ if (switchCharacter) await ui.api.apply({ id: "sprite" }, {});
+ else ui.api.stopMouth();
+ ui.resume(); await pending;
+ assert.equal(ui.connections(), 0);
+ }
+});
diff --git a/tests/live2d-host.test.js b/tests/live2d-host.test.js
new file mode 100644
index 0000000..8d434ce
--- /dev/null
+++ b/tests/live2d-host.test.js
@@ -0,0 +1,45 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { createModelHandler, installCore, runtimeReady } = require("../src/live2d-host");
+
+test("model protocol serves only the active model's declared nonexecutable resources", async (t) => {
+ const userData = fs.mkdtempSync(path.join(os.tmpdir(), "pet-protocol-test-"));
+ t.after(() => fs.rmSync(userData, { recursive: true, force: true }));
+ const id = "imported-012345678901234567890123";
+ let active = { id, type: "live2d" };
+ const root = path.join(userData, "characters", id);
+ fs.mkdirSync(root, { recursive: true });
+ fs.writeFileSync(path.join(root, "character.json"), JSON.stringify({ resources: ["model.model3.json", "loader.js", "linked.json"] }));
+ fs.writeFileSync(path.join(root, "model.model3.json"), "{}");
+ fs.writeFileSync(path.join(root, "loader.js"), "alert('no')");
+ fs.writeFileSync(path.join(userData, "settings.json"), "private fixture");
+ fs.symlinkSync(path.join(userData, "settings.json"), path.join(root, "linked.json"));
+ const handler = createModelHandler({ userData, sourceDir: path.join(__dirname, "../src"), getActiveCharacter: () => active });
+ const request = (suffix, method = "GET") => handler({ url: `pet-live2d://viewer${suffix}`, method });
+ const valid = request(`/models/${id}/model.model3.json`);
+ assert.equal(valid.status, 200);
+ assert.equal(await valid.text(), "{}");
+ assert.match(valid.headers.get("Content-Security-Policy"), /connect-src 'self'/);
+ for (const suffix of [`/models/${id}/loader.js`, `/models/${id}/linked.json`, `/models/${id}/character.json`,
+ `/models/${id}/../settings.json`, `/models/${id}/%252e%252e/settings.json`, "/settings.json", "/index.html?token=private", "/core.js"]) {
+ const result = request(suffix);
+ assert.equal(result.status, 404, suffix);
+ assert.equal(await result.text(), "Unavailable");
+ }
+ assert.equal(request("/index.html", "POST").status, 404);
+ active = { id: "default", type: "sprite" };
+ assert.equal(request(`/models/${id}/model.model3.json`).status, 404);
+ assert.equal(request("/index.html").status, 200);
+});
+
+test("unknown runtime JavaScript is never installed or served", (t) => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "pet-core-test-"));
+ t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+ const source = path.join(root, "anything.js");
+ fs.writeFileSync(source, "console.log('untrusted')");
+ assert.throws(() => installCore(source, root), /unrecognized_runtime/);
+ assert.equal(runtimeReady(root), false);
+});
diff --git a/tests/live2d-import.test.js b/tests/live2d-import.test.js
new file mode 100644
index 0000000..d10ea05
--- /dev/null
+++ b/tests/live2d-import.test.js
@@ -0,0 +1,95 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { zipSync } = require("fflate");
+const { readLive2DPack, installLive2DPack, resourceName } = require("../src/live2d-import");
+const png = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aX1sAAAAASUVORK5CYII=", "base64");
+
+function fixture(t, change = () => {}) {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "pet-model-test-"));
+ t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+ const raw = { Version: 3, FileReferences: {
+ Moc: "sample.moc3", Textures: ["textures/skin.png"],
+ Expressions: [{ Name: "Smile", File: "smile.exp3.json" }],
+ Motions: { Idle: [{ File: "rest.motion3.json", Sound: "private.wav" }] },
+ }, Groups: [{ Target: "Parameter", Name: "LipSync", Ids: ["ParamMouthOpenY"] }], url: "https://example.invalid/tracker" };
+ change(raw);
+ const moc = Buffer.alloc(64); moc.write("MOC3");
+ const files = { "sample.model3.json": Buffer.from(JSON.stringify(raw)), "sample.moc3": moc,
+ "textures/skin.png": png, "smile.exp3.json": Buffer.from('{"Parameters":[]}'),
+ "rest.motion3.json": Buffer.from('{"Version":3,"Curves":[]}'), "private.wav": Buffer.from("unused") };
+ for (const [name, bytes] of Object.entries(files)) {
+ const target = path.join(root, name); fs.mkdirSync(path.dirname(target), { recursive: true }); fs.writeFileSync(target, bytes);
+ }
+ return { root, files };
+}
+
+test("Live2D folder, selected model and wrapped ZIP install the same bounded resource graph", (t) => {
+ const { root, files } = fixture(t);
+ const pack = readLive2DPack(root);
+ const zipPath = path.join(root, "model.zip");
+ fs.writeFileSync(zipPath, zipSync(Object.fromEntries(Object.entries(files).map(([key, bytes]) => [`Model/${key}`, bytes]))));
+ assert.deepEqual(readLive2DPack(zipPath), pack);
+ assert.deepEqual(readLive2DPack(path.join(root, "sample.model3.json")), pack);
+ assert.equal(pack.manifest.type, "live2d");
+ assert.deepEqual(pack.manifest.expressions, ["Smile"]);
+ const model = JSON.parse(pack.files["model.model3.json"]);
+ assert.equal(model.url, undefined);
+ assert.equal(model.FileReferences.Motions.Idle[0].Sound, undefined);
+ assert.equal(pack.files["private.wav"], undefined);
+ installLive2DPack(pack, path.join(root, "installed"));
+ installLive2DPack(pack, path.join(root, "installed"));
+ assert.ok(fs.existsSync(path.join(root, "installed", pack.manifest.id, "textures/skin.png")));
+});
+
+for (const unsafe of ["../key.json", "/key.json", "https://example.invalid/a.png", "file:///key.json", "a\\b.png", "a/%2e%2e/b.png", "a.png?token=1", "CON.png", "a./b.png", "a//b.png"]) {
+ test(`Live2D rejects nonportable or escaping resource ${unsafe}`, () => assert.throws(() => resourceName(unsafe)));
+}
+for (const [label, change] of [
+ ["remote texture", (raw) => { raw.FileReferences.Textures = ["https://example.invalid/x.png"]; }],
+ ["executable reference", (raw) => { raw.FileReferences.Moc = "loader.js"; }],
+ ["too many textures", (raw) => { raw.FileReferences.Textures = Array(9).fill("textures/skin.png"); }],
+ ["invalid version", (raw) => { raw.Version = 2; }],
+]) test(`Live2D rejects ${label}`, (t) => assert.throws(() => readLive2DPack(fixture(t, change).root)));
+
+test("Live2D rejects missing resources, symlinked directories and malformed PNGs", (t) => {
+ const { root } = fixture(t);
+ assert.throws(() => readLive2DPack(root, () => false), /image_decode_failed/);
+ fs.renameSync(path.join(root, "textures"), path.join(root, "real-textures"));
+ fs.symlinkSync(path.join(root, "real-textures"), path.join(root, "textures"), "junction");
+ assert.throws(() => readLive2DPack(root), /symlink/);
+ fs.unlinkSync(path.join(root, "textures"));
+ assert.throws(() => readLive2DPack(root));
+});
+
+test("native hit areas survive import with unique names and no unrelated metadata", (t) => {
+ const { root } = fixture(t, raw => { raw.HitAreas = [
+ { Id: "HitAreaHead", Name: "", url: "https://example.invalid" },
+ { Id: "HitAreaBody", Name: "" }, { Id: "Hair", Name: "Head" }, { Id: "Hair2", Name: "Head" },
+ { Id: "Hands", Name: "__proto__" },
+ ]; });
+ const areas = JSON.parse(readLive2DPack(root).files["model.model3.json"]).HitAreas;
+ assert.equal(areas.length, 5);
+ assert.equal(new Set(areas.map(area => area.Name)).size, 5);
+ assert.equal(areas[0].Name, "HitAreaHead 1");
+ assert.equal(areas[1].Name, "HitAreaBody 2");
+ assert.equal(areas[0].url, undefined);
+ assert.equal(areas.some(area => area.Name === "__proto__"), false);
+});
+
+test("malformed or unbounded hit areas are rejected", t => {
+ for (const areas of [null, {}, [null], [{ Id: "" }], [{ Id: "x".repeat(129) }], Array(65).fill({ Id: "Head" })]) {
+ assert.throws(() => readLive2DPack(fixture(t, raw => { raw.HitAreas = areas; }).root), /invalid_hit_areas/);
+ }
+});
+
+test("Live2D ZIP rejects ambiguous models, traversal and case-colliding paths", (t) => {
+ const { root, files } = fixture(t);
+ const target = path.join(root, "bad.zip");
+ for (const extra of [{ "second.model3.json": files["sample.model3.json"] }, { "../secret.json": Buffer.from("{}") }, { "textures/SKIN.png": png }]) {
+ fs.writeFileSync(target, zipSync({ ...files, ...extra }));
+ assert.throws(() => readLive2DPack(target));
+ }
+});
diff --git a/tests/live2d-rig.test.js b/tests/live2d-rig.test.js
new file mode 100644
index 0000000..1612d59
--- /dev/null
+++ b/tests/live2d-rig.test.js
@@ -0,0 +1,20 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { configure } = require("../src/live2d/rig");
+test("legacy exported models use their actual parameter IDs for gaze and breathing", () => {
+ const params = [{ parameterId: "ParamAngleX", peak: 15 }, { parameterId: "ParamBreath", peak: .5 }];
+ const internal = { coreModel: { getModel: () => ({ parameters: { ids: ["PARAM_ANGLE_X", "PARAM_BREATH"] } }) },
+ breath: { getParameters: () => params } };
+ configure(internal);
+ assert.equal(internal.idParamAngleX, "PARAM_ANGLE_X");
+ assert.equal(params[0].parameterId, "PARAM_ANGLE_X");
+ assert.equal(params[0].peak, 6.75);
+ assert.equal(params[1].parameterId, "PARAM_BREATH");
+ assert.equal(params[1].peak, .5);
+});
+test("modern parameter IDs take precedence when both conventions exist", () => {
+ const internal = { coreModel: { getModel: () => ({ parameters: { ids: ["ParamAngleX", "PARAM_ANGLE_X"] } }) }, breath: { getParameters: () => [] } };
+ const { resolve } = configure(internal);
+ assert.equal(resolve("ParamAngleX"), "ParamAngleX");
+ assert.equal(resolve("Missing"), "Missing");
+});
diff --git a/tests/live2d-runtime.test.js b/tests/live2d-runtime.test.js
new file mode 100644
index 0000000..75d8c64
--- /dev/null
+++ b/tests/live2d-runtime.test.js
@@ -0,0 +1,128 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const { createHash } = require("node:crypto");
+const { loadMain, loadRenderer } = require("./helpers");
+const { loadPet } = require("./pet-helpers");
+
+test("vendored display bundles match the pinned upstream releases and omit Core/models", () => {
+ for (const [name, hash] of Object.entries({
+ "pixi.min.js": "403f2f2ee8145fa17f60c5c89403056efe2680e5096ec2762036486914ed19c5",
+ "cubism4.min.js": "af1267e6d52759b245766c578d905bfa025b532d5c3cc727c370957c4409e21b",
+ })) {
+ assert.equal(createHash("sha256").update(fs.readFileSync(path.join(__dirname, "../src/live2d/vendor", name))).digest("hex"), hash);
+ }
+ assert.equal(fs.readdirSync(path.join(__dirname, "../src/live2d/vendor")).some((name) => /core|\.moc3$|\.png$/i.test(name)), false);
+});
+
+test("model expression mappings and gaze normalize without enabling affection or voice", () => {
+ const app = loadMain();
+ const state = app.run('normalizeSettings({persona:{live2dGaze:false,live2dExpressions:{happy:0,shy:63,review:64,failed:"1"}}})');
+ assert.equal(state.persona.live2dGaze, false);
+ assert.deepEqual(JSON.parse(JSON.stringify(state.persona.live2dExpressions)), { happy: 0, shy: 63, review: -1, failed: -1 });
+ assert.equal(state.affection.enabled, false);
+ assert.equal(state.tts.enabled, false);
+});
+
+test("Live2D click-only advances once without scheduling sprite actions or network calls", () => {
+ const pet = loadPet();
+ pet.run(`globalThis.modelCalls=[]; window.DesktopPetModel={apply(){},expression(){},stopMouth(){},busy(){},dragging(){},cycle(){modelCalls.push("cycle")}};
+ applyAppState({settings:{expressionMode:"clickOnly"},activeCharacter:{id:"imported-fixture",type:"live2d",states:{idle:{row:0,frames:1,interval:1000}}}});
+ handleClick(); handleDoubleClick(); handleLongPress(); scheduleIdleBehavior();`);
+ assert.deepEqual(JSON.parse(pet.run('JSON.stringify(modelCalls)')), ["cycle"]);
+});
+
+test("slow double-clicks advance once even when pointer events have no click count", () => {
+ const pet = loadPet();
+ pet.run(`globalThis.cycles=0; window.DesktopPetModel={dragging(){},cycle(){cycles++}};
+ character={...character,type:"live2d"}; settings.expressionMode="clickOnly";`);
+ for (const detail of [1, 2]) {
+ pet.run('clickOnlyReadyAt=0; beginDrag({button:0,clientX:96,clientY:100,screenX:100,screenY:100})');
+ pet.events.mousedown({ detail });
+ pet.run('endDrag({detail:0})');
+ }
+ assert.equal(pet.run('cycles'), 1);
+});
+
+test("touch mappings validate indices, preserve motion group names, and keep quiet idle optional", () => {
+ const app = loadMain();
+ const persona = app.run(`normalizeSettings({persona:{live2dIdle:false,live2dTouches:{
+ head:{expression:0,motion:{group:"",index:0}},greet:{expression:64,motion:{group:"Tap",index:-1}}
+ }}}).persona`);
+ assert.equal(persona.live2dIdle, false);
+ assert.deepEqual(JSON.parse(JSON.stringify(persona.live2dTouches)), {
+ head: { expression: 0, motion: { group: "", index: 0 } }, greet: { expression: -1, motion: null },
+ });
+ assert.equal(app.run('normalizeSettings({}).persona.live2dIdle'), true);
+});
+
+test("a delayed hit test cannot trigger a touch after dragging, mode changes or focus loss", async () => {
+ for (const interrupt of ['cancelDrag()', 'settings.expressionMode="clickOnly"', 'dragStart={}']) {
+ const pet = loadPet();
+ pet.run(`globalThis.touches=[]; window.DesktopPetModel={dragging(){},locate(){return new Promise(resolve=>globalThis.resolveHit=resolve)},touch(kind){touches.push(kind)}};
+ character={...character,type:"live2d"}; scheduleSingleClick("greet",{x:0.5,y:0.2});`);
+ pet.fireTimer(pet.run('clickTimer'));
+ pet.run(interrupt);
+ pet.run('resolveHit("head")');
+ await new Promise(resolve => setImmediate(resolve));
+ assert.equal(pet.run('touches.length'), 0);
+ }
+});
+
+test("native head hits select head responses and transparent hits do nothing", async () => {
+ for (const hit of ["head", "greet", null]) {
+ const pet = loadPet();
+ pet.context.hit = hit;
+ pet.run(`globalThis.touches=[]; window.DesktopPetModel={locate:async()=>hit,touch(kind){touches.push(kind)}};
+ character={...character,type:"live2d"}; scheduleSingleClick("greet",{x:0.5,y:0.2});`);
+ pet.fireTimer(pet.run('clickTimer'));
+ await new Promise(resolve => setImmediate(resolve));
+ assert.deepEqual(JSON.parse(pet.run('JSON.stringify(touches)')), hit ? [hit] : []);
+ }
+});
+
+test("import feedback follows settings language changes", () => {
+ const ui = loadRenderer("settings.js");
+ ui.run('setImportStatus("settings.imported"); activeLanguage="en-US"; applyStaticTranslations()');
+ assert.match(ui.nodes.get("#import-status").textContent, /Character/);
+ ui.run('activeLanguage="ja-JP"; applyStaticTranslations()');
+ assert.equal(ui.nodes.get("#import-status").textContent, require("../src/i18n").t("settings.imported", {}, "ja-JP"));
+});
+
+test("partner touch phrases are opt-in, local and leave affection unchanged", () => {
+ const pet = loadPet();
+ pet.run('settings.persona = {relationship:"partner"}; settings.userName="Alex"; respondToInteraction("head")');
+ assert.match(pet.run('speechBubble.textContent'), /Alex/);
+ assert.equal(pet.run('speechBubble.textContent.includes("pet.interaction.")'), false);
+});
+
+test("reply gesture mappings are optional, normalized, and checked against the active model", () => {
+ const app = loadMain();
+ app.run(`settings = normalizeSettings({persona:{live2dMotions:{happy:{group:"Tap",index:1},shy:{group:"",index:0},review:{group:"Tap",index:-1},failed:{group:"Tap",index:256}}}});
+ getCharacterPack = () => ({type:"live2d",motions:{Tap:2,"":1}});`);
+ assert.equal(app.run('replyMotionFor("happy").index'), 1);
+ assert.equal(app.run('replyMotionFor("shy").group'), "");
+ assert.equal(app.run('replyMotionFor("review")'), null);
+ assert.equal(app.run('replyMotionFor("failed")'), null);
+ app.run('getCharacterPack = () => ({type:"live2d",motions:{Tap:1}})');
+ assert.equal(app.run('replyMotionFor("happy")'), null);
+ app.run('settings.expressionMode = "clickOnly"');
+ assert.equal(app.run('replyMotionFor("shy")'), null);
+ assert.equal(app.run('normalizeSettings({}).persona.live2dMotions.happy'), null);
+});
+
+test("completed replies trigger one gesture, never one per stream chunk or replay", () => {
+ const pet = loadPet();
+ pet.run(`globalThis.gestures=[]; window.DesktopPetModel={busy(){},stopMouth(){},expression(){},replyMotion(value){gestures.push(value)}};
+ character={...character,type:"live2d"}; settings.expressionMode="automatic";
+ globalThis.reply={source:"chat",action:"happy",text:"Hello",presentationId:1,replyMotion:{group:"Tap",index:0},speak:false};
+ handlePetMessage({...reply,streaming:true}); handlePetMessage({...reply,streaming:true});`);
+ assert.equal(pet.run('gestures.length'), 0);
+ pet.run('handlePetMessage(reply); handlePetMessage(reply)');
+ assert.equal(pet.run('gestures.length'), 1);
+ pet.run('handlePetMessage({...reply,presentationId:2,replyMotion:null})');
+ assert.equal(pet.run('gestures.length'), 1);
+ pet.run('settings.expressionMode="clickOnly"; handlePetMessage({...reply,presentationId:3})');
+ assert.equal(pet.run('gestures.length'), 1);
+});
diff --git a/tests/live2d-smoke.cjs b/tests/live2d-smoke.cjs
new file mode 100644
index 0000000..bc75c3d
--- /dev/null
+++ b/tests/live2d-smoke.cjs
@@ -0,0 +1,339 @@
+const { _electron } = require("playwright");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const assert = require("node:assert/strict");
+const http = require("node:http");
+const { poll } = require("./poll.cjs");
+const project = path.join(__dirname, "..");
+const data = fs.mkdtempSync(path.join(os.tmpdir(), "pet-live2d-smoke-"));
+const output = path.join(project, "out/playwright/live2d");
+const env = { ...process.env, PET_TEST_DATA: data };
+delete env.ELECTRON_RUN_AS_NODE;
+const modelPath = process.env.PET_MODEL_FIXTURE;
+const corePath = process.env.PET_CORE_FIXTURE;
+if (!modelPath || !corePath) throw new Error("PET_MODEL_FIXTURE and PET_CORE_FIXTURE required; no model is bundled");
+
+const wav = Buffer.alloc(44 + 8000 * 2 * 5);
+wav.write("RIFF"); wav.writeUInt32LE(wav.length - 8, 4); wav.write("WAVEfmt ", 8);
+wav.writeUInt32LE(16, 16); wav.writeUInt16LE(1, 20); wav.writeUInt16LE(1, 22);
+wav.writeUInt32LE(8000, 24); wav.writeUInt32LE(16000, 28); wav.writeUInt16LE(2, 32); wav.writeUInt16LE(16, 34);
+wav.write("data", 36); wav.writeUInt32LE(wav.length - 44, 40);
+for (let i = 0; i < (wav.length - 44) / 2; i++) wav.writeInt16LE(Math.round(Math.sin(i / 8000 * Math.PI * 440) * 6000), 44 + i * 2);
+let requests = 0;
+const server = http.createServer((req, res) => {
+ let body = "";
+ req.on("data", chunk => { body += chunk; }); req.on("end", () => {
+ if (req.url === "/tts") { res.writeHead(200, { "content-type": "audio/wav" }); res.end(wav); }
+ else {
+ requests++;
+ const message = JSON.parse(body).messages.at(-1).content;
+ if (message === "fail") { res.writeHead(503); res.end("Test service unavailable"); return; }
+ const timer = setTimeout(() => {
+ res.writeHead(200, { "content-type": "application/json" });
+ res.end(JSON.stringify({ choices: [{ message: { content: "[expression:happy] It's good to see you. Sit beside me for a little while." } }] }));
+ }, message === "cancel" ? 2000 : 500);
+ res.on("close", () => clearTimeout(timer));
+ }
+ });
+});
+
+async function run() {
+ await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+ const endpoint = `http://127.0.0.1:${server.address().port}`;
+ const app = await _electron.launch({ executablePath: require("electron"), args: [path.join(__dirname, "live2d-boot.cjs")], env });
+ const errors = [];
+ app.on("window", (page) => {
+ page.on("pageerror", (error) => errors.push(error.message));
+ page.on("console", (entry) => { if (entry.type() === "error") console.log("Renderer:", entry.text()); });
+ });
+ const find = async (file) => {
+ for (let i = 0; i < 150; i++) {
+ const page = app.windows().find((item) => item.url().endsWith(`/${file}`));
+ if (page) { await page.waitForLoadState(); return page; }
+ await new Promise((resolve) => setTimeout(resolve, 50));
+ }
+ throw new Error(`Window missing: ${file}`);
+ };
+ try {
+ fs.mkdirSync(output, { recursive: true });
+ const pet = await find("index.html");
+ const settings = await find("settings.html");
+ await app.evaluate(({ dialog }, file) => { dialog.showOpenDialog = async () => ({ canceled: false, filePaths: [file] }); }, modelPath);
+ await settings.locator("#import-live2d").click();
+ await settings.locator("#import-preview").waitFor({ state: "visible" });
+ await settings.locator("#confirm-import").click();
+ const id = await settings.evaluate(async () => (await window.desktopPet.getChatState()).characters.find((item) => item.type === "live2d").id);
+ await settings.evaluate((id) => window.desktopPet.saveChatConfig({ characterId: id, language: "en-US", persona: { setupDone: true } }), id);
+ await pet.waitForFunction(() => document.querySelector("#model-status").textContent.includes("not installed"));
+ await app.evaluate(({ dialog }, file) => { dialog.showOpenDialog = async () => ({ canceled: false, filePaths: [file] }); }, corePath);
+ await settings.locator("#import-core").click();
+ await pet.waitForFunction(() => document.querySelector("#model-status").hidden, null, { timeout: 30000 });
+ const frame = pet.frames().find((item) => item.url().startsWith("pet-live2d:"));
+ assert.ok(frame, "isolated model frame");
+ assert.equal(await frame.evaluate(() => typeof window.desktopPet), "undefined");
+ assert.equal(await frame.evaluate(() => typeof window.require), "undefined");
+ await app.evaluate(({ Menu }) => {
+ globalThis.originalMenuPopup = Menu.prototype.popup;
+ Menu.prototype.popup = function () { globalThis.petMenu = this; };
+ });
+ try {
+ await pet.locator("#pet-menu").click();
+ await poll(() => app.evaluate(() => !!globalThis.petMenu), { label: "Live2D pet menu" });
+ assert.equal(await app.evaluate(() => petMenu.items.some(item => item.accelerator === "CommandOrControl+Q")), true);
+ await app.evaluate(() => petMenu.items.flatMap(item => item.submenu?.items || []).find(item => item.label === "Full Chat").click());
+ const menuChat = await find("chat.html");
+ assert.equal(await menuChat.locator("#message-input").isVisible(), true);
+ await menuChat.close();
+ await app.evaluate(() => petMenu.items.flatMap(item => item.submenu?.items || []).find(item => item.label === "Chat Settings").click());
+ assert.equal(await settings.locator("#tab-character").isVisible(), true);
+ } finally {
+ await app.evaluate(({ Menu }) => { Menu.prototype.popup = globalThis.originalMenuPopup; });
+ }
+ await frame.evaluate(() => {
+ window.modelCommands = [];
+ window.addEventListener("message", event => { if (event.data?.channel === "desktop-pet-model") modelCommands.push(event.data.type); });
+ const original = PIXI.live2d.Live2DModel.from;
+ PIXI.live2d.Live2DModel.from = async (...args) => { window.testModel = await original.apply(PIXI.live2d.Live2DModel, args); return window.testModel; };
+ });
+ await pet.evaluate((id) => {
+ document.querySelector("iframe").contentWindow.postMessage({ channel: "desktop-pet-model", type: "load", id }, "pet-live2d://viewer");
+ window.modelEvents = [];
+ window.expressionSources = [];
+ window.pointerEvents = [];
+ for (const type of ["pointerdown", "mousedown", "pointerup", "mouseup", "click", "dblclick"]) {
+ document.querySelector("#pet").addEventListener(type, event => pointerEvents.push({ type, detail: event.detail, time: Math.round(performance.now()) }));
+ }
+ const originalExpression = window.DesktopPetModel.expression;
+ window.DesktopPetModel.expression = index => {
+ expressionSources.push({ index, stack: new Error().stack.split("\n").slice(1, 5).map(line => line.replace(/file:\/\/[^)]+\//g, "")) });
+ originalExpression(index);
+ };
+ window.addEventListener("message", (event) => { if (event.data?.channel === "desktop-pet-model") modelEvents.push(event.data); });
+ }, id);
+ await frame.waitForFunction(() => window.testModel?.internalModel);
+ await frame.evaluate(() => testModel.internalModel.on("beforeModelUpdate", () => {
+ const core = testModel.internalModel.coreModel;
+ const ids = core.getModel().parameters.ids;
+ const pick = (...names) => names.find(name => ids.includes(name));
+ window.testParameters = { eye: core.getParameterValueById(pick("ParamEyeLOpen", "PARAM_EYE_L_OPEN")),
+ breath: core.getParameterValueById(pick("ParamBreath", "PARAM_BREATH")),
+ x: core.getParameterValueById(pick("ParamAngleX", "PARAM_ANGLE_X")),
+ mouth: core.getParameterValueById(testModel.internalModel.settings.getLipSyncParameters()[0]) };
+ window.testBlinkMinimum = Math.min(window.testBlinkMinimum ?? 1, testParameters.eye);
+ }));
+ const stats = () => frame.evaluate(() => {
+ const canvas = document.querySelector("canvas");
+ const gl = canvas.getContext("webgl2") || canvas.getContext("webgl");
+ const pixels = new Uint8Array(canvas.width * canvas.height * 4);
+ gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+ let visible = 0;
+ for (let i = 3; i < pixels.length; i += 4) if (pixels[i] > 10) visible++;
+ return { visible, ...window.testParameters };
+ });
+ await pet.waitForTimeout(500);
+ assert.ok((await stats()).visible > 1000);
+ const sampled = [];
+ for (let i = 0; i < 50; i++) { sampled.push(await stats()); await pet.waitForTimeout(100); }
+ console.log("Model parameters", { first: sampled[0], last: sampled.at(-1), eyeRange: [Math.min(...sampled.map((s) => s.eye)), Math.max(...sampled.map((s) => s.eye))], breathRange: [Math.min(...sampled.map((s) => s.breath)), Math.max(...sampled.map((s) => s.breath))] });
+ await frame.waitForFunction(() => window.testBlinkMinimum < 0.2, null, { timeout: 12000 });
+ assert.ok(Math.max(...sampled.map((s) => s.breath)) - Math.min(...sampled.map((s) => s.breath)) > 0.1, "native breathing");
+ await pet.evaluate(() => window.desktopPet.setSettings({ expressionMode: "clickOnly", scale: 2 }));
+ await pet.waitForTimeout(600);
+ const before = await pet.evaluate(() => modelEvents.filter((item) => item.type === "expression").length);
+ await pet.locator("#pet").click();
+ await pet.waitForTimeout(800);
+ const after = await pet.evaluate(() => modelEvents.filter((item) => item.type === "expression"));
+ assert.equal(after.length, before + 1, "one click, one expression");
+ assert.equal(after.at(-1).index, 0);
+ await pet.waitForTimeout(1200);
+ const heldExpressions = await pet.evaluate(() => modelEvents.filter(item => item.type === "expression"));
+ assert.equal(heldExpressions.length, after.length, JSON.stringify({ heldExpressions, commands: await frame.evaluate(() => modelCommands), sources: await pet.evaluate(() => expressionSources) }));
+ await pet.locator("#pet").dblclick();
+ await pet.waitForTimeout(600);
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "expression").length), after.length + 1, "double-click adds no second expression");
+ const slowClickBox = await pet.locator("#pet").boundingBox();
+ const slowClickX = slowClickBox.x + slowClickBox.width / 2;
+ const slowClickY = slowClickBox.y + slowClickBox.height / 2;
+ await pet.mouse.move(slowClickX, slowClickY);
+ await pet.mouse.down({ clickCount: 1 }); await pet.mouse.up({ clickCount: 1 });
+ await pet.waitForTimeout(320);
+ await pet.mouse.down({ clickCount: 2 }); await pet.mouse.up({ clickCount: 2 });
+ await pet.waitForTimeout(600);
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "expression").length), after.length + 2,
+ JSON.stringify({ reason: "slow double-click adds no second expression either", events: await pet.evaluate(() => pointerEvents), expressions: await pet.evaluate(() => modelEvents.filter(item => item.type === "expression")), sources: await pet.evaluate(() => expressionSources) }));
+ const manualBeforeHold = await pet.evaluate(() => modelEvents.filter(item => item.type === "expression").length);
+ await pet.mouse.down(); await pet.waitForTimeout(650); await pet.mouse.up();
+ await pet.waitForTimeout(400);
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "expression").length), manualBeforeHold, "long hold never advances manual expressions");
+ assert.equal(await pet.evaluate(() => settings.scale), 2, "double-click and hold never resize the pet");
+ await app.evaluate(({ screen }) => {
+ globalThis.testCursor = { x: 300, y: 300 };
+ globalThis.originalCursorReader = screen.getCursorScreenPoint;
+ screen.getCursorScreenPoint = () => globalThis.testCursor;
+ });
+ try {
+ await pet.mouse.down();
+ await pet.waitForTimeout(50);
+ await app.evaluate(() => { globalThis.testCursor = { x: 320, y: 320 }; });
+ await pet.waitForFunction(() => didDrag === true);
+ await pet.mouse.up();
+ await pet.waitForFunction(() => dragStart === null && didDrag === false);
+ await pet.waitForTimeout(350);
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "expression").length), manualBeforeHold, "manual dragging preserves the selected native expression");
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "touch").length), 0, "dragging never turns into a tap");
+ } finally {
+ await app.evaluate(({ screen }) => { screen.getCursorScreenPoint = globalThis.originalCursorReader; });
+ }
+ await pet.screenshot({ path: path.join(output, "model-manual-200.png") });
+ await pet.evaluate(() => window.desktopPet.setSettings({ expressionMode: "automatic", scale: 0.75 }));
+ await pet.waitForTimeout(600);
+ const bounds = await pet.locator("#pet").boundingBox();
+ await pet.mouse.move(bounds.x + bounds.width * 0.95, bounds.y + bounds.height * 0.25);
+ await pet.waitForTimeout(800);
+ assert.ok(Math.abs((await stats()).x) > 0.5, "gaze follows pointer");
+ assert.ok(await frame.evaluate(() => testModel.internalModel.focusController.x > 0.1), "pointer input reaches the gaze controller");
+ assert.ok((await stats()).visible > 1000);
+ await pet.screenshot({ path: path.join(output, "model-automatic-75.png") });
+ await settings.locator("#live2d-expression").selectOption("2");
+ await settings.locator("#preview-expression").click();
+ await pet.waitForFunction(() => modelEvents.filter((item) => item.type === "expression").at(-1)?.index === 2);
+ await settings.screenshot({ path: path.join(output, "settings-live2d.png") });
+ await settings.locator("#preview-motion").click();
+ await pet.waitForFunction(() => modelEvents.some((item) => item.type === "motion"));
+ await settings.locator("#live2d-happy").selectOption("1");
+ const replyMotion = await settings.locator("#live2d-motion-happy").evaluate(select => {
+ const options = [...select.options].filter(option => option.value);
+ return (options.find(option => !/^idle$/i.test(JSON.parse(option.value).group)) || options[0]).value;
+ });
+ await settings.locator("#live2d-motion-happy").selectOption(replyMotion);
+ await settings.locator("#live2d-motion-happy").scrollIntoViewIfNeeded();
+ await settings.screenshot({ path: path.join(output, "settings-reply-gestures.png") });
+ await settings.locator("#save-settings").click();
+ await pet.waitForFunction(() => settings.persona.live2dExpressions.happy === 1);
+ await settings.locator("#live2d-idle").uncheck();
+ await settings.locator("#live2d-gaze").uncheck();
+ await settings.locator("#live2d-touch-head").selectOption("0");
+ await settings.locator("#live2d-touch-greet").selectOption("2");
+ await settings.locator("#save-settings").click();
+ await pet.waitForFunction(() => settings.persona.live2dIdle === false && settings.persona.live2dTouches.head.expression === 0);
+ await settings.locator("#live2d-touch-head").scrollIntoViewIfNeeded();
+ await settings.screenshot({ path: path.join(output, "settings-touch-responses.png") });
+ await pet.evaluate(() => { dismissBubble(); window.DesktopPetModel.expression(-1); });
+ await pet.waitForTimeout(600);
+ // Probe the same isolated bridge used by pointer events, including models with no hit areas.
+ const touchPoints = await pet.evaluate(async () => {
+ const points = {};
+ for (const y of [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]) {
+ for (const x of [0.5, 0.4, 0.6]) {
+ const kind = await window.DesktopPetModel.locate(x, y);
+ if (kind && !points[kind]) points[kind] = { x, y };
+ }
+ }
+ return points;
+ });
+ assert.ok(touchPoints.head && touchPoints.greet, "head and body hit regions are reachable");
+ const clickPoint = async point => {
+ const box = await pet.locator("#pet").boundingBox();
+ await pet.locator("#pet").click({ position: { x: point.x * box.width, y: point.y * box.height } });
+ };
+ await clickPoint(touchPoints.head);
+ await pet.waitForFunction(() => modelEvents.filter(item => item.type === "touch").at(-1)?.kind === "head");
+ await pet.waitForFunction(() => modelEvents.filter(item => item.type === "expression").at(-1)?.index === 0);
+ await pet.screenshot({ path: path.join(output, "head-pat.png") });
+ await clickPoint(touchPoints.head);
+ await pet.waitForTimeout(350);
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "touch").length), 1, "rapid pats never stack");
+ await pet.waitForFunction(() => modelEvents.filter(item => item.type === "expression").at(-1)?.index === -1);
+ await pet.waitForTimeout(400);
+ await clickPoint(touchPoints.greet);
+ await pet.waitForFunction(() => modelEvents.filter(item => item.type === "touch").at(-1)?.kind === "greet");
+ await pet.waitForFunction(() => modelEvents.filter(item => item.type === "expression").at(-1)?.index === 2);
+ await pet.locator("#talk").click();
+ await pet.waitForFunction(() => modelEvents.filter(item => item.type === "expression").at(-1)?.index === -1);
+ await pet.locator("#companion-close").click();
+ await pet.waitForTimeout(2400);
+ await clickPoint({ x: 0.001, y: 0.001 });
+ await pet.waitForTimeout(450);
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "touch").length), 2, "empty corners do not trigger interaction");
+ assert.equal(requests, 0, "touch interactions never call the LLM");
+ for (const language of ["ja-JP", "zh-CN", "en-US"]) {
+ await settings.evaluate(language => window.desktopPet.saveChatConfig({ language }), language);
+ await settings.waitForFunction(language => document.documentElement.lang === language, language);
+ await settings.locator("#live2d-motion-touch-greet").scrollIntoViewIfNeeded();
+ assert.equal(await settings.locator("#live2d-touch-head").inputValue(), "0");
+ assert.equal(await settings.locator("#live2d-touch-greet").inputValue(), "2");
+ assert.equal(await settings.locator("#live2d-idle").isChecked(), false);
+ assert.equal(await settings.evaluate(() => document.documentElement.scrollWidth > innerWidth), false);
+ await settings.screenshot({ path: path.join(output, `touch-settings-${language}.png`) });
+ }
+ await settings.evaluate((endpoint) => window.desktopPet.saveChatConfig({
+ assistant: { baseUrl: `${endpoint}/v1`, model: "local-test", stream: false },
+ tts: { enabled: true, provider: "custom", endpoint: `${endpoint}/tts`, customBodyTemplate: '{"text":"{{text}}"}' },
+ persona: { relationship: "partner", userName: "Alex" },
+ }), endpoint);
+ await pet.locator("#talk").click();
+ await pet.locator("#companion-text").fill("Stay with me a little.");
+ await pet.locator("#companion-text").press("Escape");
+ await pet.locator("#talk").click();
+ assert.equal(await pet.locator("#companion-text").inputValue(), "Stay with me a little.");
+ await pet.screenshot({ path: path.join(output, "inline-composer.png") });
+ const layout = await pet.evaluate(() => {
+ const input = document.querySelector("#companion-input").getBoundingClientRect();
+ const model = document.querySelector("#model-stage").getBoundingClientRect();
+ const bubble = document.querySelector("#speech-panel").getBoundingClientRect();
+ return { gap: model.top - input.bottom, bubbleGap: input.top - bubble.bottom };
+ });
+ assert.ok(layout.gap >= 8 && layout.bubbleGap >= 0, "composer, bubble and model never overlap");
+ await pet.locator("#companion-send").click();
+ await pet.waitForFunction(() => document.querySelector("#companion-input").hidden);
+ assert.equal(app.windows().some(page => page.url().endsWith("/quick-chat.html")), false, "no detached conversation window");
+ await pet.waitForFunction(() => speechActive && activeAudio && !activeAudio.paused);
+ await pet.waitForFunction(() => modelEvents.filter((item) => item.type === "expression").at(-1)?.index === 1);
+ await frame.waitForFunction(() => window.testParameters.mouth > 0.3);
+ await poll(() => pet.evaluate(async () => (await window.desktopPet.getChatState()).voice.status === "playing"), { label: "playing voice" });
+ await pet.waitForFunction(() => modelEvents.filter(item => item.type === "motion").length === 2);
+ await pet.screenshot({ path: path.join(output, "model-speaking.png") });
+ assert.equal(await pet.locator("#voice-toggle img").evaluate(img => img.complete && img.naturalWidth > 0 && img.src.endsWith("/square.svg")), true);
+ await pet.locator("#voice-toggle").click();
+ await frame.waitForFunction(() => window.testParameters.mouth < 0.03);
+ await pet.waitForFunction(() => document.querySelector("#voice-toggle img").src.endsWith("/volume-2.svg"));
+ assert.equal(await pet.locator("#voice-toggle img").evaluate(img => img.complete && img.naturalWidth > 0), true);
+ assert.equal(requests, 1);
+ assert.equal(await pet.evaluate(() => {
+ const bubble = document.querySelector("#speech-panel").getBoundingClientRect();
+ const model = document.querySelector("#model-stage").getBoundingClientRect();
+ return bubble.bottom <= model.top;
+ }), true, "reply does not cover model");
+ await pet.locator("#talk").click();
+ await pet.locator("#companion-text").fill("fail");
+ await pet.locator("#companion-send").click();
+ await pet.waitForFunction(() => document.querySelector("#companion-text").value === "fail");
+ assert.equal(await pet.evaluate(() => modelEvents.filter(item => item.type === "motion").length), 2, "failed requests never trigger reply gestures");
+ assert.equal(await pet.locator("#companion-input").isHidden(), true, "failure does not steal focus");
+ await pet.locator("#talk").click();
+ await pet.locator("#companion-text").fill("cancel");
+ await pet.locator("#companion-send").click();
+ await pet.locator("#companion-stop").click();
+ await poll(() => pet.evaluate(async () => !(await window.desktopPet.getChatState()).busy), { label: "cancelled request" });
+ await pet.waitForTimeout(2200);
+ assert.equal(await pet.evaluate(() => bubbleVisible), false, "cancelled reply cannot return later");
+ await pet.locator("#talk").click();
+ await pet.locator("#companion-text").fill("Unsent companion thought");
+ await pet.evaluate(() => window.desktopPet.openChatWindow());
+ const chat = await find("chat.html");
+ await chat.waitForFunction(() => document.querySelector("#message-input").value === "Unsent companion thought");
+ await pet.locator("#companion-close").click();
+ await pet.evaluate(() => window.desktopPet.setSettings({ characterId: "luna" }));
+ await pet.waitForFunction(() => !document.querySelector("iframe") && spriteImage && character.id === "luna");
+ assert.equal(await pet.evaluate(() => ctx.getImageData(0, 0, 768, 832).data.some((value, index) => index % 4 === 3 && value > 0)), true);
+ assert.deepEqual(errors, []);
+ console.log("PASS: native sample loading, isolated frame, blink, breath, gaze, manual expression, motion, head/body touch mapping/restoration/interruption, empty hit rejection, inline draft/submit/failure/cancel, history sync, chat expression, audio-driven mouth/stop, scaling, sprite fallback; isolated local LLM/TTS only.");
+ } finally {
+ await app.evaluate(({ app }) => app.exit(0));
+ await app.close();
+ fs.rmSync(data, { recursive: true, force: true });
+ server.closeAllConnections(); server.close();
+ }
+}
+run().catch((error) => { console.error(error); server.closeAllConnections(); server.close(); process.exitCode = 1; });
diff --git a/tests/live2d-viewer.test.js b/tests/live2d-viewer.test.js
new file mode 100644
index 0000000..44f98fd
--- /dev/null
+++ b/tests/live2d-viewer.test.js
@@ -0,0 +1,156 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+const rig = require("../src/live2d/rig");
+
+async function viewer() {
+ const events = {}, updates = {}, messages = [], motions = [], values = {}, expressions = [];
+ let now = 100, stops = 0;
+ let alpha = 255;
+ const internal = { width: 100, height: 200,
+ coreModel: { getModel: () => ({ parameters: { ids: ["PARAM_ANGLE_Z", "PARAM_MOUTH_OPEN_Y"] } }),
+ setParameterValueById: (id, value) => { values[id] = value; }, addParameterValueById: (id, value) => { values[id] = value; } },
+ breath: { getParameters: () => [] },
+ motionManager: { groups: {}, stopAllMotions: () => { stops++; }, on: (name, callback) => { events[name] = callback; },
+ expressionManager: { defaultExpression: {}, resetExpression: () => expressions.push(-1),
+ setExpression: async index => { expressions.push(index); return true; } } },
+ hitAreas: { Head: {}, Body: {} },
+ focusController: { focus() {} }, on: (event, callback) => { updates[event] = callback; },
+ };
+ const model = { internalModel: internal, scale: { set() {} }, anchor: { set() {} }, position: { set() {} },
+ destroy() {}, update() {}, motion: async (group, index) => { motions.push({ group, index }); return true; },
+ hitTest: (x, y) => x < 10 ? [] : y < 150 ? ["Head", "Body"] : ["Body"] };
+ const parent = { postMessage: message => messages.push(message) };
+ const context = vm.createContext({ parent, innerWidth: 200, innerHeight: 400, devicePixelRatio: 1,
+ performance: { now: () => now },
+ document: { hidden: false, querySelector: () => ({ width: 200, height: 400 }), addEventListener: (name, callback) => { events[name] = callback; } },
+ window: { Live2DCubismCore: {}, DesktopPetRig: { ...rig, measure: () => ({ width: 100, height: 200 }) },
+ addEventListener: (name, callback) => { events[name] = callback; } },
+ fetch: async () => ({ json: async () => ({ FileReferences: { Expressions: [{ Name: "Smile" }, { Name: "Blush" }], Motions: { Tap: [{}, {}], Idle: [{}] } } }) }),
+ PIXI: { Application: class {
+ constructor() {
+ this.renderer = { resize() {}, gl: { readPixels: (x, y, w, h, format, type, pixel) => { pixel[3] = alpha; } } };
+ this.stage = { addChild() {} }; this.ticker = { add() {}, stop() {}, start() {} };
+ }
+ }, live2d: { Live2DModel: { from: async () => model } } },
+ });
+ context.window.PIXI = context.PIXI;
+ vm.runInContext(fs.readFileSync(path.join(__dirname, "../src/live2d/viewer.js"), "utf8"), context);
+ const send = (type, extra = {}) => events.message({ source: parent, origin: "null",
+ data: { channel: "desktop-pet-model", id: "imported-123456789012345678901234", type, ...extra } });
+ send("load"); await new Promise(resolve => setImmediate(resolve));
+ assert.ok(messages.some(message => message.type === "loaded"));
+ return { send, motions, values, messages, expressions, events, context, stops: () => stops,
+ setAlpha: value => { alpha = value; }, internal, model,
+ advance: milliseconds => { now += milliseconds; }, tick: () => updates.beforeModelUpdate() };
+}
+
+test("reply gestures are bounded and unavailable in click-only mode", async () => {
+ const ui = await viewer();
+ ui.send("reply-motion", { group: "Missing", index: 0 });
+ ui.send("reply-motion", { group: "Tap", index: 0 });
+ ui.send("reply-motion", { group: "Tap", index: 1 });
+ assert.equal(ui.motions.length, 1);
+ ui.advance(12000); ui.send("reply-motion", { group: "Tap", index: 1 });
+ assert.equal(ui.motions.length, 2);
+ ui.send("options", { automatic: false });
+ ui.advance(12000); ui.send("reply-motion", { group: "Tap", index: 0 });
+ assert.equal(ui.motions.length, 2);
+});
+
+const flush = () => new Promise(resolve => setImmediate(resolve));
+
+test("head pats ease in and out, do not stack, and restore the previous expression", async () => {
+ const ui = await viewer();
+ ui.send("expression", { index: 0 }); await flush();
+ ui.send("options", { touches: { head: { expression: 1 } } });
+ ui.send("touch", { kind: "head" }); await flush();
+ assert.equal(ui.expressions.at(-1), 1);
+ ui.tick(); assert.ok(Math.abs(ui.values.PARAM_ANGLE_Z) < 0.001);
+ ui.advance(1100); ui.tick(); assert.equal(ui.values.PARAM_ANGLE_Z, -5);
+ ui.send("touch", { kind: "head" });
+ assert.equal(ui.messages.filter(message => message.type === "touch").length, 1);
+ ui.advance(1100); ui.tick(); await flush();
+ assert.equal(ui.expressions.at(-1), 0);
+ assert.ok(Math.abs(ui.values.PARAM_ANGLE_Z) < 0.001);
+});
+
+test("touch expressions cannot overwrite a newer reply, drag or manual selection", async () => {
+ for (const interrupt of ["expression", "drag", "manual", "presence"]) {
+ const ui = await viewer();
+ ui.send("options", { touches: { head: { expression: 1 } } });
+ ui.send("touch", { kind: "head" }); await flush();
+ if (interrupt === "expression") ui.send("expression", { index: 0 });
+ if (interrupt === "drag") ui.send("options", { dragging: true });
+ if (interrupt === "manual") ui.send("options", { automatic: false });
+ if (interrupt === "presence") ui.send("presence", { state: "attentive" });
+ await flush();
+ const count = ui.expressions.length;
+ ui.advance(5000); ui.tick(); await flush();
+ assert.equal(ui.expressions.length, count);
+ assert.equal(ui.expressions.at(-1), interrupt === "expression" ? 0 : -1);
+ }
+});
+
+test("body touches use their own motion, while quiet idle never suppresses requested gestures", async () => {
+ const ui = await viewer();
+ ui.send("options", { idle: false, touches: { greet: { motion: { group: "Tap", index: 1 } } } });
+ ui.advance(90000); ui.tick(); assert.equal(ui.motions.length, 0);
+ ui.send("touch", { kind: "greet" }); ui.tick();
+ assert.deepEqual(ui.motions, [{ group: "Tap", index: 1 }]);
+ assert.equal(ui.values.PARAM_ANGLE_Z, undefined, "native gestures have no additional artificial tilt");
+ ui.send("options", { idle: true }); ui.advance(60000); ui.tick();
+ assert.equal(ui.motions.at(-1).group, "Idle");
+});
+
+test("hit tests prefer native head areas and reject blank or malformed coordinates", async () => {
+ const ui = await viewer();
+ for (const [x, y, kind] of [[0.5, 0.2, "head"], [0.5, 0.8, "greet"], [0, 0, null], [NaN, 0, null], [1, 1, null]]) {
+ ui.send("locate", { x, y, request: 1 });
+ assert.equal(ui.messages.at(-1).kind, kind);
+ }
+ ui.setAlpha(0); ui.send("locate", { x: 0.5, y: 0.2, request: 2 });
+ assert.equal(ui.messages.at(-1).kind, null, "transparent pixels inside native bounds do not react");
+ ui.setAlpha(255);
+ ui.internal.hitAreas = { localized: { id: "HitAreaHead" } };
+ ui.model.hitTest = () => ["localized"];
+ ui.send("locate", { x: 0.5, y: 0.2, request: 3 });
+ assert.equal(ui.messages.at(-1).kind, "head", "drawable IDs resolve non-English names");
+ ui.internal.hitAreas = {};
+ ui.send("locate", { x: 0.5, y: 0.8, request: 4 });
+ assert.equal(ui.messages.at(-1).kind, "greet", "models without native areas use visible fallback regions");
+});
+
+test("hiding cancels transient gestures and resuming never launches a queued idle motion", async () => {
+ const ui = await viewer();
+ ui.send("options", { touches: { head: { expression: 1 } } });
+ ui.send("touch", { kind: "head" }); await flush();
+ ui.context.document.hidden = true; ui.events.visibilitychange(); await flush();
+ assert.equal(ui.expressions.at(-1), -1);
+ ui.advance(120000);
+ ui.context.document.hidden = false; ui.events.visibilitychange(); ui.tick();
+ assert.equal(ui.motions.length, 0);
+});
+
+test("speech preserves a reply gesture while the next user request interrupts it", async () => {
+ const ui = await viewer();
+ ui.send("presence", { state: "thinking" });
+ ui.send("reply-motion", { group: "Tap", index: 0 });
+ const before = ui.stops();
+ ui.send("presence", { state: "speaking" });
+ assert.equal(ui.stops(), before);
+ ui.send("presence", { state: "thinking" });
+ assert.equal(ui.stops(), before + 1);
+});
+
+test("legacy mouth IDs animate without a LipSync group and settle after audio stops", async () => {
+ const ui = await viewer();
+ ui.send("mouth", { value: 1 });
+ for (let i = 0; i < 10; i++) ui.tick();
+ assert.ok(ui.values.PARAM_MOUTH_OPEN_Y > 0.8);
+ ui.advance(400);
+ for (let i = 0; i < 30; i++) ui.tick();
+ assert.equal(ui.values.PARAM_MOUTH_OPEN_Y, 0);
+});
diff --git a/tests/pet-helpers.js b/tests/pet-helpers.js
index 0a987d1..0c0b9fa 100644
--- a/tests/pet-helpers.js
+++ b/tests/pet-helpers.js
@@ -13,7 +13,7 @@ function loadPet(api = {}) {
const events = {};
let timerId = 0;
const nodes = new Map();
- for (const id of ["speech-bubble", "speech-card", "bubble-speaker", "bubble-reply", "bubble-history", "bubble-pin", "bubble-dismiss", "last-reply", "talk"]) {
+ for (const id of ["speech-bubble", "speech-card", "bubble-speaker", "bubble-reply", "bubble-history", "bubble-pin", "bubble-dismiss", "last-reply", "talk", "pet-menu"]) {
nodes.set(`#${id}`, { textContent: "", events: {}, attributes: {},
addEventListener(name, fn) { this.events[name] = fn; },
setAttribute(name, value) { this.attributes[name] = value; },
@@ -43,7 +43,7 @@ function loadPet(api = {}) {
getChatState: () => new Promise(() => {}), onChatStateUpdated() {},
recordInteraction() {}, dragStart() {}, dragEnd() {}, beginSpeech: async () => 1,
speechStateChanged() {}, onSpeechStopped() {}, openChatWindow() {}, openQuickChatWindow() {},
- stopVoice() {}, showLastReply() {}, ...api },
+ stopVoice() {}, showLastReply() {}, showContextMenu() {}, ...api },
addEventListener(name, handler) { events[name] = handler; },
setInterval(fn) { intervals.set(++timerId, fn); return timerId; },
clearInterval(id) { intervals.delete(id); },
diff --git a/tests/poll.cjs b/tests/poll.cjs
new file mode 100644
index 0000000..0a490e3
--- /dev/null
+++ b/tests/poll.cjs
@@ -0,0 +1,10 @@
+async function poll(check, { timeout = 30000, interval = 50, label = "condition" } = {}) {
+ const deadline = Date.now() + timeout;
+ do {
+ const result = await check();
+ if (result) return result;
+ await new Promise(resolve => setTimeout(resolve, interval));
+ } while (Date.now() < deadline);
+ throw new Error(`Timed out waiting for ${label}`);
+}
+module.exports = { poll };
diff --git a/tests/poll.test.js b/tests/poll.test.js
new file mode 100644
index 0000000..3ce665b
--- /dev/null
+++ b/tests/poll.test.js
@@ -0,0 +1,15 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { poll } = require("./poll.cjs");
+
+test("async state polling waits for a true value, not a truthy Promise", async () => {
+ let calls = 0;
+ const result = await poll(async () => ++calls === 3 ? { reply: "Ready" } : false, { interval: 1 });
+ assert.equal(calls, 3);
+ assert.deepEqual(result, { reply: "Ready" });
+});
+
+test("async state polling reports timeouts and propagates real evaluation failures", async () => {
+ await assert.rejects(poll(async () => false, { timeout: 5, interval: 1, label: "reply" }), /waiting for reply/);
+ await assert.rejects(poll(async () => { throw new Error("Window closed"); }), /Window closed/);
+});
diff --git a/tests/run-electron-smoke.cjs b/tests/run-electron-smoke.cjs
index cbc6e09..6bc2de4 100644
--- a/tests/run-electron-smoke.cjs
+++ b/tests/run-electron-smoke.cjs
@@ -6,10 +6,21 @@ const { spawnSync } = require("node:child_process");
const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "desktop-pet-smoke-"));
const env = { ...process.env, PET_SMOKE_DATA: dataDir };
delete env.ELECTRON_RUN_AS_NODE;
+const args = process.argv.slice(2).filter((arg) => arg !== "--packaged");
let status = 0;
try {
+ if (process.argv.includes("--packaged")) {
+ const output = path.resolve(process.env.PET_SMOKE_OUTPUT || path.join(__dirname, "../dist"));
+ const candidates = process.platform === "darwin"
+ ? ["mac", `mac-${process.arch}`].map((folder) => path.join(output, folder, "Desktop Pet.app/Contents/Resources/app.asar"))
+ : [path.join(output, process.platform === "win32" ? "win-unpacked" : "linux-unpacked", "resources/app.asar")];
+ const archive = candidates.find((file) => fs.existsSync(file));
+ if (!archive) throw new Error("Packaged app.asar missing; build before running --packaged");
+ env.PET_SMOKE_APP = archive;
+ console.log("Testing packaged app resources with an isolated profile");
+ }
for (const phase of ["initial", "restart"]) {
- const result = spawnSync(require("electron"), [path.join(__dirname, "electron-smoke.cjs"), ...process.argv.slice(2)], {
+ const result = spawnSync(require("electron"), [path.join(__dirname, "electron-smoke.cjs"), ...args], {
env: { ...env, PET_SMOKE_PHASE: phase }, stdio: "inherit", timeout: 150000,
});
if (result.error) console.error(result.error.message);
diff --git a/tests/voice-controls.test.js b/tests/voice-controls.test.js
index c2172ba..dc1d129 100644
--- a/tests/voice-controls.test.js
+++ b/tests/voice-controls.test.js
@@ -234,3 +234,31 @@ test("voice-only updates preserve message nodes and a reader's scroll position",
assert.equal(messages.children[0], first);
assert.equal(messages.scrollTop, 42);
});
+
+test("pet voice controls keep icons and accessible labels through stop and replay", async () => {
+ let update, stops = 0, replays = 0;
+ const ui = loadRenderer("voice-controls.js", {
+ onChatStateUpdated: callback => { update = callback; },
+ stopVoice: async () => { stops++; }, replaySpeech: async () => { replays++; },
+ }, "index.html");
+ const controls = ui.nodes.get("#voice-controls");
+ const button = ui.nodes.get("#voice-toggle");
+ const icon = {};
+ const attributes = {};
+ controls.dataset.compact = "true";
+ button.querySelector = () => icon;
+ button.setAttribute = (key, value) => { attributes[key] = value; };
+ update({ resolvedLanguage: "en-US", voice: { enabled: true, status: "playing", canReplay: true } });
+ assert.equal(icon.src, "./icons/square.svg");
+ assert.equal(attributes["aria-label"], button.title);
+ assert.ok(button.title.includes("Stop"));
+ assert.equal(button.textContent, "");
+ await button.events.click();
+ assert.equal(stops, 1);
+ update({ voice: { enabled: true, status: "idle", canReplay: true } });
+ assert.equal(icon.src, "./icons/volume-2.svg");
+ await button.events.click();
+ assert.equal(replays, 1);
+ update({ voice: { enabled: false, status: "idle", canReplay: false } });
+ assert.equal(controls.hidden, true);
+});
@@ -51,6 +53,7 @@ macOS で開発元を確認できないと表示された場合は、app を右
## 機能
- 透明、フレームなし、常に手前の小さなペットウィンドウ
+- Live2D の追加、まばたき・呼吸・触れ合いの反応・返答時の動作の設定
- 表示言語：システムに合わせる、簡体字中国語、English、日本語
- ドラッグ移動中に移動アニメーションを再生
- クリック、ダブルクリック、長押し、マウスホバーに反応
@@ -67,6 +70,7 @@ macOS で開発元を確認できないと表示された場合は、app を右
- 25分集中リマインダー
- 30 / 60分休憩リマインダー
- 会話機能：
+ - ペット横の入力欄と上部の吹き出し。横のメニューから設定や終了を選択
- 返信をペットの吹き出しに表示するクイック入力ウィンドウ
- 小さなフローティングチャットウィンドウ
- 独立した会話設定ウィンドウ
@@ -178,7 +182,7 @@ API key はこの端末だけに保存されます。利用できる場合はOS
自動表情モードでは、頭をなでる・長押しする、体を軽くクリックする、ドラッグして置く操作に、それぞれ異なるローカルの反応があります。既存の表情を使い、組み込みキャラクターごとの一言と設定した呼び名で応えます。モデルや音声サービスは呼び出さず、好感度も増えません。表示中の返信や通知を上書きせず、会話や音声を中断しません。**一般 > ふれあいの一言** をオフにすると従来の動作のみになります。
-クリック限定モードは手動のままです。1回のクリックで表情が1つ進み、ダブルクリック・長押しでは追加変更せず、ドラッグ後は選んでいた表情に戻ります。画像の変更やLive2Dの追加はありません。
+クリック限定モードは手動のままです。1回のクリックで表情が1つ進み、ダブルクリック・長押しでは追加変更せず、ドラッグ後は選んでいた表情に戻ります。既存の画像は変更していません。追加モデルの操作は [Live2D ガイド](docs/live2d.md#日本語)をご覧ください。
## キャラクターパック
@@ -233,3 +237,5 @@ assets/characters/
## License
Code is released under the MIT License. See [ASSET_NOTICE.md](ASSET_NOTICE.md) before publicly redistributing artwork assets.
+
+同梱の中国語・日本語フォントには SIL Open Font License 1.1 が適用されます。[フォントの利用条件](assets/fonts/NOTICE.md)をご覧ください。
diff --git a/README.md b/README.md
index f8b14aa..e040fe0 100644
--- a/README.md
+++ b/README.md
@@ -2,14 +2,16 @@
[English](README.md) | [简体中文](README.zh-CN.md) | [日本語](README.ja.md)
-**0.4.5 desktop update:** remember the pet's position, find it from the menu bar or system tray, and keep all windows open when cancelling Quit. [Release notes](docs/releases/v0.4.5.md). Includes the [0.4.3 reply bubble controls](docs/releases/v0.4.3.md) and [0.4.1 safety fixes](docs/releases/v0.4.1.md).
+**0.5.0 companion update:** import a Live2D character, talk beside the pet, and customize touch reactions and reply gestures. Existing sprite characters, settings and window recovery remain available. [Release notes](docs/releases/v0.5.0.md).
+
+**Live2D is optional.** Bring your own compatible exported model and install the supported Core file locally. Neither Core nor sample models are bundled. [Model import, compatibility and licensing](docs/live2d.md).
[](https://github.com/TonyNa-code/desktop-pet/actions/workflows/build.yml)
[](https://github.com/TonyNa-code/desktop-pet/releases/latest)
[](LICENSE)
-A cross-platform anime desktop pet for Windows, macOS, and Linux, with character packs, multilingual UI, chat model integration, and optional voice replies. It uses Electron for a transparent always-on-top pet window, and loads each character from a spritesheet plus a small `character.json` action manifest.
+A cross-platform anime desktop pet for Windows, macOS, and Linux, with sprite character packs, optional Live2D models, multilingual UI, chat model integration, and optional voice replies. It uses Electron for a transparent always-on-top pet window. Sprite packs use a spritesheet and a small `character.json` action manifest; Live2D imports use `.model3.json` and its associated files.