@jingyi0605/codingns4dsh 0.2.1-beta.5 → 0.2.1-beta.6

package/data/build/dist/client/client.manager.js

@@ -0,0 +1,3454 @@
+window.__ModuleLoader__.load({
+	id: "@jingyi0605/codingns4dsh",
+	chunk: "client.manager.js",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		const require_transport = require("@jingyi0605/codingns4dsh/client.transport.js");
+		const require_theme = require("@jingyi0605/codingns4dsh/client.theme.js");
+		require("@jingyi0605/codingns4dsh/client.primitives-adapter.js");
+		let react = require("react");
+		//#region src/dsh-capabilities/settings-store.ts
+		/** 将 DSH 两代写入结果统一成内部成功布尔值。 */
+		function accepted(write) {
+			return write.then((result) => result !== false);
+		}
+		/**
+		* 判断两份设置快照在内容上是否等价。
+		*
+		* DSH 的 ConfigForm、SettingsScope 和插件自己的 Host RPC 都会在每次读取时
+		* 构造新对象。`useSyncExternalStore` 要求 `getSnapshot()` 在内容未变化时返回
+		* 同一个引用，否则 React 会在每次渲染后重新比对快照并强制再次渲染，直到抛出
+		* “Maximum update depth exceeded”（React #185）。所有适配器都必须先比较内容、
+		* 再决定是否替换快照并唤醒订阅者。
+		*/
+		function sameSettingsSnapshot(left, right) {
+			return sameSettingsValue(left.value, right.value) && left.revision === right.revision && left.writable === right.writable && left.status === right.status;
+		}
+		/** 设置内容的结构比较：数组按顺序、对象按键，标量按 Object.is。 */
+		function sameSettingsValue(left, right) {
+			if (Object.is(left, right)) return true;
+			if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+			if (Array.isArray(left) || Array.isArray(right)) {
+				if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+				return left.every((value, index) => sameSettingsValue(value, right[index]));
+			}
+			const leftRecord = left;
+			const rightRecord = right;
+			const leftKeys = Object.keys(leftRecord);
+			const rightKeys = Object.keys(rightRecord);
+			if (leftKeys.length !== rightKeys.length) return false;
+			return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(rightRecord, key) && sameSettingsValue(leftRecord[key], rightRecord[key]));
+		}
+		//#endregion
+		//#region src/shared/assistant-lifecycle.ts
+		const DEFAULT_ASSISTANT_NAME = "我的助理";
+		const ASSISTANT_PERSONALITY_MAX_CHARS = 4e3;
+		/** 只为未创建且尚无设定的助理补默认值；显式空白和已有档案保持原样。 */
+		function readAssistantPersonality(profile) {
+			return profile.personality ?? (profile.initialized ? "" : "你是一位友善、耐心、可靠的智能助理，是用户工作与生活中的伙伴。善于倾听，表达自然简洁，优先给出清晰结论和可执行建议，再按需解释细节。遇到不确定的信息会如实说明并主动澄清，尊重用户的选择与隐私，不编造事实或经历。");
+		}
+		/** 只有显式档案表示已创建；旧能力配置仅预填表单，不能跳过首次创建。 */
+		function readAssistantProfile(settings) {
+			if (settings.profile !== void 0) return { ...settings.profile };
+			return {
+				name: DEFAULT_ASSISTANT_NAME,
+				initialized: false,
+				createdAt: null
+			};
+		}
+		//#endregion
+		//#region src/shared/assistant-avatar-resources.ts
+		function assistantAvatarCacheStatusPath(pack) {
+			return `${pack.basePath}cache-status.json`;
+		}
+		Object.freeze([]);
+		//#endregion
+		//#region src/shared/assistant-avatar-legacy-resources.ts
+		/** 地址包含上游提交与精简策略版本；修改资源或策略时必须更新版本，避免浏览器旧缓存。 */
+		const WHALE_LIVE2D_RESOURCE_PACK = Object.freeze({
+			basePath: "/api/codingns/assistant-avatar-assets/whale-185c02bf-v1/",
+			upstreamRoot: "https://raw.githubusercontent.com/A8Chann/dsh-pet-live2d/185c02bfbb3b886e1a236b5c2ec035cc085b9ca2/dsh-live2d-pet/pets/ds-whale-girl/",
+			manifest: "c_0120.model3.json",
+			motionGroups: Object.freeze({
+				idle: "Idle",
+				thinking: "Idle",
+				listening: "Idle",
+				waiting: "Idle",
+				error: "SprayWater"
+			}),
+			files: Object.freeze([
+				{
+					path: "c_0120.model3.json",
+					contentType: "application/json",
+					maxBytes: 262144
+				},
+				{
+					path: "model/c_0120.moc3",
+					contentType: "application/octet-stream",
+					maxBytes: 4194304
+				},
+				{
+					path: "model/c_0120.physics3.json",
+					contentType: "application/json",
+					maxBytes: 1048576
+				},
+				{
+					path: "model/c_0120.cdi3.json",
+					contentType: "application/json",
+					maxBytes: 1048576,
+					preload: false
+				},
+				{
+					path: "textures/texture_00.png",
+					contentType: "image/png",
+					maxBytes: 4194304
+				},
+				{
+					path: "textures/texture_01.png",
+					contentType: "image/png",
+					maxBytes: 1048576
+				},
+				{
+					path: "motions/idle.motion3.json",
+					contentType: "application/json",
+					maxBytes: 1048576
+				},
+				{
+					path: "motions/spray-water.motion3.json",
+					contentType: "application/json",
+					maxBytes: 1048576
+				}
+			].map((file) => Object.freeze(file)))
+		});
+		const ASSISTANT_AVATAR_RESOURCE_PACKS = Object.freeze([WHALE_LIVE2D_RESOURCE_PACK]);
+		//#endregion
+		//#region src/shared/assistant-avatar-legacy.ts
+		const spriteRoot = "https://raw.githubusercontent.com/YunYueSama/codex-deepseek-pet/7661c8b304c5400701f91da01b1a643a207331de/codex-deepseek-pet/";
+		const live2dRoot = WHALE_LIVE2D_RESOURCE_PACK.upstreamRoot;
+		/**
+		* 目录保存经 Codex/DSH 适配器转换并核验的统一模型数据，不包含美术文件。
+		* 固定提交避免上游 main 更新悄悄改变素材；读取目录不请求网络，选中后才由渲染器加载。
+		* 预设使用独立 ID，保留此前按上游 ID 导入的用户形象与自定义清单容量。
+		*/
+		const LEGACY_ASSISTANT_AVATAR_PRESETS = Object.freeze([Object.freeze({
+			labelKey: "avatar.preset.whaleSprite",
+			model: Object.freeze({
+				id: "codingns-preset-whale-sprite",
+				name: "大肥鱼 · Q版全身",
+				renderer: "spritesheet",
+				source: `${spriteRoot}spritesheet.webp`,
+				spriteVersion: 2,
+				package: Object.freeze({
+					adapterId: "codex-pet",
+					manifestUrl: `${spriteRoot}pet.json`,
+					author: "YunYueSama",
+					license: "大肥鱼项目署名许可 1.0：仅授权作者有权授权的新增贡献；第三方角色与参考作品权利另行确认，非 DeepSeek 官方授权。",
+					homepage: "https://github.com/YunYueSama/codex-deepseek-pet/blob/7661c8b304c5400701f91da01b1a643a207331de/ASSET_LICENSE.md"
+				})
+			})
+		}), Object.freeze({
+			labelKey: "avatar.preset.whaleLive2d",
+			model: Object.freeze({
+				id: "codingns-preset-whale-live2d",
+				name: "大肥鱼 · Live2D 桌前",
+				renderer: "live2d",
+				source: `${WHALE_LIVE2D_RESOURCE_PACK.basePath}${WHALE_LIVE2D_RESOURCE_PACK.manifest}`,
+				spriteVersion: 2,
+				motionGroups: WHALE_LIVE2D_RESOURCE_PACK.motionGroups,
+				live2d: Object.freeze({
+					scale: 1,
+					position: Object.freeze([0, 0])
+				}),
+				package: Object.freeze({
+					adapterId: "dsh-live2d-pet",
+					manifestUrl: `${live2dRoot}pet.json`,
+					author: "模型：上善无形 / ZipZipPipe / 氵六青 · 插件：A8Chann",
+					license: "CC BY-NC-SA 4.0：署名、非商业、相同方式共享；商业使用须分别取得各权利人授权。清单已精简，模型与贴图未修改。",
+					homepage: "https://github.com/A8Chann/dsh-pet-live2d/blob/185c02bfbb3b886e1a236b5c2ec035cc085b9ca2/NOTICE.md"
+				})
+			})
+		})]);
+		function getAssistantAvatarPreset(id) {
+			return LEGACY_ASSISTANT_AVATAR_PRESETS.find((preset) => preset.model.id === id);
+		}
+		Object.freeze([]);
+		//#endregion
+		//#region src/shared/assistant-avatar-catalog.ts
+		/** 使用说明单独版本化；升级说明后必须重新确认，不能继承旧版同意。 */
+		const ASSISTANT_AVATAR_CONSENT_VERSION = "2026-10-07.1";
+		function validAssistantAvatarConsent(value) {
+			if (value === null || typeof value !== "object") return false;
+			const consent = value;
+			return typeof consent.version === "string" && consent.version.length > 0 && consent.version.length <= 80 && Number.isSafeInteger(consent.acceptedAt) && consent.acceptedAt > 0;
+		}
+		function hasAssistantAvatarConsent(value) {
+			return validAssistantAvatarConsent(value) && value.version === "2026-10-07.1";
+		}
+		//#endregion
+		//#region src/shared/assistant-avatar-engine.ts
+		let runtimeRevision = 0;
+		const runtimeListeners = /* @__PURE__ */ new Set();
+		/** Host 与 Client 各自维护代次，安装成功立即解除缺失引擎的短期缓存。 */
+		function invalidateAssistantAvatarRuntime() {
+			runtimeRevision += 1;
+			for (const listener of runtimeListeners) listener();
+		}
+		function assistantAvatarRuntimeRevision() {
+			return runtimeRevision;
+		}
+		/** 已经显示加载失败的形象也需要重新挂载，不能只清除模块缓存。 */
+		function subscribeAssistantAvatarRuntime(listener) {
+			runtimeListeners.add(listener);
+			return () => {
+				runtimeListeners.delete(listener);
+			};
+		}
+		/** 引擎许可单独版本化：Cubism SDK 条款与第三方素材许可分别确认。 */
+		const ASSISTANT_AVATAR_ENGINE_CONSENT_VERSION = "2026-10-08.1";
+		function validAssistantAvatarEngineConsent(value) {
+			if (value === null || typeof value !== "object") return false;
+			const consent = value;
+			return typeof consent.version === "string" && consent.version.length > 0 && consent.version.length <= 80 && Number.isSafeInteger(consent.acceptedAt) && consent.acceptedAt > 0;
+		}
+		function hasAssistantAvatarEngineConsent(value) {
+			return validAssistantAvatarEngineConsent(value) && value.version === "2026-10-08.1";
+		}
+		//#endregion
+		//#region src/shared/assistant-avatar.ts
+		const ASSISTANT_AVATAR_STATES = [
+			"idle",
+			"listening",
+			"thinking",
+			"speaking",
+			"waiting",
+			"error"
+		];
+		const ASSISTANT_AVATAR_RUNTIME_PATH = "/api/codingns/assistant-avatar-runtime";
+		const BUILTIN_ASSISTANT_AVATAR = {
+			id: "codingns-default",
+			name: "鱼妞",
+			renderer: "builtin",
+			source: "",
+			spriteVersion: 2
+		};
+		/** 保留旧默认 ID 和存储字段；实际生图素材通过固定的同源 URL 加载。 */
+		const BUILTIN_ASSISTANT_AVATARS = [BUILTIN_ASSISTANT_AVATAR, {
+			id: "codingns-basic-male",
+			name: "鱼仔",
+			renderer: "builtin",
+			source: "",
+			spriteVersion: 2
+		}];
+		/** 旧名称仅用于写入兼容；读取归一化后统一显示新名称，其他内置字段仍不可替换。 */
+		const legacyBuiltinNames = {
+			"codingns-default": "CodingNS",
+			"codingns-basic-male": "基础形象 · 男生"
+		};
+		const BUILTIN_ASSISTANT_AVATAR_SOURCES = {
+			"codingns-default": "/api/codingns/assistant-avatar-basic/female-v1.png",
+			"codingns-basic-male": "/api/codingns/assistant-avatar-basic/male-v1.png"
+		};
+		function getBuiltinAssistantAvatar(id) {
+			return BUILTIN_ASSISTANT_AVATARS.find((model) => model.id === id);
+		}
+		function builtinAssistantAvatarLabelKey(id) {
+			if (id === BUILTIN_ASSISTANT_AVATAR.id) return "avatar.builtinName";
+			if (id === "codingns-basic-male") return "avatar.builtinMaleName";
+		}
+		BUILTIN_ASSISTANT_AVATAR.id;
+		/** 资源只允许网页地址；任意脚本、file: 和协议相对地址均不能作为素材入口。 */
+		function isAssistantAvatarSource(value) {
+			if (value.length === 0 || value.length > 2048 || /[\s\\\u0000-\u001f]/u.test(value)) return false;
+			if (value.startsWith("/") && !value.startsWith("//")) return true;
+			try {
+				const url = new URL(value);
+				return (url.protocol === "https:" || url.protocol === "http:") && url.username === "" && url.password === "";
+			} catch {
+				return false;
+			}
+		}
+		/** 读取旧设置时补默认值；非法模型被过滤，绝不让坏配置阻止助理入口。 */
+		function normalizeAssistantAppearance(value) {
+			const record = asRecord(value);
+			const models = [...BUILTIN_ASSISTANT_AVATARS];
+			const seen = new Set(models.map((model) => model.id));
+			for (const item of Array.isArray(record.models) ? record.models.slice(0, 21) : []) {
+				if (models.length >= 21) break;
+				const model = asRecord(item);
+				if (!validModel(model) || seen.has(model.id)) continue;
+				seen.add(model.id);
+				models.push(copyAssistantAvatarModel(model));
+			}
+			return {
+				floatingEnabled: record.floatingEnabled === true,
+				dialogEnabled: record.dialogEnabled !== false,
+				floatingSize: boundedSize(record.floatingSize, 72, 320, 144),
+				dialogSize: boundedSize(record.dialogSize, 120, 480, 240),
+				selectedId: typeof record.selectedId === "string" && (seen.has(record.selectedId) || getAssistantAvatarPreset(record.selectedId) !== void 0) ? record.selectedId : BUILTIN_ASSISTANT_AVATAR.id,
+				models,
+				...validAssistantAvatarConsent(record.thirdPartyConsent) ? { thirdPartyConsent: {
+					version: record.thirdPartyConsent.version,
+					acceptedAt: record.thirdPartyConsent.acceptedAt
+				} } : {},
+				...validAssistantAvatarEngineConsent(record.engineConsent) ? { engineConsent: {
+					version: record.engineConsent.version,
+					acceptedAt: record.engineConsent.acceptedAt
+				} } : {}
+			};
+		}
+		/** 写入必须严格校验，不能把被静默修正的数据报告为保存成功。 */
+		function validateAssistantAppearance(value) {
+			const record = asRecord(value);
+			if (record.thirdPartyConsent !== void 0 && !validAssistantAvatarConsent(record.thirdPartyConsent)) throw new TypeError("第三方形象协议记录无效");
+			if (record.engineConsent !== void 0 && !validAssistantAvatarEngineConsent(record.engineConsent)) throw new TypeError("Live2D 引擎许可记录无效");
+			if (typeof record.floatingEnabled !== "boolean" || typeof record.dialogEnabled !== "boolean") throw new TypeError("形象显示开关无效");
+			for (const [key, min, max] of [[
+				"floatingSize",
+				72,
+				320
+			], [
+				"dialogSize",
+				120,
+				480
+			]]) if (typeof record[key] !== "number" || !Number.isInteger(record[key]) || record[key] < min || record[key] > max) throw new TypeError("形象尺寸超出范围");
+			if (!Array.isArray(record.models) || record.models.length === 0 || record.models.length > 21) throw new TypeError(`形象清单必须包含 1 到 21 项`);
+			const seen = /* @__PURE__ */ new Set();
+			for (const item of record.models) {
+				const model = asRecord(item);
+				validateAssistantAvatarModel(model);
+				if (typeof model.id !== "string" || seen.has(model.id)) throw new TypeError("形象 ID 重复或无效");
+				seen.add(model.id);
+			}
+			if (!seen.has(BUILTIN_ASSISTANT_AVATAR.id) || typeof record.selectedId !== "string" || !seen.has(record.selectedId) && getAssistantAvatarPreset(record.selectedId) === void 0) throw new TypeError("当前形象不在清单中");
+		}
+		/** 所有导入和管理写入共享同一校验，不能由某个适配器绕过资源边界。 */
+		function validateAssistantAvatarModel(value) {
+			const model = asRecord(value);
+			const builtin = getBuiltinAssistantAvatar(model.id);
+			if (builtin !== void 0) {
+				const keys = Object.keys(builtin);
+				if (keys.some((key) => model[key] !== builtin[key] && !(key === "name" && model[key] === legacyBuiltinNames[builtin.id])) || Object.keys(model).some((key) => !keys.includes(key) && model[key] !== void 0)) throw new TypeError("内置形象不可替换");
+				return;
+			}
+			if (!validModel(model)) throw new TypeError("形象名称、类型或资源地址无效");
+		}
+		/** 保留旧存储字段，复制白名单内的数据，避免扩展把运行对象写进设置。 */
+		function copyAssistantAvatarModel(model) {
+			return {
+				id: model.id,
+				name: model.name.trim(),
+				...copyAsset(model),
+				...model.package === void 0 ? {} : { package: { ...model.package } },
+				...model.surfaces === void 0 ? {} : { surfaces: Object.fromEntries(Object.entries(model.surfaces).map(([surface, asset]) => [surface, copyAsset(asset)])) }
+			};
+		}
+		function selectedAssistantAvatar(appearance) {
+			return appearance.models.find((model) => model.id === appearance.selectedId) ?? getAssistantAvatarPreset(appearance.selectedId)?.model ?? BUILTIN_ASSISTANT_AVATAR;
+		}
+		/** 创建表单只列已登记形象；已创建助理和管理器可保留旧选择的兼容入口。 */
+		function listAssistantAvatars(appearance, includeLegacy = true) {
+			if (!includeLegacy) return appearance.models;
+			const legacy = getAssistantAvatarPreset(appearance.selectedId)?.model;
+			return legacy === void 0 || appearance.models.some((model) => model.id === legacy.id) ? appearance.models : [...appearance.models, legacy];
+		}
+		/** 展示位置只覆盖素材，不覆盖身份；状态映射也跟随所选素材，不串用另一种格式。 */
+		function resolveAssistantAvatarAsset(model, surface) {
+			const asset = model.surfaces?.[surface];
+			return asset === void 0 ? model : {
+				id: model.id,
+				name: model.name,
+				...copyAsset(asset),
+				...model.package === void 0 ? {} : { package: model.package },
+				...model.surfaces === void 0 ? {} : { surfaces: model.surfaces }
+			};
+		}
+		function assistantAvatarImageSource(model, state) {
+			return model.stateSources?.[state] ?? model.source;
+		}
+		function resolveAssistantAvatarState(state, pending = false) {
+			if (state === "error") return "error";
+			if (state === "speaking") return "speaking";
+			if (pending || state === "loading" || state === "thinking") return "thinking";
+			if (state === "listening" || state === "recording") return "listening";
+			if (state === "waiting") return "waiting";
+			return "idle";
+		}
+		/** 帧布局来自 Signalight/codex-to-dsh-pet；单帧 192×208，8 列。 */
+		function assistantSpriteMotion(state) {
+			if (state === "error") return {
+				row: 5,
+				frames: 8,
+				interval: 140
+			};
+			if (state === "waiting" || state === "listening") return {
+				row: 6,
+				frames: 6,
+				interval: 150
+			};
+			if (state === "thinking") return {
+				row: 7,
+				frames: 6,
+				interval: 120
+			};
+			if (state === "speaking") return {
+				row: 8,
+				frames: 6,
+				interval: 150
+			};
+			return {
+				row: 0,
+				frames: 6,
+				interval: 160
+			};
+		}
+		/** 视口变化或旧坐标失效时让宠物保持在可点击范围。 */
+		function clampAssistantAvatarPosition(x, y, width, height, viewportWidth, viewportHeight) {
+			return {
+				x: Math.max(0, Math.min(Number.isFinite(x) ? x : 0, Math.max(0, viewportWidth - width))),
+				y: Math.max(0, Math.min(Number.isFinite(y) ? y : 0, Math.max(0, viewportHeight - height)))
+			};
+		}
+		function validModel(model) {
+			return typeof model.id === "string" && /^[A-Za-z][A-Za-z0-9_-]{0,79}$/u.test(model.id) && typeof model.name === "string" && model.name.trim().length > 0 && model.name.length <= 80 && validAsset(model) && validPackage(model.package) && validSurfaces(model.surfaces);
+		}
+		function validAsset(asset) {
+			return typeof asset.renderer === "string" && validId(asset.renderer) && asset.renderer !== "builtin" && typeof asset.source === "string" && isAssistantAvatarSource(asset.source) && (asset.spriteVersion === 1 || asset.spriteVersion === 2) && validStateMap(asset.stateSources, (source) => asset.renderer === "image" && isAssistantAvatarSource(source)) && validStateMap(asset.motionGroups, (group) => asset.renderer === "live2d" && group.trim().length > 0 && group.length <= 120) && validLive2dOptions(asset.live2d, asset.renderer);
+		}
+		function validStateMap(value, valid) {
+			return value === void 0 || isRecord(value) && Object.entries(value).every(([state, item]) => ASSISTANT_AVATAR_STATES.includes(state) && typeof item === "string" && valid(item));
+		}
+		function validPackage(value) {
+			if (value === void 0) return true;
+			if (!isRecord(value) || typeof value.adapterId !== "string" || !validId(value.adapterId)) return false;
+			for (const key of ["manifestUrl", "homepage"]) if (value[key] !== void 0 && (typeof value[key] !== "string" || !isAssistantAvatarSource(value[key]))) return false;
+			for (const key of ["author", "license"]) if (value[key] !== void 0 && (typeof value[key] !== "string" || value[key].length > 2048)) return false;
+			if (value.installationId !== void 0 && (typeof value.installationId !== "string" || !/^[a-f0-9]{64}$/u.test(value.installationId))) return false;
+			return Object.keys(value).every((key) => [
+				"adapterId",
+				"manifestUrl",
+				"homepage",
+				"author",
+				"license",
+				"installationId"
+			].includes(key));
+		}
+		function validSurfaces(value) {
+			return value === void 0 || isRecord(value) && Object.entries(value).every(([surface, asset]) => ["floating", "dialog"].includes(surface) && isRecord(asset) && validAsset(asset));
+		}
+		function validLive2dOptions(value, renderer) {
+			if (value === void 0) return true;
+			if (!isRecord(value) || renderer !== "live2d" || Object.keys(value).some((key) => !["scale", "position"].includes(key))) return false;
+			if (value.scale !== void 0 && (typeof value.scale !== "number" || !Number.isFinite(value.scale) || value.scale < .05 || value.scale > 10)) return false;
+			return value.position === void 0 || Array.isArray(value.position) && value.position.length === 2 && value.position.every((item) => typeof item === "number" && Number.isFinite(item) && Math.abs(item) <= 2);
+		}
+		function copyAsset(asset) {
+			return {
+				renderer: asset.renderer,
+				source: asset.source,
+				spriteVersion: asset.spriteVersion,
+				...asset.stateSources === void 0 ? {} : { stateSources: { ...asset.stateSources } },
+				...asset.motionGroups === void 0 ? {} : { motionGroups: { ...asset.motionGroups } },
+				...asset.live2d === void 0 ? {} : { live2d: {
+					...asset.live2d,
+					...asset.live2d.position === void 0 ? {} : { position: [...asset.live2d.position] }
+				} }
+			};
+		}
+		function validId(value) {
+			return /^[A-Za-z][A-Za-z0-9_-]{0,79}$/u.test(value);
+		}
+		function isRecord(value) {
+			return typeof value === "object" && value !== null && !Array.isArray(value);
+		}
+		function boundedSize(value, min, max, fallback) {
+			return typeof value === "number" && Number.isFinite(value) ? Math.max(min, Math.min(max, Math.round(value))) : fallback;
+		}
+		function asRecord(value) {
+			return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+		}
+		//#endregion
+		//#region src/shared/assistant-avatar-adapters.ts
+		/** 相对路径以清单实际响应 URL 为基准，重定向后不再使用旧目录。 */
+		function resolveAssistantAvatarSource(source, manifestUrl) {
+			if (typeof source !== "string" || source.trim().length === 0 || source.trim().startsWith("//") || /[\\\u0000-\u001f]/u.test(source)) throw new TypeError("形象包资源地址无效");
+			if (!isAssistantAvatarSource(manifestUrl)) throw new TypeError("形象包清单地址无效");
+			const resolved = new URL(source, manifestUrl).href;
+			if (!isAssistantAvatarSource(resolved)) throw new TypeError("形象包资源地址无效");
+			return resolved;
+		}
+		function record(value) {
+			if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("形象包清单必须是 JSON 对象");
+			return value;
+		}
+		function looksLike(value, key) {
+			return typeof value === "object" && value !== null && key in value;
+		}
+		function asset(value, url) {
+			const input = record(value);
+			return {
+				renderer: input.renderer,
+				source: resolveAssistantAvatarSource(input.source, url),
+				spriteVersion: input.spriteVersion ?? 2,
+				...input.stateSources === void 0 ? {} : { stateSources: Object.fromEntries(Object.entries(record(input.stateSources)).map(([state, source]) => [state, resolveAssistantAvatarSource(source, url)])) },
+				...input.motionGroups === void 0 ? {} : { motionGroups: record(input.motionGroups) },
+				...input.live2d === void 0 ? {} : { live2d: record(input.live2d) }
+			};
+		}
+		function build(input, base, context, adapterId, surfaces) {
+			const info = {
+				adapterId,
+				manifestUrl: context.manifestUrl,
+				...input.author === void 0 ? {} : { author: input.author },
+				...input.license === void 0 ? {} : { license: input.license },
+				...input.homepage === void 0 ? {} : { homepage: resolveAssistantAvatarSource(input.homepage, context.manifestUrl) }
+			};
+			const model = {
+				id: input.id,
+				name: input.name ?? input.displayName,
+				...base,
+				package: info,
+				...surfaces === void 0 ? {} : { surfaces }
+			};
+			validateAssistantAvatarModel(model);
+			return copyAssistantAvatarModel(model);
+		}
+		const BUILTIN_ASSISTANT_AVATAR_ADAPTERS = [
+			{
+				id: "codingns-pack",
+				labelKey: "avatar.adapter.native",
+				matches: (value) => looksLike(value, "avatarManifestVersion"),
+				parse(value, context) {
+					const input = record(value);
+					if (input.avatarManifestVersion !== 1) throw new TypeError("不支持的 CodingNS 形象包版本");
+					const surfaces = input.surfaces === void 0 ? void 0 : Object.fromEntries(Object.entries(record(input.surfaces)).map(([surface, source]) => [surface, asset(source, context.manifestUrl)]));
+					return build(input, asset(input.asset, context.manifestUrl), context, this.id, surfaces);
+				}
+			},
+			{
+				id: "codex-pet",
+				labelKey: "avatar.adapter.codex",
+				matches: (value) => looksLike(value, "spritesheetPath"),
+				parse(value, context) {
+					const input = record(value);
+					return build(input, {
+						renderer: "spritesheet",
+						source: resolveAssistantAvatarSource(input.spritesheetPath, context.manifestUrl),
+						spriteVersion: input.spriteVersionNumber
+					}, context, this.id);
+				}
+			},
+			{
+				id: "dsh-live2d-pet",
+				labelKey: "avatar.adapter.dsh",
+				matches: (value) => looksLike(value, "petManifestVersion"),
+				parse(value, context) {
+					const input = record(value);
+					if (input.petManifestVersion !== 2 || input.renderer !== "live2d") throw new TypeError("不支持的 DSH 形象包格式");
+					const live2d = record(input.live2d);
+					const translate = live2d.translate === void 0 ? void 0 : record(live2d.translate);
+					const motions = live2d.motions === void 0 ? {} : record(live2d.motions);
+					const motionGroups = Object.fromEntries(Object.entries({
+						idle: ["idle"],
+						thinking: ["thinking", "tool"],
+						speaking: ["speaking"],
+						listening: ["listening", "waiting"],
+						waiting: [
+							"waiting",
+							"asking",
+							"queued"
+						],
+						error: ["error", "failed"]
+					}).flatMap(([state, aliases]) => {
+						const group = aliases.map((key) => motions[key]).find((item) => item !== void 0);
+						return group === void 0 ? [] : [[state, group]];
+					}));
+					return build(input, {
+						renderer: "live2d",
+						source: resolveAssistantAvatarSource(live2d.model, context.manifestUrl),
+						spriteVersion: 2,
+						...Object.keys(motionGroups).length === 0 ? {} : { motionGroups },
+						...live2d.scale === void 0 && translate === void 0 ? {} : { live2d: {
+							...live2d.scale === void 0 ? {} : { scale: live2d.scale },
+							...translate === void 0 ? {} : { position: [translate.x, translate.y] }
+						} }
+					}, context, this.id);
+				}
+			},
+			{
+				id: "cubism-model",
+				labelKey: "avatar.adapter.cubism",
+				matches: (value) => looksLike(value, "FileReferences") || looksLike(value, "model"),
+				parse(value, context) {
+					const input = record(value);
+					const refs = input.FileReferences === void 0 ? input : record(input.FileReferences);
+					const textures = refs.Textures ?? refs.textures;
+					if (input.FileReferences !== void 0 && input.Version !== 3 || !Array.isArray(textures) || textures.length === 0) throw new TypeError("Live2D 模型清单不完整");
+					resolveAssistantAvatarSource(refs.Moc ?? refs.model, context.manifestUrl);
+					for (const texture of textures) resolveAssistantAvatarSource(texture, context.manifestUrl);
+					let hash = 2166136261;
+					for (const character of context.manifestUrl) hash = Math.imul(hash ^ character.charCodeAt(0), 16777619);
+					const filename = new URL(context.manifestUrl).pathname.split("/").pop() ?? "Live2D";
+					return build({
+						id: `live2d-${(hash >>> 0).toString(36)}`,
+						name: decodeURIComponent(filename).replace(/\.model3?\.json$/iu, "").slice(0, 80) || "Live2D"
+					}, {
+						renderer: "live2d",
+						source: context.manifestUrl,
+						spriteVersion: 2
+					}, context, this.id);
+				}
+			}
+		];
+		const ASSISTANT_AVATAR_STATUS_PATH = "/api/codingns/assistant-avatar-cache-status";
+		//#endregion
+		//#region src/shared/assistant-tts.ts
+		const DEFAULT_ASSISTANT_TTS_PARAMETERS = Object.freeze({
+			rate: 1,
+			volume: 1,
+			segmentPauseMs: 0,
+			chunkTokens: 75,
+			seed: null
+		});
+		const ASSISTANT_TTS_PARAMETER_LIMITS = {
+			rate: {
+				min: .5,
+				max: 2,
+				step: .05
+			},
+			volume: {
+				min: 0,
+				max: 1,
+				step: .01
+			},
+			segmentPauseMs: {
+				min: 0,
+				max: 2e3,
+				step: 50
+			},
+			chunkTokens: {
+				min: 30,
+				max: 120,
+				step: 1
+			},
+			seed: {
+				min: 0,
+				max: 4294967295,
+				step: 1
+			}
+		};
+		/** 已保存的旧值或损坏值用默认值恢复；写入及试听请求使用严格校验。 */
+		function readAssistantTtsParameters(value) {
+			const result = { ...DEFAULT_ASSISTANT_TTS_PARAMETERS };
+			for (const key of [
+				"rate",
+				"volume",
+				"segmentPauseMs",
+				"chunkTokens",
+				"seed"
+			]) {
+				const item = value?.[key];
+				if (validParameter(key, item)) Object.assign(result, { [key]: item });
+			}
+			return result;
+		}
+		function validateAssistantTtsParameters(value, base) {
+			if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("播报参数必须为对象");
+			const result = readAssistantTtsParameters(base);
+			for (const [key, item] of Object.entries(value)) {
+				if (!Object.hasOwn(ASSISTANT_TTS_PARAMETER_LIMITS, key)) throw new Error(`不支持的播报参数：${key}`);
+				const name = key;
+				if (!validParameter(name, item)) {
+					const limit = ASSISTANT_TTS_PARAMETER_LIMITS[name];
+					throw new Error(`播报参数 ${key} 需要 ${limit.min}～${limit.max}${name === "seed" ? " 的整数或 null" : name === "chunkTokens" || name === "segmentPauseMs" ? " 的整数" : ""}`);
+				}
+				Object.assign(result, { [key]: item });
+			}
+			return result;
+		}
+		function validParameter(key, value) {
+			if (key === "seed" && value === null) return true;
+			const limit = ASSISTANT_TTS_PARAMETER_LIMITS[key];
+			return typeof value === "number" && Number.isFinite(value) && value >= limit.min && value <= limit.max && (key === "rate" || key === "volume" || Number.isInteger(value));
+		}
+		const DEFAULT_ASSISTANT_TTS_SETTINGS = {
+			backend: "browser",
+			selectedId: "moss:Junhao",
+			voices: [],
+			parameters: DEFAULT_ASSISTANT_TTS_PARAMETERS
+		};
+		const MOSS_BUILTIN_VOICES = [
+			{
+				id: "moss:Junhao",
+				name: "Junhao · 欢迎关注模思智能",
+				language: "zh",
+				gender: "male",
+				kind: "builtin",
+				reference: "Junhao",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Zhiming",
+				name: "Zhiming · 京味胡同闲聊",
+				language: "zh",
+				gender: "male",
+				kind: "builtin",
+				reference: "Zhiming",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Weiguo",
+				name: "Weiguo · 说书",
+				language: "zh",
+				gender: "male",
+				kind: "builtin",
+				reference: "Weiguo",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Xiaoyu",
+				name: "Xiaoyu · 明星",
+				language: "zh",
+				gender: "female",
+				kind: "builtin",
+				reference: "Xiaoyu",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Yuewen",
+				name: "Yuewen · 机车",
+				language: "zh",
+				gender: "female",
+				kind: "builtin",
+				reference: "Yuewen",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Lingyu",
+				name: "Lingyu · 深夜电台",
+				language: "zh",
+				gender: "female",
+				kind: "builtin",
+				reference: "Lingyu",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Trump",
+				name: "Trump · Trump",
+				language: "en",
+				gender: "male",
+				kind: "builtin",
+				reference: "Trump",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Ava",
+				name: "Ava · The Bitter Lesson",
+				language: "en",
+				gender: "female",
+				kind: "builtin",
+				reference: "Ava",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Bella",
+				name: "Bella · A Gentle Reminder",
+				language: "en",
+				gender: "female",
+				kind: "builtin",
+				reference: "Bella",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Adam",
+				name: "Adam · English News",
+				language: "en",
+				gender: "male",
+				kind: "builtin",
+				reference: "Adam",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Nathan",
+				name: "Nathan · The Quiet Motion of the World",
+				language: "en",
+				gender: "male",
+				kind: "builtin",
+				reference: "Nathan",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Soyo",
+				name: "Soyo · Soyo",
+				language: "ja",
+				gender: "female",
+				kind: "builtin",
+				reference: "Soyo",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Saki",
+				name: "Saki · Saki",
+				language: "ja",
+				gender: "female",
+				kind: "builtin",
+				reference: "Saki",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Mortis",
+				name: "Mortis · Mortis",
+				language: "ja",
+				gender: "female",
+				kind: "builtin",
+				reference: "Mortis",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Umiri",
+				name: "Umiri · Umiri",
+				language: "ja",
+				gender: "female",
+				kind: "builtin",
+				reference: "Umiri",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Mei",
+				name: "Mei · Togawa",
+				language: "ja",
+				gender: "female",
+				kind: "builtin",
+				reference: "Mei",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Anon",
+				name: "Anon · Anon",
+				language: "ja",
+				gender: "female",
+				kind: "builtin",
+				reference: "Anon",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			},
+			{
+				id: "moss:Arisa",
+				name: "Arisa · Arisa",
+				language: "ja",
+				gender: "female",
+				kind: "builtin",
+				reference: "Arisa",
+				source: "https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX/blob/f52645cb467506d8e18e746ddd59482685b74e58/browser_poc_manifest.json",
+				license: "Apache-2.0（项目许可；参考声音授权另行确认）"
+			}
+		];
+		const ASSISTANT_TTS_PATH = "/api/codingns/assistant/voice/tts";
+		const ASSISTANT_VOICE_SITES = [{
+			id: "kyutai",
+			name: "Kyutai 开放音色",
+			url: "https://kyutai.org/tts/",
+			help: "试听后填写 kyutai:voice-donations/0a67.wav 等录音 ID，或 Hugging Face 音频文件网址。"
+		}, {
+			id: "aishell",
+			name: "AISHELL-3 中文录音",
+			url: "https://huggingface.co/datasets/AISHELL/AISHELL-3",
+			help: "填写 aishell:完整录音ID，或 Hugging Face 中单个音频文件的网址。"
+		}];
+		/** 旧设置只补默认值，内置音色始终由目录提供，不能被自定义记录覆盖。 */
+		function readAssistantTtsSettings(value) {
+			const voices = (value?.voices ?? []).filter((voice) => voice.kind === "reference" && /^ref-[a-f0-9]{64}$/u.test(voice.id) && voice.reference === voice.id);
+			const selectedId = value?.selectedId ?? DEFAULT_ASSISTANT_TTS_SETTINGS.selectedId;
+			return {
+				backend: value?.backend === "moss-onnx" ? "moss-onnx" : "browser",
+				selectedId: [...MOSS_BUILTIN_VOICES, ...voices].some((voice) => voice.id === selectedId) ? selectedId : DEFAULT_ASSISTANT_TTS_SETTINGS.selectedId,
+				voices,
+				parameters: readAssistantTtsParameters(value?.parameters)
+			};
+		}
+		//#endregion
+		//#region src/client/global-voice-runtime-registry.ts
+		const adapters = /* @__PURE__ */ new WeakMap();
+		function registerGlobalVoiceAdapter(services, adapter) {
+			adapters.set(services, adapter);
+			return () => {
+				if (adapters.get(services) === adapter) adapters.delete(services);
+			};
+		}
+		function getGlobalVoiceAdapter(services) {
+			return adapters.get(services);
+		}
+		//#endregion
+		//#region src/client/avatar/image.ts
+		/** 图片差分也消费相同的状态接口；某张差分缺失时先回落该角色默认图片。 */
+		function ImageAssistantAvatar({ model, state, size, onError, onLoadProgress }) {
+			const requested = assistantAvatarImageSource(model, state);
+			const [failed, setFailed] = (0, react.useState)("");
+			const image = (0, react.useRef)(null);
+			(0, react.useEffect)(() => setFailed(""), [requested]);
+			const source = failed === requested ? model.source : requested;
+			(0, react.useEffect)(() => {
+				onLoadProgress?.({ phase: image.current?.complete && image.current.naturalWidth > 0 ? "ready" : "resources" });
+			}, [source, onLoadProgress]);
+			return (0, react.createElement)("img", {
+				key: source,
+				ref: image,
+				src: source,
+				alt: "",
+				draggable: false,
+				onLoad: () => onLoadProgress?.({ phase: "ready" }),
+				onError: () => {
+					if (source !== model.source) setFailed(requested);
+					else onError("avatar_image_load_failed");
+				},
+				style: {
+					display: "block",
+					width: size,
+					maxWidth: "100%",
+					height: size * 208 / 192,
+					objectFit: "contain"
+				}
+			});
+		}
+		//#endregion
+		//#region src/client/avatar/builtin.ts
+		/** 基础形象使用生图工具生成的透明 PNG，不手绘角色，也不加载第三方引擎。 */
+		function BuiltinAssistantAvatar(props) {
+			const source = BUILTIN_ASSISTANT_AVATAR_SOURCES[props.model.id] ?? BUILTIN_ASSISTANT_AVATAR_SOURCES[BUILTIN_ASSISTANT_AVATAR.id];
+			return (0, react.createElement)(ImageAssistantAvatar, {
+				...props,
+				model: {
+					...props.model,
+					source
+				}
+			});
+		}
+		//#endregion
+		//#region src/client/avatar/spritesheet.ts
+		/** 可测试的时钟：只推进当前动作实际拥有的帧，暂停后不追赶后台时间。 */
+		var AssistantSpriteClock = class {
+			state;
+			frame = 0;
+			last;
+			constructor(state) {
+				this.state = state;
+			}
+			setState(state) {
+				if (state !== this.state) {
+					this.state = state;
+					this.frame = 0;
+					this.last = void 0;
+				}
+			}
+			reset() {
+				this.last = void 0;
+			}
+			tick(now) {
+				const motion = assistantSpriteMotion(this.state);
+				if (this.last === void 0) this.last = now;
+				const steps = Math.floor(Math.max(0, now - this.last) / motion.interval);
+				this.frame = (this.frame + steps) % motion.frames;
+				this.last += steps * motion.interval;
+				return {
+					row: motion.row,
+					frame: this.frame
+				};
+			}
+		};
+		/** 参考 Signalight 的纯 DOM 图集渲染，不引入 Pixi 或上游会话逻辑。 */
+		function SpriteSheetAssistantAvatar({ model, state, size, onError, onLoadProgress }) {
+			const element = (0, react.useRef)(null);
+			const stateRef = (0, react.useRef)(state);
+			stateRef.current = state;
+			(0, react.useEffect)(() => {
+				if (element.current !== null) element.current.style.backgroundPosition = `0% ${assistantSpriteMotion(state).row * 100 / (model.spriteVersion === 2 ? 10 : 8)}%`;
+			}, [state, model.spriteVersion]);
+			(0, react.useEffect)(() => {
+				const target = element.current;
+				if (target === null) return void 0;
+				onLoadProgress?.({ phase: "resources" });
+				const image = new Image();
+				let disposed = false;
+				let frameId = 0;
+				const clock = new AssistantSpriteClock(stateRef.current);
+				const media = window.matchMedia?.("(prefers-reduced-motion: reduce)");
+				const rows = model.spriteVersion === 2 ? 11 : 9;
+				const paint = (now) => {
+					clock.setState(stateRef.current);
+					const frame = clock.tick(now);
+					target.style.backgroundPosition = `${frame.frame * 100 / 7}% ${frame.row * 100 / (rows - 1)}%`;
+				};
+				const tick = (now) => {
+					if (disposed) return;
+					paint(now);
+					frameId = requestAnimationFrame(tick);
+				};
+				const refresh = () => {
+					cancelAnimationFrame(frameId);
+					clock.reset();
+					paint(performance.now());
+					if (!disposed && !document.hidden && !media?.matches) frameId = requestAnimationFrame(tick);
+				};
+				image.onload = () => {
+					if (disposed) return;
+					if (image.naturalWidth !== 1536 || image.naturalHeight !== 208 * rows) {
+						onError(`avatar_sprite_dimensions_invalid: expected 1536x${208 * rows}`);
+						return;
+					}
+					target.style.backgroundImage = `url(${JSON.stringify(model.source)})`;
+					onLoadProgress?.({
+						phase: "ready",
+						loaded: 1,
+						total: 1
+					});
+					refresh();
+				};
+				image.onerror = () => {
+					if (!disposed) onError("avatar_sprite_load_failed");
+				};
+				image.src = model.source;
+				document.addEventListener("visibilitychange", refresh);
+				media?.addEventListener("change", refresh);
+				return () => {
+					disposed = true;
+					image.onload = null;
+					image.onerror = null;
+					cancelAnimationFrame(frameId);
+					document.removeEventListener("visibilitychange", refresh);
+					media?.removeEventListener("change", refresh);
+				};
+			}, [
+				model.source,
+				model.spriteVersion,
+				onError,
+				onLoadProgress
+			]);
+			return (0, react.createElement)("div", {
+				ref: element,
+				"aria-hidden": true,
+				style: {
+					width: size,
+					aspectRatio: "192 / 208",
+					maxWidth: "100%",
+					backgroundRepeat: "no-repeat",
+					backgroundSize: `800% ${model.spriteVersion === 2 ? 1100 : 900}%`
+				}
+			});
+		}
+		//#endregion
+		//#region src/client/avatar/cache-status.ts
+		/** 只诊断本站固定预设；查询失败不阻断模型加载，不推测浏览器是否命中缓存。 */
+		async function readAssistantAvatarCacheStatus(source, location, fetchStatus = (...args) => fetch(...args)) {
+			try {
+				const origin = new URL(location);
+				const model = new URL(source, origin);
+				const installedId = model.origin === origin.origin && model.pathname === "/api/codingns/assistant-avatar-assets" ? model.searchParams.get("pack") : null;
+				if (installedId !== null && /^[a-f0-9]{64}$/u.test(installedId)) {
+					const response = await fetchStatus(new URL(`${ASSISTANT_AVATAR_STATUS_PATH}?pack=${installedId}`, origin).href, {
+						cache: "no-store",
+						credentials: "same-origin",
+						signal: AbortSignal.timeout(250)
+					});
+					if (!response.ok) return void 0;
+					const value = await response.json();
+					if (value.version !== 1 || value.pack !== installedId || typeof value.generation !== "string" || !value.generation || value.generation.length > 80 || [
+						value.cached,
+						value.pending,
+						value.total,
+						value.downloads
+					].some((number) => !Number.isSafeInteger(number) || number < 0) || value.total > 256 || value.cached + value.pending > value.total) return void 0;
+					return value;
+				}
+				const pack = ASSISTANT_AVATAR_RESOURCE_PACKS.find((entry) => model.origin === origin.origin && model.pathname === entry.basePath + entry.manifest);
+				if (pack === void 0) return void 0;
+				const response = await fetchStatus(new URL(assistantAvatarCacheStatusPath(pack), origin).href, {
+					cache: "no-store",
+					credentials: "same-origin",
+					signal: AbortSignal.timeout(250)
+				});
+				if (!response.ok) return void 0;
+				const value = await response.json();
+				const numbers = [
+					value.cached,
+					value.pending,
+					value.total,
+					value.downloads
+				];
+				const total = pack.files.filter((file) => file.preload !== false).length;
+				if (value.version !== 1 || typeof value.generation !== "string" || value.generation.length === 0 || value.generation.length > 80 || value.pack !== pack.basePath || value.total !== total || numbers.some((number) => !Number.isSafeInteger(number) || number < 0) || value.cached + value.pending > total) return void 0;
+				return value;
+			} catch {
+				return;
+			}
+		}
+		const MAX_AGE = 2592e6;
+		const DATABASE = "codingns-assistant-avatar-previews";
+		const STORE = "previews";
+		/** 排序映射，避免设置归一化复制对象或属性顺序变化造成无效缓存。 */
+		function assistantAvatarPreviewKey(model, surface, rendererVersion, baseUrl = typeof document === "undefined" ? void 0 : document.baseURI) {
+			const asset = resolveAssistantAvatarAsset(model, surface);
+			const url = (source) => {
+				try {
+					return new URL(source, baseUrl).href;
+				} catch {
+					return source;
+				}
+			};
+			const entries = (map) => Object.entries(map ?? {}).sort(([a], [b]) => a.localeCompare(b));
+			return JSON.stringify([
+				1,
+				model.id,
+				surface,
+				rendererVersion,
+				asset.renderer,
+				url(asset.source),
+				asset.spriteVersion,
+				asset.live2d?.scale ?? 1,
+				asset.live2d?.position ?? [0, 0],
+				entries(asset.motionGroups),
+				entries(asset.stateSources).map(([state, source]) => [state, url(source)])
+			]);
+		}
+		function validAssistantAvatarPreview(value) {
+			if (value === null || typeof value !== "object") return false;
+			const preview = value;
+			return preview.blob instanceof Blob && preview.blob.type === "image/png" && preview.blob.size > 0 && preview.blob.size <= 524288 && Number.isSafeInteger(preview.width) && Number.isSafeInteger(preview.height) && preview.width > 0 && preview.height > 0 && preview.width <= 512 && preview.height <= 512 && (preview.cropAreaPercentages === void 0 || validCropArea(preview.cropAreaPercentages));
+		}
+		function validCropArea(area) {
+			return area !== null && typeof area === "object" && [
+				area.x,
+				area.y,
+				area.width,
+				area.height
+			].every(Number.isFinite) && area.x >= 0 && area.y >= 0 && area.width > 0 && area.height > 0 && area.x + area.width <= 100.001 && area.y + area.height <= 100.001;
+		}
+		/** 开库和事务都有短超时；存储不可用只丢失预览，不影响模型显示。 */
+		var AssistantAvatarPreviewStore = class {
+			factory;
+			now;
+			databaseName;
+			limits;
+			database;
+			constructor(factory = () => typeof indexedDB === "undefined" ? void 0 : indexedDB, now = Date.now, databaseName = DATABASE, limits = {}) {
+				this.factory = factory;
+				this.now = now;
+				this.databaseName = databaseName;
+				this.limits = limits;
+			}
+			async read(key, signal) {
+				return this.transaction("readonly", (store, result) => {
+					const request = store.get(key);
+					request.onsuccess = () => {
+						const record = request.result;
+						if (this.validRecord(record) && record.key === key) result({
+							blob: record.blob,
+							width: record.width,
+							height: record.height,
+							...record.cropAreaPercentages === void 0 ? {} : { cropAreaPercentages: record.cropAreaPercentages }
+						});
+					};
+				}, signal);
+			}
+			async write(key, modelId, surface, preview, signal) {
+				if (!validAssistantAvatarPreview(preview)) return false;
+				return await this.transaction("readwrite", (store, result) => {
+					const request = store.getAll();
+					request.onsuccess = () => {
+						const records = [];
+						for (const entry of request.result) if (!this.validRecord(entry) || entry.modelId === modelId && entry.surface === surface) store.delete(entry.key);
+						else records.push(entry);
+						records.sort((a, b) => b.savedAt - a.savedAt);
+						for (const entry of records.slice((this.limits.maxEntries ?? 8) - 1)) store.delete(entry.key);
+						store.put({
+							key,
+							modelId,
+							surface,
+							...preview,
+							savedAt: this.now()
+						});
+						result(true);
+					};
+				}, signal) ?? false;
+			}
+			async remove(key) {
+				await this.transaction("readwrite", (store) => {
+					store.delete(key);
+				});
+			}
+			async removeModel(modelId) {
+				await this.transaction("readwrite", (store) => {
+					const request = store.getAll();
+					request.onsuccess = () => {
+						for (const entry of request.result) if (entry.modelId === modelId) store.delete(entry.key);
+					};
+				});
+			}
+			validRecord(value) {
+				if (!validAssistantAvatarPreview(value)) return false;
+				const entry = value;
+				return typeof entry.key === "string" && typeof entry.modelId === "string" && (entry.surface === "floating" || entry.surface === "dialog") && Number.isFinite(entry.savedAt) && entry.savedAt <= this.now() && this.now() - entry.savedAt < (this.limits.maxAgeMs ?? MAX_AGE);
+			}
+			open() {
+				if (this.database !== void 0) return this.database;
+				const task = new Promise((resolve) => {
+					let request;
+					try {
+						const factory = this.factory();
+						if (factory === void 0) {
+							resolve(void 0);
+							return;
+						}
+						request = factory.open(this.databaseName, 1);
+					} catch {
+						resolve(void 0);
+						return;
+					}
+					let settled = false;
+					const finish = (database) => {
+						if (settled) {
+							database?.close();
+							return;
+						}
+						settled = true;
+						clearTimeout(timer);
+						resolve(database);
+					};
+					const timer = setTimeout(() => finish(), 1e3);
+					request.onupgradeneeded = () => {
+						if (!request.result.objectStoreNames.contains(STORE)) request.result.createObjectStore(STORE, { keyPath: "key" });
+					};
+					request.onerror = () => finish();
+					request.onblocked = () => finish();
+					request.onsuccess = () => {
+						request.result.onversionchange = () => {
+							request.result.close();
+							this.database = void 0;
+						};
+						finish(request.result);
+					};
+				});
+				this.database = task;
+				task.then((database) => {
+					if (database === void 0 && this.database === task) this.database = void 0;
+				});
+				return task;
+			}
+			async transaction(mode, action, signal) {
+				if (signal?.aborted) return void 0;
+				const database = await this.open();
+				if (database === void 0 || signal?.aborted) return void 0;
+				return new Promise((resolve) => {
+					let transaction;
+					try {
+						transaction = database.transaction(STORE, mode);
+					} catch {
+						this.database = void 0;
+						resolve(void 0);
+						return;
+					}
+					let value;
+					const abort = () => {
+						try {
+							transaction.abort();
+						} catch {}
+					};
+					const timer = setTimeout(abort, 1e3);
+					const finish = (success) => {
+						clearTimeout(timer);
+						signal?.removeEventListener("abort", abort);
+						resolve(success ? value : void 0);
+					};
+					transaction.oncomplete = () => finish(true);
+					transaction.onabort = () => finish(false);
+					transaction.onerror = () => finish(false);
+					signal?.addEventListener("abort", abort, { once: true });
+					try {
+						action(transaction.objectStore(STORE), (next) => {
+							value = next;
+						});
+					} catch {
+						abort();
+						finish(false);
+					}
+				});
+			}
+		};
+		const assistantAvatarPreviewStore = new AssistantAvatarPreviewStore();
+		//#endregion
+		//#region src/client/avatar/preview-capture.ts
+		/** 在同步绘制窗口拷贝到 2D 画布；PNG 编码异步执行，不保留原 GPU 缓冲。 */
+		function copyCanvasFrame(source) {
+			if (source.width <= 0 || source.height <= 0) return void 0;
+			const canvas = document.createElement("canvas");
+			const scale = Math.min(1, 512 / Math.max(source.width, source.height));
+			canvas.width = Math.max(1, Math.round(source.width * scale));
+			canvas.height = Math.max(1, Math.round(source.height * scale));
+			const context = canvas.getContext("2d", { willReadFrequently: true });
+			if (context === null) return void 0;
+			context.drawImage(source, 0, 0, canvas.width, canvas.height);
+			const pixels = context.getImageData(0, 0, canvas.width, canvas.height).data;
+			for (let index = 3; index < pixels.length; index += 4) if (pixels[index] > 0) return canvas;
+		}
+		/** 只临时观察当前上下文的绘制，在同一帧微任务中捕获完整图像，完成/取消后还原。 */
+		function captureAssistantAvatarPreview(source, signal) {
+			if (signal?.aborted) return Promise.resolve(void 0);
+			return new Promise((resolve) => {
+				let settled = false;
+				let queued = false;
+				const restore = [];
+				const finish = (preview) => {
+					if (settled) return;
+					settled = true;
+					clearTimeout(timer);
+					signal?.removeEventListener("abort", abort);
+					for (const release of restore.splice(0).reverse()) release();
+					resolve(preview);
+				};
+				const abort = () => finish();
+				const timer = setTimeout(abort, 1e3);
+				signal?.addEventListener("abort", abort, { once: true });
+				const capture = () => {
+					if (settled || signal?.aborted) return true;
+					try {
+						const canvas = copyCanvasFrame(source);
+						if (canvas === void 0) return false;
+						for (const release of restore.splice(0).reverse()) release();
+						canvas.toBlob((blob) => {
+							const preview = blob === null ? void 0 : {
+								blob,
+								width: canvas.width,
+								height: canvas.height
+							};
+							finish(validAssistantAvatarPreview(preview) ? preview : void 0);
+						}, "image/png");
+						return true;
+					} catch {
+						finish();
+						return true;
+					}
+				};
+				try {
+					const context = source.getContext("webgl2") ?? source.getContext("webgl");
+					if (context === null) {
+						if (!capture()) finish();
+						return;
+					}
+					for (const name of ["drawElements", "drawArrays"]) {
+						const original = context[name];
+						const descriptor = Object.getOwnPropertyDescriptor(context, name);
+						const observe = (...args) => {
+							Reflect.apply(original, context, args);
+							if (!queued && !settled) {
+								queued = true;
+								queueMicrotask(() => {
+									queued = false;
+									capture();
+								});
+							}
+						};
+						Object.defineProperty(context, name, {
+							configurable: true,
+							writable: true,
+							value: observe
+						});
+						restore.push(() => {
+							if (context[name] !== observe) return;
+							try {
+								if (descriptor === void 0) delete context[name];
+								else Object.defineProperty(context, name, descriptor);
+							} catch {}
+						});
+					}
+					capture();
+				} catch {
+					finish();
+				}
+			});
+		}
+		/** 先去掉透明边距，再取上部角色轮廓；不修改原素材，也不识别具体角色 ID。 */
+		function assistantAvatarPortraitCrop(pixels, width, height) {
+			if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1 || width > 512 || height > 512 || pixels.length !== width * height * 4) return void 0;
+			let left = width, right = -1, top = height, bottom = -1;
+			for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+				if (pixels[(y * width + x) * 4 + 3] < 24) continue;
+				left = Math.min(left, x);
+				right = Math.max(right, x);
+				top = Math.min(top, y);
+				bottom = Math.max(bottom, y);
+			}
+			if (right < left) return void 0;
+			const upperBottom = Math.min(bottom, top + Math.ceil((bottom - top + 1) * .56));
+			let upperLeft = width, upperRight = -1;
+			for (let y = top; y <= upperBottom; y++) for (let x = left; x <= right; x++) {
+				if (pixels[(y * width + x) * 4 + 3] < 24) continue;
+				upperLeft = Math.min(upperLeft, x);
+				upperRight = Math.max(upperRight, x);
+			}
+			const size = Math.max(1, Math.ceil(Math.max(upperRight - upperLeft + 1, upperBottom - top + 1) * 1.08));
+			return {
+				x: (upperLeft + upperRight + 1 - size) / 2,
+				y: top - size * .04,
+				size
+			};
+		}
+		/** 图片和动作图集只加载一张现有素材；跨域不允许截图时安静回退。 */
+		async function createImageAssistantAvatarPortrait(model, signal) {
+			return portraitFromImage(assistantAvatarImageSource(model, "idle"), signal);
+		}
+		async function createBuiltinAssistantAvatarPortrait(model, signal) {
+			return portraitFromImage(BUILTIN_ASSISTANT_AVATAR_SOURCES[model.id] ?? BUILTIN_ASSISTANT_AVATAR_SOURCES[BUILTIN_ASSISTANT_AVATAR.id], signal);
+		}
+		async function createSpriteAssistantAvatarPortrait(model, signal) {
+			const image = await loadImage(model.source, signal);
+			const rows = model.spriteVersion === 2 ? 11 : 9;
+			if (image === void 0 || image.naturalWidth !== 1536 || image.naturalHeight !== 208 * rows) return void 0;
+			return cropImage(image, signal, {
+				x: 0,
+				y: 0,
+				width: 192,
+				height: 208
+			});
+		}
+		/** 微调使用完整静态角色或图集首帧，避免在已裁好的小头像上继续损失构图。 */
+		async function createImageAssistantAvatarPortraitSource(model, signal) {
+			const image = await loadImage(assistantAvatarImageSource(model, "idle"), signal);
+			return image === void 0 ? void 0 : imageFrame(image, signal);
+		}
+		async function createBuiltinAssistantAvatarPortraitSource(model, signal) {
+			return createImageAssistantAvatarPortraitSource({
+				...model,
+				source: BUILTIN_ASSISTANT_AVATAR_SOURCES[model.id] ?? BUILTIN_ASSISTANT_AVATAR_SOURCES[BUILTIN_ASSISTANT_AVATAR.id]
+			}, signal);
+		}
+		async function createSpriteAssistantAvatarPortraitSource(model, signal) {
+			const image = await loadImage(model.source, signal);
+			if (image === void 0 || image.naturalWidth !== 1536 || image.naturalHeight !== 208 * (model.spriteVersion === 2 ? 11 : 9)) return void 0;
+			return imageFrame(image, signal, {
+				x: 0,
+				y: 0,
+				width: 192,
+				height: 208
+			});
+		}
+		async function imageFrame(image, signal, frame = {
+			x: 0,
+			y: 0,
+			width: image.naturalWidth,
+			height: image.naturalHeight
+		}) {
+			if (signal.aborted || typeof document === "undefined") return void 0;
+			try {
+				const scale = Math.min(1, 512 / Math.max(frame.width, frame.height)), canvas = document.createElement("canvas");
+				canvas.width = Math.max(1, Math.round(frame.width * scale));
+				canvas.height = Math.max(1, Math.round(frame.height * scale));
+				const context = canvas.getContext("2d");
+				if (context === null) return void 0;
+				context.drawImage(image, frame.x, frame.y, frame.width, frame.height, 0, 0, canvas.width, canvas.height);
+				return await encodePortrait(canvas, signal);
+			} catch {
+				return;
+			}
+		}
+		/** 裁剪组件仅负责交互及坐标；像素输出保留透明背景并统一成 128px。 */
+		async function cropAssistantAvatarPortrait(source, area, signal) {
+			if (signal.aborted || ![
+				area.x,
+				area.y,
+				area.width,
+				area.height
+			].every(Number.isFinite) || area.width <= 0 || area.height <= 0 || Math.abs(area.width - area.height) > 1 || area.x < 0 || area.y < 0 || area.x + area.width > source.width + 1 || area.y + area.height > source.height + 1) return void 0;
+			const url = URL.createObjectURL(source.blob);
+			try {
+				const image = await loadImage(url, signal);
+				if (image === void 0 || typeof document === "undefined") return void 0;
+				const canvas = document.createElement("canvas");
+				canvas.width = 128;
+				canvas.height = 128;
+				const context = canvas.getContext("2d");
+				if (context === null) return void 0;
+				context.imageSmoothingQuality = "high";
+				context.drawImage(image, area.x, area.y, area.width, area.height, 0, 0, 128, 128);
+				return await encodePortrait(canvas, signal);
+			} catch {
+				return;
+			} finally {
+				URL.revokeObjectURL(url);
+			}
+		}
+		/** 初始化裁剪框仍落在角色上部，组件随后负责拖动与缩放。 */
+		async function initialAssistantAvatarPortraitArea(source, signal) {
+			if (signal.aborted) return void 0;
+			const url = URL.createObjectURL(source.blob);
+			try {
+				const image = await loadImage(url, signal);
+				if (image === void 0 || typeof document === "undefined") return void 0;
+				const canvas = document.createElement("canvas");
+				canvas.width = source.width;
+				canvas.height = source.height;
+				const context = canvas.getContext("2d", { willReadFrequently: true });
+				if (context === null) return void 0;
+				context.drawImage(image, 0, 0, canvas.width, canvas.height);
+				const crop = assistantAvatarPortraitCrop(context.getImageData(0, 0, canvas.width, canvas.height).data, canvas.width, canvas.height);
+				if (crop === void 0) return void 0;
+				const size = Math.min(crop.size, canvas.width, canvas.height);
+				return {
+					x: Math.max(0, Math.min(canvas.width - size, crop.x)) / canvas.width * 100,
+					y: Math.max(0, Math.min(canvas.height - size, crop.y)) / canvas.height * 100,
+					width: size / canvas.width * 100,
+					height: size / canvas.height * 100
+				};
+			} catch {
+				return;
+			} finally {
+				URL.revokeObjectURL(url);
+			}
+		}
+		async function createAssistantAvatarPortraitFromPreview(preview, signal) {
+			if (signal.aborted) return void 0;
+			const url = URL.createObjectURL(preview.blob);
+			try {
+				return await portraitFromImage(url, signal);
+			} finally {
+				URL.revokeObjectURL(url);
+			}
+		}
+		async function portraitFromImage(source, signal) {
+			const image = await loadImage(source, signal);
+			return image === void 0 ? void 0 : cropImage(image, signal);
+		}
+		function loadImage(source, signal) {
+			if (signal.aborted || typeof Image === "undefined") return Promise.resolve(void 0);
+			return new Promise((resolve) => {
+				const image = new Image();
+				let finished = false;
+				const finish = (success = false) => {
+					if (finished) return;
+					finished = true;
+					clearTimeout(timer);
+					signal.removeEventListener("abort", abort);
+					image.onload = null;
+					image.onerror = null;
+					if (!success) image.src = "";
+					resolve(success ? image : void 0);
+				};
+				const abort = () => finish();
+				const timer = setTimeout(abort, 3e4);
+				signal.addEventListener("abort", abort, { once: true });
+				image.crossOrigin = "anonymous";
+				image.onload = () => finish(image.naturalWidth > 0 && image.naturalHeight > 0);
+				image.onerror = abort;
+				image.src = source;
+			});
+		}
+		async function cropImage(image, signal, frame = {
+			x: 0,
+			y: 0,
+			width: image.naturalWidth,
+			height: image.naturalHeight
+		}) {
+			if (signal.aborted || typeof document === "undefined") return void 0;
+			try {
+				const scale = Math.min(1, 512 / Math.max(frame.width, frame.height));
+				const sample = document.createElement("canvas");
+				sample.width = Math.max(1, Math.round(frame.width * scale));
+				sample.height = Math.max(1, Math.round(frame.height * scale));
+				const context = sample.getContext("2d", { willReadFrequently: true });
+				if (context === null) return void 0;
+				context.drawImage(image, frame.x, frame.y, frame.width, frame.height, 0, 0, sample.width, sample.height);
+				const crop = assistantAvatarPortraitCrop(context.getImageData(0, 0, sample.width, sample.height).data, sample.width, sample.height);
+				if (crop === void 0) return void 0;
+				const output = document.createElement("canvas");
+				output.width = 128;
+				output.height = 128;
+				const target = output.getContext("2d");
+				if (target === null) return void 0;
+				target.imageSmoothingEnabled = true;
+				target.imageSmoothingQuality = "high";
+				const zoom = output.width / crop.size;
+				target.setTransform(zoom, 0, 0, zoom, -crop.x * zoom, -crop.y * zoom);
+				target.drawImage(sample, 0, 0);
+				return await encodePortrait(output, signal);
+			} catch {
+				return;
+			}
+		}
+		function encodePortrait(canvas, signal) {
+			return new Promise((resolve) => {
+				let settled = false;
+				const finish = (blob) => {
+					if (settled) return;
+					settled = true;
+					clearTimeout(timer);
+					signal.removeEventListener("abort", abort);
+					resolve(!signal.aborted && blob !== void 0 && blob !== null && blob.size > 0 && blob.size <= 524288 ? {
+						blob,
+						width: canvas.width,
+						height: canvas.height
+					} : void 0);
+				};
+				const abort = () => finish();
+				const timer = setTimeout(abort, 1e3);
+				signal.addEventListener("abort", abort, { once: true });
+				if (signal.aborted) {
+					finish();
+					return;
+				}
+				canvas.toBlob((blob) => finish(blob), "image/png");
+			});
+		}
+		//#endregion
+		//#region src/client/avatar/live2d.ts
+		/** 成功共享引擎；失败更换模块 URL，避免浏览器缓存失败的动态导入而无法恢复。 */
+		var AssistantLive2dModuleLoader = class {
+			importModule;
+			fetchStatus;
+			module;
+			attempt = 0;
+			retryAt = 0;
+			revision = assistantAvatarRuntimeRevision();
+			constructor(importModule = (url) => import(
+				/* @vite-ignore */
+				url
+), fetchStatus = (...args) => fetch(...args)) {
+				this.importModule = importModule;
+				this.fetchStatus = fetchStatus;
+			}
+			load(location) {
+				if (this.revision !== assistantAvatarRuntimeRevision() || this.retryAt > 0 && Date.now() >= this.retryAt) {
+					this.revision = assistantAvatarRuntimeRevision();
+					this.module = void 0;
+					this.retryAt = 0;
+				}
+				if (this.module !== void 0) return this.module;
+				const url = new URL(ASSISTANT_AVATAR_RUNTIME_PATH, location);
+				url.searchParams.set("v", "2.1.1");
+				const attempt = this.attempt++;
+				if (attempt > 0) url.searchParams.set("retry", String(attempt));
+				const request = withLoadDeadline(this.importModule(url.href), 45e3).then((module) => {
+					if (typeof module.init !== "function") throw new Error("avatar_runtime_invalid");
+					return module;
+				}).catch(async (error) => {
+					if (this.module === request) this.retryAt = Date.now() + 3e4;
+					let status;
+					try {
+						status = (await this.fetchStatus(url, {
+							credentials: "same-origin",
+							signal: AbortSignal.timeout(5e3)
+						})).status;
+					} catch {}
+					if (status === 503) throw new Error("avatar_runtime_unavailable");
+					if (status !== void 0 && status !== 200) throw new Error(`avatar_runtime_http_${status}`);
+					throw error;
+				});
+				this.module = request;
+				return request;
+			}
+		};
+		const runtimeModuleLoader = new AssistantLive2dModuleLoader();
+		/** 固定同源独立 ESM，只在用户选择 Live2D 时加载；不进入主 Client bundle。 */
+		function loadLive2dModule() {
+			return runtimeModuleLoader.load(window.location.href);
+		}
+		/** l2d 某些下载失败只记录日志而不拒绝 Promise，必须限制永久等待。 */
+		async function withLoadDeadline(task, timeoutMs, observeActivity) {
+			let timer;
+			try {
+				return await Promise.race([task, new Promise((_resolve, reject) => {
+					const refresh = () => {
+						clearTimeout(timer);
+						timer = setTimeout(() => reject(/* @__PURE__ */ new Error("avatar_load_timeout")), timeoutMs);
+					};
+					observeActivity?.(refresh);
+					refresh();
+				})]);
+			} finally {
+				clearTimeout(timer);
+				observeActivity?.(void 0);
+			}
+		}
+		/** 参考上游 load/setState/resize/destroy；旧加载完成不能复活已销毁实例。 */
+		var AssistantLive2dController = class {
+			runtime;
+			motionGroups;
+			options;
+			timeoutMs;
+			disposed = false;
+			state = "idle";
+			loaded = false;
+			loadConfirmed = false;
+			cancelLoad;
+			refreshDeadline;
+			report;
+			constructor(runtime, motionGroups, options, report, timeoutMs = 45e3) {
+				this.runtime = runtime;
+				this.motionGroups = motionGroups;
+				this.options = options;
+				this.timeoutMs = timeoutMs;
+				this.report = report;
+				runtime.on?.("loadstart", (total) => {
+					if (this.disposed) return;
+					this.refreshDeadline?.();
+					this.report?.({
+						phase: "resources",
+						loaded: 0,
+						total
+					});
+				});
+				runtime.on?.("loadprogress", (loaded, total) => {
+					if (this.disposed) return;
+					this.refreshDeadline?.();
+					this.report?.({
+						phase: total > 0 && loaded >= total ? "rendering" : "resources",
+						loaded,
+						total
+					});
+				});
+				runtime.on?.("loaded", () => {
+					if (!this.disposed) this.loadConfirmed = true;
+				});
+			}
+			async load(source) {
+				if (this.disposed) return false;
+				this.loadConfirmed = false;
+				try {
+					const operation = this.runtime.load({
+						path: source,
+						scale: this.options?.scale ?? 1,
+						volume: 0,
+						logLevel: "warn",
+						...this.options?.position === void 0 ? {} : { position: [...this.options.position] }
+					}).then(() => {
+						if (this.disposed) {
+							this.runtime.destroy();
+							return false;
+						}
+						if (this.runtime.on !== void 0 && !this.loadConfirmed) throw new Error("avatar_model_not_loaded");
+						return true;
+					}, (error) => {
+						if (this.disposed) {
+							this.runtime.destroy();
+							return false;
+						}
+						throw error;
+					});
+					const cancelled = new Promise((resolve) => {
+						this.cancelLoad = () => resolve(false);
+					});
+					if (!await withLoadDeadline(Promise.race([operation, cancelled]), this.timeoutMs, (refresh) => {
+						this.refreshDeadline = refresh;
+					})) return false;
+					this.loaded = true;
+					this.setState(this.state);
+					return true;
+				} catch (error) {
+					this.dispose();
+					throw error;
+				} finally {
+					this.cancelLoad = void 0;
+				}
+			}
+			setState(state) {
+				if (this.disposed) return;
+				this.state = state;
+				if (!this.loaded) return;
+				const groups = Object.keys(this.runtime.getMotions());
+				const desired = state === "speaking" ? /talk|speak/iu : state === "thinking" ? /think|work/iu : state === "error" ? /fail|error|sad/iu : state === "listening" || state === "waiting" ? /listen|wait/iu : /idle/iu;
+				const configured = this.motionGroups?.[state];
+				const group = configured !== void 0 && groups.includes(configured) ? configured : groups.find((name) => desired.test(name)) ?? groups.find((name) => /idle/iu.test(name));
+				if (group !== void 0) this.runtime.playMotion(group, void 0, 2);
+			}
+			resize() {
+				if (!this.disposed && this.loaded) this.runtime.resize();
+			}
+			dispose() {
+				if (this.disposed) return;
+				this.disposed = true;
+				this.report = void 0;
+				this.cancelLoad?.();
+				this.runtime.destroy();
+			}
+		};
+		/** 没有已绘制预览时只生成一次头像；捕获后立即销毁临时 WebGL 实例。 */
+		async function createLive2dAssistantAvatarPortrait(model, signal) {
+			const preview = await createLive2dAssistantAvatarPortraitSource(model, signal);
+			return preview === void 0 ? void 0 : createAssistantAvatarPortraitFromPreview(preview, signal);
+		}
+		/** 编辑器复用同一静态帧来源，临时实例的销毁仍由适配器统一完成。 */
+		async function createLive2dAssistantAvatarPortraitSource(model, signal) {
+			if (signal.aborted || typeof document === "undefined") return void 0;
+			const module = await loadLive2dModule();
+			if (signal.aborted) return void 0;
+			const canvas = document.createElement("canvas");
+			canvas.width = 512;
+			canvas.height = 555;
+			canvas.style.cssText = "position:fixed;left:-10000px;top:0;width:256px;height:277.5px;pointer-events:none;opacity:0";
+			canvas.setAttribute("aria-hidden", "true");
+			document.body.appendChild(canvas);
+			let controller;
+			const abort = () => controller?.dispose();
+			try {
+				const runtime = module.init(canvas);
+				if (runtime === null) return void 0;
+				controller = new AssistantLive2dController(runtime, model.motionGroups, model.live2d);
+				signal.addEventListener("abort", abort, { once: true });
+				if (signal.aborted || !await controller.load(model.source) || signal.aborted) return void 0;
+				return await captureAssistantAvatarPreview(runtime.getCanvas?.() ?? canvas, signal);
+			} finally {
+				signal.removeEventListener("abort", abort);
+				controller?.dispose();
+				canvas.remove();
+			}
+		}
+		function Live2dAssistantAvatar({ model, state, size, onError, onLoadProgress, diagnostics = false, onPreview }) {
+			const configKey = JSON.stringify([model.motionGroups, model.live2d]);
+			const config = (0, react.useMemo)(() => ({
+				motionGroups: model.motionGroups,
+				options: model.live2d
+			}), [configKey]);
+			const canvas = (0, react.useRef)(null);
+			const controller = (0, react.useRef)(void 0);
+			const currentState = (0, react.useRef)(state);
+			currentState.current = state;
+			const [visible, setVisible] = (0, react.useState)(() => typeof document === "undefined" || !document.hidden);
+			(0, react.useEffect)(() => {
+				const refresh = () => setVisible(!document.hidden);
+				document.addEventListener("visibilitychange", refresh);
+				return () => document.removeEventListener("visibilitychange", refresh);
+			}, []);
+			(0, react.useEffect)(() => {
+				const target = canvas.current;
+				if (target === null || !visible) return void 0;
+				let disposed = false;
+				let instance;
+				const previewController = new AbortController();
+				const started = diagnostics ? performance.now() : 0;
+				let progress = { phase: "engine" };
+				const report = (next) => {
+					if (disposed) return;
+					if (!diagnostics) {
+						onLoadProgress?.(next);
+						return;
+					}
+					const elapsedMs = performance.now() - started;
+					progress = {
+						...progress,
+						...next,
+						elapsedMs,
+						...next.phase === "rendering" && progress.resourcesMs === void 0 ? { resourcesMs: elapsedMs } : {}
+					};
+					onLoadProgress?.(progress);
+				};
+				report(progress);
+				const observer = typeof ResizeObserver === "undefined" ? void 0 : new ResizeObserver(() => instance?.resize());
+				observer?.observe(target);
+				Promise.all([loadLive2dModule(), diagnostics ? readAssistantAvatarCacheStatus(model.source, window.location.href) : void 0]).then(async ([module, before]) => {
+					if (disposed) return;
+					report({
+						phase: "resources",
+						...before === void 0 ? {} : { cacheBefore: before }
+					});
+					const runtime = module.init(target);
+					if (runtime === null) throw new Error("avatar_webgl_unavailable");
+					instance = new AssistantLive2dController(runtime, config.motionGroups, config.options, report);
+					controller.current = instance;
+					instance.setState(currentState.current);
+					if (!await instance.load(model.source) || disposed) return;
+					if (onPreview !== void 0) {
+						const preview = await captureAssistantAvatarPreview(runtime.getCanvas?.() ?? target, previewController.signal);
+						if (disposed) return;
+						if (preview !== void 0) onPreview(preview);
+					}
+					report({ phase: "ready" });
+					if (!diagnostics) return;
+					const finished = progress;
+					const after = await readAssistantAvatarCacheStatus(model.source, window.location.href);
+					if (!disposed && after !== void 0) {
+						progress = {
+							...finished,
+							cacheAfter: after
+						};
+						onLoadProgress?.(progress);
+					}
+				}).catch((error) => {
+					if (!disposed) onError(error instanceof Error ? error.message : String(error));
+				});
+				return () => {
+					disposed = true;
+					previewController.abort();
+					observer?.disconnect();
+					instance?.dispose();
+					controller.current = void 0;
+				};
+			}, [
+				model.source,
+				config,
+				visible,
+				onError,
+				onLoadProgress,
+				diagnostics,
+				onPreview
+			]);
+			(0, react.useEffect)(() => {
+				controller.current?.setState(state);
+			}, [state]);
+			return (0, react.createElement)("canvas", {
+				ref: canvas,
+				width: Math.round(size * 2),
+				height: Math.round(size * 208 / 192 * 2),
+				"aria-hidden": true,
+				style: {
+					width: size,
+					height: "auto",
+					aspectRatio: "192 / 208",
+					maxWidth: "100%",
+					display: "block"
+				}
+			});
+		}
+		//#endregion
+		//#region src/shared/assistant-avatar-registration.ts
+		/** 所有形象适配器与渲染器共用稳定注册快照；注销只清理自己的一代。 */
+		var AssistantAvatarRegistration = class {
+			entries = /* @__PURE__ */ new Map();
+			reserved;
+			listeners = /* @__PURE__ */ new Set();
+			snapshot;
+			constructor(builtins = []) {
+				for (const entry of builtins) this.entries.set(entry.id, entry);
+				this.reserved = new Set(this.entries.keys());
+				this.snapshot = Object.freeze([...this.entries.values()]);
+			}
+			subscribe = (listener) => {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			};
+			getSnapshot = () => this.snapshot;
+			get(id) {
+				return this.entries.get(id);
+			}
+			register(entry) {
+				if (!/^[A-Za-z][A-Za-z0-9_-]{0,79}$/u.test(entry.id) || this.reserved.has(entry.id)) throw new TypeError("形象扩展 ID 无效或占用内置名称");
+				if (this.entries.has(entry.id)) throw new TypeError(`形象扩展已注册: ${entry.id}`);
+				this.entries.set(entry.id, entry);
+				this.emit();
+				return () => {
+					if (this.entries.get(entry.id) !== entry) return;
+					this.entries.delete(entry.id);
+					this.emit();
+				};
+			}
+			emit() {
+				this.snapshot = Object.freeze([...this.entries.values()]);
+				for (const listener of this.listeners) listener();
+			}
+		};
+		//#endregion
+		//#region src/client/avatar/registry.ts
+		/** 与语音适配器一样按服务实例隔离，页面卸载不会污染另一份 Client。 */
+		var AssistantAvatarRegistry = class extends AssistantAvatarRegistration {
+			constructor() {
+				super([
+					{
+						id: "builtin",
+						component: BuiltinAssistantAvatar,
+						reportsLoading: true,
+						portraitVersion: "1",
+						createPortrait: createBuiltinAssistantAvatarPortrait,
+						createPortraitSource: createBuiltinAssistantAvatarPortraitSource
+					},
+					{
+						id: "image",
+						labelKey: "avatar.type.image",
+						component: ImageAssistantAvatar,
+						reportsLoading: true,
+						portraitVersion: "1",
+						createPortrait: createImageAssistantAvatarPortrait,
+						createPortraitSource: createImageAssistantAvatarPortraitSource
+					},
+					{
+						id: "spritesheet",
+						labelKey: "avatar.type.spritesheet",
+						component: SpriteSheetAssistantAvatar,
+						reportsLoading: true,
+						portraitVersion: "1",
+						createPortrait: createSpriteAssistantAvatarPortrait,
+						createPortraitSource: createSpriteAssistantAvatarPortraitSource
+					},
+					{
+						id: "live2d",
+						labelKey: "avatar.type.live2d",
+						component: Live2dAssistantAvatar,
+						reportsLoading: true,
+						initialLoadPhase: "engine",
+						reportsCache: true,
+						previewVersion: "1",
+						portraitVersion: "1",
+						createPortrait: createLive2dAssistantAvatarPortrait,
+						createPortraitSource: createLive2dAssistantAvatarPortraitSource
+					}
+				]);
+			}
+		};
+		const registries = /* @__PURE__ */ new WeakMap();
+		/** 配置草稿借用正式渲染器注册表，保留第三方扩展。 */
+		function bindAssistantAvatarRegistry(services, registry) {
+			registries.set(services, registry);
+		}
+		function getAssistantAvatarRegistry(services) {
+			let registry = registries.get(services);
+			if (registry === void 0) {
+				registry = new AssistantAvatarRegistry();
+				registries.set(services, registry);
+			}
+			return registry;
+		}
+		/** 扩展模块应将返回的注销函数登记到自己的 context.resources。 */
+		function registerAssistantAvatarRenderer(services, renderer) {
+			return getAssistantAvatarRegistry(services).register(renderer);
+		}
+		//#endregion
+		//#region src/client/avatar/loading.ts
+		const loadingStyle = `
+@keyframes codingns-avatar-orbit { to { transform: rotate(360deg); } }
+@keyframes codingns-avatar-breathe { 50% { transform: scale(1.08); opacity: .65; } }
+@keyframes codingns-avatar-shimmer { from { transform: translateX(-130%); } to { transform: translateX(330%); } }
+[data-codingns-avatar-loading] .codingns-avatar-halo { animation: codingns-avatar-breathe 2.6s ease-in-out infinite; }
+[data-codingns-avatar-loading] .codingns-avatar-orbit { animation: codingns-avatar-orbit 3s linear infinite; }
+[data-codingns-avatar-loading] .codingns-avatar-indeterminate { animation: codingns-avatar-shimmer 1.6s ease-in-out infinite; }
+@media (prefers-reduced-motion: reduce) {
+  [data-codingns-avatar-loading] .codingns-avatar-halo,
+  [data-codingns-avatar-loading] .codingns-avatar-orbit,
+  [data-codingns-avatar-loading] .codingns-avatar-indeterminate { animation: none; }
+}`;
+		/** 百分比只根据已经完成的文件计数生成；未知总数保留循环动画。 */
+		function assistantAvatarLoadPercent(progress) {
+			if (progress.total === void 0 || progress.loaded === void 0 || !Number.isFinite(progress.total) || !Number.isFinite(progress.loaded) || progress.total <= 0) return void 0;
+			return Math.round(Math.min(1, Math.max(0, progress.loaded / progress.total)) * 100);
+		}
+		/** 计数只在同一缓存代际内可相减，Host 重建后不能把相同数字解释成下载为零。 */
+		function newHostDownloads(progress) {
+			const before = progress.cacheBefore;
+			const after = progress.cacheAfter;
+			if (before === void 0 || after === void 0 || after.generation !== before.generation || after.downloads < before.downloads) return void 0;
+			return after.downloads - before.downloads;
+		}
+		function cacheText(progress, t) {
+			const before = progress.cacheBefore;
+			if (before === void 0) return t("avatar.cacheUnknown");
+			const initial = t("avatar.cacheBefore", {
+				cached: before.cached,
+				total: before.total
+			});
+			const count = newHostDownloads(progress);
+			return count === void 0 ? initial : `${initial} · ${t("avatar.cacheDownloads", { count })}`;
+		}
+		/** 透明光晕、轨道光点与细进度条，直接复用插槽尺寸和宿主主题。 */
+		function AssistantAvatarLoading({ progress, size, t, showCache = false, diagnostics = false, preview = false, animationOnly = false }) {
+			showCache = !animationOnly && diagnostics && showCache;
+			if (progress.phase === "ready" && (!diagnostics || animationOnly)) return null;
+			const percent = assistantAvatarLoadPercent(progress);
+			const compact = size < 120;
+			const ready = progress.phase === "ready";
+			const elapsed = progress.elapsedMs === void 0 ? "" : t("avatar.loadElapsed", { seconds: (progress.elapsedMs / 1e3).toFixed(2) });
+			const shortElapsed = progress.elapsedMs === void 0 ? "" : t("avatar.loadElapsedCompact", { seconds: (progress.elapsedMs / 1e3).toFixed(2) });
+			const details = [
+				showCache ? cacheText(progress, t) : "",
+				elapsed,
+				progress.resourcesMs === void 0 ? "" : t("avatar.loadResourcesElapsed", { seconds: (progress.resourcesMs / 1e3).toFixed(2) })
+			].filter(Boolean).join(" · ");
+			const newDownloads = newHostDownloads(progress);
+			if (ready) return (0, react.createElement)("span", {
+				"data-codingns-avatar-load-summary": true,
+				title: details,
+				style: {
+					position: "absolute",
+					bottom: 0,
+					maxWidth: "100%",
+					fontSize: 10,
+					lineHeight: 1.4,
+					color: require_theme.dshThemeColor.labelSecondary,
+					textAlign: "center",
+					background: require_theme.dshThemeColor.cardBackground,
+					borderRadius: 8,
+					padding: "2px 6px"
+				}
+			}, showCache ? (0, react.createElement)("span", { style: { display: "block" } }, progress.cacheBefore === void 0 ? t("avatar.cacheUnknown") : t(compact ? "avatar.cacheTiny" : "avatar.cacheShort", {
+				cached: progress.cacheBefore.cached,
+				total: progress.cacheBefore.total
+			})) : null, (0, react.createElement)("span", { style: { display: "block" } }, [showCache && newDownloads !== void 0 ? t(compact ? "avatar.cacheDownloadsTiny" : "avatar.cacheDownloadsCompact", { count: newDownloads }) : "", compact && showCache && newDownloads !== void 0 ? "" : shortElapsed].filter(Boolean).join(" · ")));
+			const phaseText = progress.phase === "engine" ? t("avatar.loadEngine") : progress.phase === "rendering" ? t("avatar.loadRendering") : t("avatar.loading");
+			const orbSize = preview ? 14 : Math.min(80, size * (compact ? .3 : .46));
+			const cache = progress.cacheBefore;
+			const cacheLabel = compact ? cache === void 0 ? t("avatar.cacheUnknownCompact") : t("avatar.cacheTiny", {
+				cached: cache.cached,
+				total: cache.total
+			}) : cacheText(progress, t);
+			return (0, react.createElement)("div", {
+				"data-codingns-avatar-loading": progress.phase,
+				role: "status",
+				"aria-label": phaseText,
+				...showCache ? { title: cacheText(progress, t) } : {},
+				style: {
+					position: "absolute",
+					inset: preview ? "auto 0 0" : 0,
+					display: "flex",
+					flexDirection: "column",
+					justifyContent: "center",
+					alignItems: "center",
+					gap: compact || preview ? 4 : 10,
+					...preview ? {
+						padding: "5px 4px",
+						borderRadius: 10,
+						background: require_theme.dshThemeColor.cardBackground
+					} : {},
+					pointerEvents: "none",
+					color: require_theme.dshThemeColor.labelSecondary,
+					textAlign: "center"
+				}
+			}, (0, react.createElement)("style", null, loadingStyle), (0, react.createElement)("div", { style: {
+				display: "flex",
+				flexDirection: preview ? "row" : "column",
+				alignItems: "center",
+				gap: compact || preview ? 4 : 10
+			} }, (0, react.createElement)("div", {
+				"aria-hidden": true,
+				style: {
+					position: "relative",
+					flexShrink: 0,
+					width: orbSize,
+					height: orbSize,
+					color: require_theme.dshThemeColor.accent
+				}
+			}, (0, react.createElement)("div", {
+				className: "codingns-avatar-halo",
+				style: {
+					position: "absolute",
+					inset: "-14%",
+					borderRadius: "50%",
+					background: "radial-gradient(circle, rgba(112, 148, 255, .24), rgba(132, 204, 247, .10) 55%, transparent 72%)"
+				}
+			}), (0, react.createElement)("div", {
+				className: "codingns-avatar-orbit",
+				style: {
+					position: "absolute",
+					inset: 0,
+					borderRadius: "50%",
+					border: "1px solid rgba(112, 148, 255, .20)"
+				}
+			}, (0, react.createElement)("span", { style: {
+				position: "absolute",
+				top: -3,
+				left: "50%",
+				width: 6,
+				height: 6,
+				borderRadius: "50%",
+				background: "currentColor",
+				boxShadow: "0 0 12px rgba(112, 148, 255, .5)"
+			} })), (0, react.createElement)("svg", {
+				viewBox: "0 0 64 64",
+				style: {
+					position: "absolute",
+					inset: "20%",
+					width: "60%",
+					height: "60%"
+				},
+				fill: "none"
+			}, (0, react.createElement)("path", {
+				d: "M32 9C35 23 41 29 55 32C41 35 35 41 32 55C29 41 23 35 9 32C23 29 29 23 32 9Z",
+				fill: "currentColor",
+				opacity: .85
+			}), (0, react.createElement)("circle", {
+				cx: 51,
+				cy: 12,
+				r: 3,
+				fill: "currentColor",
+				opacity: .4
+			}))), animationOnly ? null : (0, react.createElement)("span", { style: {
+				fontSize: compact || preview ? 10 : size < 160 ? 11 : 13,
+				fontWeight: 500
+			} }, compact || preview ? t("avatar.loadingCompact") : phaseText)), animationOnly ? null : (0, react.createElement)("div", {
+				role: "progressbar",
+				"aria-label": t("avatar.loadProgress"),
+				"aria-valuemin": 0,
+				"aria-valuemax": 100,
+				...percent === void 0 ? {} : { "aria-valuenow": percent },
+				style: {
+					width: Math.min(130, size * .74),
+					height: 3,
+					flexShrink: 0,
+					borderRadius: 3,
+					overflow: "hidden",
+					background: "rgba(112, 148, 255, .15)"
+				}
+			}, (0, react.createElement)("div", {
+				className: percent === void 0 ? "codingns-avatar-indeterminate" : void 0,
+				style: {
+					width: percent === void 0 ? "30%" : `${percent}%`,
+					height: "100%",
+					borderRadius: 3,
+					background: "linear-gradient(90deg, #81c9ed, #7791f7)",
+					transition: "width .2s ease"
+				}
+			})), animationOnly ? null : (0, react.createElement)("span", { style: {
+				fontSize: 10,
+				lineHeight: 1.5,
+				padding: "0 6px",
+				maxWidth: "100%"
+			} }, percent === void 0 ? null : `${progress.loaded}/${progress.total} · ${percent}%`, showCache ? (0, react.createElement)("span", { style: { display: "block" } }, cacheLabel) : null));
+		}
+		//#endregion
+		//#region src/client/avatar/preview.ts
+		/** 插槽拥有读写与 URL 生命周期；渲染器仅提交图像，不接触持久化存储。 */
+		function useAssistantAvatarPreview(model, surface, version) {
+			const key = version === void 0 ? void 0 : assistantAvatarPreviewKey(model, surface, version);
+			const [preview, setPreview] = (0, react.useState)();
+			const session = (0, react.useRef)(void 0);
+			(0, react.useEffect)(() => {
+				setPreview(void 0);
+				if (key === void 0) return void 0;
+				const active = {
+					key,
+					controller: new AbortController(),
+					published: false,
+					url: void 0
+				};
+				session.current = active;
+				assistantAvatarPreviewStore.read(key, active.controller.signal).then((snapshot) => {
+					if (snapshot === void 0 || active.controller.signal.aborted || active.published) return;
+					active.url = URL.createObjectURL(snapshot.blob);
+					setPreview({
+						key,
+						url: active.url,
+						width: snapshot.width,
+						height: snapshot.height
+					});
+				}).catch(() => void 0);
+				return () => {
+					active.controller.abort();
+					if (active.url !== void 0) URL.revokeObjectURL(active.url);
+					if (session.current === active) session.current = void 0;
+				};
+			}, [key]);
+			const onPreview = (0, react.useCallback)((snapshot) => {
+				const active = session.current;
+				if (key === void 0 || active?.key !== key || active.controller.signal.aborted || !validAssistantAvatarPreview(snapshot)) return;
+				active.published = true;
+				if (active.url === void 0) try {
+					active.url = URL.createObjectURL(snapshot.blob);
+					setPreview({
+						key,
+						url: active.url,
+						width: snapshot.width,
+						height: snapshot.height
+					});
+				} catch {}
+				assistantAvatarPreviewStore.write(key, model.id, surface, snapshot, active.controller.signal).catch(() => void 0);
+			}, [
+				key,
+				model.id,
+				surface
+			]);
+			const discard = (0, react.useCallback)((stop = false) => {
+				const active = session.current;
+				if (active === void 0 || active.key !== key) return;
+				active.published = true;
+				if (stop) active.controller.abort();
+				if (active.url !== void 0) URL.revokeObjectURL(active.url);
+				active.url = void 0;
+				setPreview(void 0);
+				if (key !== void 0) assistantAvatarPreviewStore.remove(key).catch(() => void 0);
+			}, [key]);
+			return {
+				preview: preview?.key === key ? preview : void 0,
+				onPreview: version === void 0 ? void 0 : onPreview,
+				discard
+			};
+		}
+		//#endregion
+		//#region src/client/avatar/portrait-service.ts
+		const assistantAvatarPortraitStore = new AssistantAvatarPreviewStore(void 0, void 0, "codingns-assistant-avatar-portraits");
+		/** 用户确认的头像属于本地配置，不按临时预览的 30 天规则失效。 */
+		const assistantAvatarPortraitOverrideStore = new AssistantAvatarPreviewStore(void 0, void 0, "codingns-assistant-avatar-portrait-overrides", {
+			maxAgeMs: Infinity,
+			maxEntries: 21
+		});
+		/** 头像始终采用对话形象的待机构图，语音状态、名称和显示尺寸不参与缓存键。 */
+		function assistantAvatarPortraitKey(model, renderer) {
+			const asset = resolveAssistantAvatarAsset(model, "dialog");
+			return JSON.stringify([
+				"portrait",
+				1,
+				renderer?.previewVersion ?? "",
+				assistantAvatarPreviewKey(model, "dialog", renderer?.portraitVersion ?? ""),
+				asset.renderer === "builtin" ? BUILTIN_ASSISTANT_AVATAR_SOURCES[model.id] : ""
+			]);
+		}
+		function validPortrait(value) {
+			return validAssistantAvatarPreview(value) && value.width === value.height && value.width <= 256;
+		}
+		function sameAsset(a, b) {
+			return assistantAvatarPreviewKey(a, "dialog", "") === assistantAvatarPreviewKey({
+				...b,
+				surfaces: {}
+			}, "dialog", "");
+		}
+		/** 每个 Client 共用一个任务和临时 URL；多条消息不会创建多个图片或 WebGL 实例。 */
+		var AssistantAvatarPortraitService = class {
+			store;
+			previews;
+			crop;
+			createUrl;
+			revokeUrl;
+			overrides;
+			entries = /* @__PURE__ */ new Map();
+			clock = 0;
+			constructor(store = assistantAvatarPortraitStore, previews = assistantAvatarPreviewStore, crop = createAssistantAvatarPortraitFromPreview, createUrl = (blob) => URL.createObjectURL(blob), revokeUrl = (url) => URL.revokeObjectURL(url), overrides = assistantAvatarPortraitOverrideStore) {
+				this.store = store;
+				this.previews = previews;
+				this.crop = crop;
+				this.createUrl = createUrl;
+				this.revokeUrl = revokeUrl;
+				this.overrides = overrides;
+			}
+			/** 编辑器仅在用户打开时读取完整静态帧，普通头像订阅不增加素材加载。 */
+			async getSource(model, renderer, signal) {
+				const asset = resolveAssistantAvatarAsset(model, "dialog");
+				const manual = await this.overrides.read(assistantAvatarPortraitKey(model, renderer), signal).catch(() => void 0);
+				const withArea = (frame) => ({
+					...frame,
+					...manual?.cropAreaPercentages === void 0 ? {} : { cropAreaPercentages: manual.cropAreaPercentages }
+				});
+				if (renderer?.previewVersion !== void 0) for (const surface of ["dialog", "floating"]) {
+					if (!sameAsset(asset, resolveAssistantAvatarAsset(model, surface))) continue;
+					const frame = await this.previews.read(assistantAvatarPreviewKey(model, surface, renderer.previewVersion), signal).catch(() => void 0);
+					if (signal.aborted) return void 0;
+					if (validAssistantAvatarPreview(frame)) return withArea(frame);
+				}
+				if (signal.aborted) return void 0;
+				const frame = await renderer?.createPortraitSource?.(asset, signal);
+				if (signal.aborted) return void 0;
+				if (validAssistantAvatarPreview(frame)) return withArea(frame);
+				const fallback = manual ?? await this.store.read(assistantAvatarPortraitKey(model, renderer), signal);
+				return fallback === void 0 ? void 0 : {
+					blob: fallback.blob,
+					width: fallback.width,
+					height: fallback.height
+				};
+			}
+			/** 先确保持久化成功才发布，存储失败和取消都保留当前头像。 */
+			async setPortrait(model, renderer, preview, signal) {
+				if (!validPortrait(preview)) throw new TypeError("avatar_portrait_invalid");
+				signal.throwIfAborted();
+				const entry = this.entry(model, renderer), controller = new AbortController();
+				entry.controller?.abort();
+				entry.controller = controller;
+				const abort = () => controller.abort();
+				signal.addEventListener("abort", abort, { once: true });
+				try {
+					const saved = await this.overrides.write(entry.snapshot.key, model.id, "dialog", preview, controller.signal);
+					signal.throwIfAborted();
+					if (!saved || entry.controller !== controller || controller.signal.aborted) throw new Error("avatar_portrait_write_failed");
+					this.publish(entry, preview);
+					entry.completed = true;
+				} finally {
+					signal.removeEventListener("abort", abort);
+					if (entry.controller === controller) entry.controller = void 0;
+				}
+			}
+			getSnapshot(model, renderer) {
+				return this.entry(model, renderer).snapshot;
+			}
+			subscribe(model, renderer, listener) {
+				const entry = this.entry(model, renderer);
+				entry.listeners.add(listener);
+				return () => {
+					entry.listeners.delete(listener);
+					this.trim();
+				};
+			}
+			retain(model, renderer) {
+				const entry = this.entry(model, renderer);
+				entry.refs++;
+				entry.touched = ++this.clock;
+				if (!entry.completed && entry.controller === void 0) this.start(entry);
+				return () => {
+					entry.refs = Math.max(0, entry.refs - 1);
+					if (entry.refs === 0) {
+						entry.controller?.abort();
+						entry.controller = void 0;
+					}
+					this.trim();
+				};
+			}
+			/** 插槽已绘制的帧优先于临时渲染任务；取消旧任务并隔离迟到结果。 */
+			offerPreview(model, surface, renderer, preview) {
+				if (!validAssistantAvatarPreview(preview)) return;
+				const asset = resolveAssistantAvatarAsset(model, surface);
+				for (const entry of this.entries.values()) {
+					if (entry.refs === 0 || !entry.overrideChecked || entry.snapshot.url !== void 0 || entry.renderer !== renderer || !sameAsset(entry.asset, asset)) continue;
+					entry.controller?.abort();
+					const controller = new AbortController();
+					entry.controller = controller;
+					entry.completed = false;
+					this.crop(preview, controller.signal).then((portrait) => this.commit(entry, controller, portrait)).catch(() => void 0).finally(() => this.finish(entry, controller));
+				}
+			}
+			removeModel(id) {
+				for (const entry of this.entries.values()) {
+					if (entry.model.id !== id) continue;
+					entry.controller?.abort();
+					entry.controller = void 0;
+					entry.completed = false;
+					if (entry.snapshot.url !== void 0) this.revokeUrl(entry.snapshot.url);
+					entry.snapshot = { key: entry.snapshot.key };
+					for (const listener of entry.listeners) listener();
+					if (entry.refs === 0 && entry.listeners.size === 0) this.entries.delete(entry.snapshot.key);
+				}
+				this.store.removeModel(id).catch(() => void 0);
+				this.overrides.removeModel(id).catch(() => void 0);
+			}
+			/** 配置窗口销毁时回收仅供本地预览使用的资源地址。 */
+			dispose() {
+				for (const entry of this.entries.values()) {
+					entry.controller?.abort();
+					if (entry.snapshot.url !== void 0) this.revokeUrl(entry.snapshot.url);
+				}
+				this.entries.clear();
+			}
+			entry(model, renderer) {
+				const key = assistantAvatarPortraitKey(model, renderer);
+				let entry = this.entries.get(key);
+				if (entry === void 0) {
+					entry = {
+						model,
+						asset: resolveAssistantAvatarAsset(model, "dialog"),
+						renderer,
+						snapshot: { key },
+						listeners: /* @__PURE__ */ new Set(),
+						refs: 0,
+						touched: ++this.clock,
+						completed: false,
+						overrideChecked: false,
+						controller: void 0
+					};
+					this.entries.set(key, entry);
+				} else if (entry.renderer !== renderer) {
+					entry.controller?.abort();
+					entry.controller = void 0;
+					entry.renderer = renderer;
+					entry.completed = entry.snapshot.url !== void 0;
+				}
+				return entry;
+			}
+			start(entry) {
+				const controller = new AbortController();
+				entry.controller = controller;
+				this.load(entry, controller.signal).then((preview) => this.commit(entry, controller, preview)).catch(() => void 0).finally(() => this.finish(entry, controller));
+			}
+			async load(entry, signal) {
+				const manual = await this.overrides.read(entry.snapshot.key, signal).catch(() => void 0);
+				if (signal.aborted || validPortrait(manual)) return signal.aborted ? void 0 : manual;
+				entry.overrideChecked = true;
+				const cached = await this.store.read(entry.snapshot.key, signal).catch(() => void 0);
+				if (signal.aborted || validPortrait(cached)) return signal.aborted ? void 0 : cached;
+				const version = entry.renderer?.previewVersion;
+				if (version !== void 0) for (const surface of ["dialog", "floating"]) {
+					if (!sameAsset(entry.asset, resolveAssistantAvatarAsset(entry.model, surface))) continue;
+					const frame = await this.previews.read(assistantAvatarPreviewKey(entry.model, surface, version), signal).catch(() => void 0);
+					if (signal.aborted) return void 0;
+					if (frame === void 0) continue;
+					const portrait = await this.crop(frame, signal);
+					if (portrait !== void 0 || signal.aborted) return portrait;
+				}
+				return signal.aborted ? void 0 : entry.renderer?.createPortrait?.(entry.asset, signal);
+			}
+			commit(entry, controller, preview) {
+				if (entry.controller !== controller || controller.signal.aborted || !validPortrait(preview)) return;
+				this.publish(entry, preview);
+				this.store.write(entry.snapshot.key, entry.model.id, "dialog", preview, controller.signal).catch(() => void 0);
+			}
+			publish(entry, preview) {
+				const previous = entry.snapshot.url, url = this.createUrl(preview.blob);
+				entry.snapshot = {
+					key: entry.snapshot.key,
+					url
+				};
+				entry.touched = ++this.clock;
+				for (const listener of entry.listeners) listener();
+				if (previous !== void 0) this.revokeUrl(previous);
+			}
+			finish(entry, controller) {
+				if (entry.controller !== controller) return;
+				entry.controller = void 0;
+				entry.completed = !controller.signal.aborted;
+				this.trim();
+			}
+			trim() {
+				const idle = [...this.entries.values()].filter((entry) => entry.refs === 0 && entry.listeners.size === 0).sort((a, b) => b.touched - a.touched);
+				for (const entry of idle.slice(8)) {
+					entry.controller?.abort();
+					if (entry.snapshot.url !== void 0) this.revokeUrl(entry.snapshot.url);
+					this.entries.delete(entry.snapshot.key);
+				}
+			}
+		};
+		const services = /* @__PURE__ */ new WeakMap();
+		function bindAssistantAvatarPortraitService(client, service) {
+			services.set(client, service);
+		}
+		function getAssistantAvatarPortraitService(client) {
+			let service = services.get(client);
+			if (service === void 0) {
+				service = new AssistantAvatarPortraitService();
+				services.set(client, service);
+			}
+			return service;
+		}
+		//#endregion
+		//#region src/client/avatar/slot.ts
+		/** 两个容器只调用这个插槽；渲染错误始终被限制在形象区域。 */
+		function AssistantAvatarSlot(props) {
+			const model = resolveAssistantAvatarAsset(props.model, props.surface);
+			const registry = getAssistantAvatarRegistry(props.services);
+			const readRenderer = (0, react.useCallback)(() => registry.get(model.renderer), [registry, model.renderer]);
+			const renderer = (0, react.useSyncExternalStore)(registry.subscribe, readRenderer, readRenderer);
+			const runtimeRevision = (0, react.useSyncExternalStore)(subscribeAssistantAvatarRuntime, assistantAvatarRuntimeRevision, assistantAvatarRuntimeRevision);
+			const generation = (0, react.useRef)({
+				renderer,
+				value: 0
+			});
+			if (generation.current.renderer !== renderer) generation.current = {
+				renderer,
+				value: generation.current.value + 1
+			};
+			return (0, react.createElement)(AvatarErrorBoundary, {
+				key: `${JSON.stringify(props.model)}:${generation.current.value}:${model.renderer === "live2d" ? runtimeRevision : 0}`,
+				fallback: (0, react.createElement)(AvatarFallback, props)
+			}, (0, react.createElement)(AvatarContent, {
+				...props,
+				model,
+				renderer
+			}));
+		}
+		function AvatarContent({ services, model, state, surface, size, renderer, showDiagnostics, transient }) {
+			const [error, setError] = (0, react.useState)("");
+			const [progress, setProgress] = (0, react.useState)(() => renderer?.reportsLoading === true ? { phase: renderer.initialLoadPhase ?? "resources" } : void 0);
+			const { preview, onPreview, discard } = useAssistantAvatarPreview(model, surface, transient ? void 0 : renderer?.previewVersion);
+			const previewKey = assistantAvatarPreviewKey(model, surface, renderer?.previewVersion ?? "");
+			const publishPreview = (0, react.useCallback)((snapshot) => {
+				onPreview?.(snapshot);
+				if (!transient && renderer !== void 0) getAssistantAvatarPortraitService(services).offerPreview(model, surface, renderer, snapshot);
+			}, [
+				services,
+				previewKey,
+				surface,
+				renderer,
+				onPreview,
+				transient
+			]);
+			const onError = (0, react.useCallback)((message) => {
+				discard(true);
+				setError(message);
+			}, [discard]);
+			const onLoadProgress = (0, react.useCallback)((next) => setProgress(next), []);
+			const t = require_transport.useCodingNsTranslator(services.locale);
+			const diagnostics = services.stage0 === true && showDiagnostics !== false;
+			const props = {
+				model,
+				state,
+				surface,
+				size,
+				onError,
+				onLoadProgress,
+				diagnostics,
+				...onPreview === void 0 ? {} : { onPreview: publishPreview }
+			};
+			const component = renderer?.component;
+			const showCache = diagnostics && (renderer?.reportsCache === true || progress?.cacheBefore !== void 0 || progress?.cacheAfter !== void 0);
+			const content = component === void 0 ? null : (0, react.createElement)(component, props);
+			if (error !== "" || content === null) return (0, react.createElement)(AvatarFallback, {
+				services,
+				model,
+				state,
+				surface,
+				size,
+				...transient === void 0 ? {} : { transient },
+				...error === "" ? {} : { error }
+			});
+			return (0, react.createElement)("div", {
+				"data-codingns-avatar-slot": surface,
+				"data-codingns-avatar-renderer": model.renderer,
+				"data-codingns-avatar-state": state,
+				"aria-label": t("avatar.character", { name: model.name }),
+				"aria-busy": progress !== void 0 && progress.phase !== "ready",
+				style: {
+					position: "relative",
+					display: "grid",
+					justifyItems: "center",
+					maxWidth: "100%",
+					minWidth: 0
+				}
+			}, (0, react.createElement)("div", { style: {
+				opacity: progress !== void 0 && progress.phase !== "ready" ? 0 : 1,
+				transition: "opacity .25s ease",
+				maxWidth: "100%"
+			} }, content), preview === void 0 ? null : (0, react.createElement)("img", {
+				key: preview.url,
+				src: preview.url,
+				alt: "",
+				"aria-hidden": true,
+				draggable: false,
+				"data-codingns-avatar-preview": true,
+				onError: () => discard(),
+				style: {
+					position: "absolute",
+					inset: 0,
+					width: "100%",
+					height: "100%",
+					objectFit: "contain",
+					pointerEvents: "none",
+					opacity: progress !== void 0 && progress.phase !== "ready" ? 1 : 0,
+					transition: "opacity .25s ease"
+				}
+			}), progress === void 0 || progress.phase === "ready" && (!diagnostics || progress.elapsedMs === void 0 && !showCache) ? null : (0, react.createElement)(AssistantAvatarLoading, {
+				progress,
+				size,
+				t,
+				showCache,
+				diagnostics,
+				preview: preview !== void 0,
+				animationOnly: transient === true
+			}));
+		}
+		const loadErrorKeys = {
+			avatar_runtime_unavailable: "avatar.live2dEngineUnavailable",
+			avatar_runtime_invalid: "avatar.live2dRuntimeInvalid",
+			avatar_webgl_unavailable: "avatar.live2dWebglUnavailable"
+		};
+		function AvatarFallback(props) {
+			const t = require_transport.useCodingNsTranslator(props.services.locale);
+			const key = props.error === void 0 ? void 0 : loadErrorKeys[props.error];
+			const detail = props.error === void 0 ? null : (0, react.createElement)("small", {
+				"data-codingns-avatar-load-error": true,
+				style: {
+					display: "block",
+					marginTop: 8,
+					overflowWrap: "anywhere"
+				}
+			}, t("avatar.loadErrorReason", { reason: key === void 0 ? props.error : t(key) }));
+			if (props.transient) return (0, react.createElement)("div", {
+				role: "alert",
+				"data-codingns-avatar-preview-failed": true,
+				style: require_theme.dshSettingsHelpStyle
+			}, t(props.model.renderer === "live2d" ? "avatar.temporaryLive2dLoadFailed" : "avatar.temporaryLoadFailed"), detail);
+			return (0, react.createElement)("div", {
+				"data-codingns-avatar-fallback": true,
+				style: {
+					display: "grid",
+					justifyItems: "center",
+					maxWidth: "100%"
+				}
+			}, (0, react.createElement)(BuiltinAssistantAvatar, {
+				...props,
+				model: BUILTIN_ASSISTANT_AVATAR,
+				onError: () => void 0
+			}), (0, react.createElement)("span", {
+				role: "status",
+				style: {
+					...require_theme.dshSettingsHelpStyle,
+					color: require_theme.dshThemeColor.labelSecondary,
+					textAlign: "center",
+					maxWidth: props.size
+				}
+			}, t("avatar.loadFailed")), detail);
+		}
+		var AvatarErrorBoundary = class extends react.Component {
+			state = { failed: false };
+			static getDerivedStateFromError() {
+				return { failed: true };
+			}
+			render() {
+				return this.state.failed ? this.props.fallback : this.props.children;
+			}
+		};
+		//#endregion
+		//#region src/client/avatar/portrait.ts
+		/** 只订阅当前形象，切换时立即回到对应占位，不显示上一角色的迟到头像。 */
+		function useAssistantAvatarPortrait(services, model) {
+			const registry = getAssistantAvatarRegistry(services);
+			const rendererId = resolveAssistantAvatarAsset(model, "dialog").renderer;
+			const readRenderer = (0, react.useCallback)(() => registry.get(rendererId), [registry, rendererId]);
+			const renderer = (0, react.useSyncExternalStore)(registry.subscribe, readRenderer, readRenderer);
+			const service = getAssistantAvatarPortraitService(services);
+			const key = assistantAvatarPortraitKey(model, renderer);
+			const read = (0, react.useCallback)(() => service.getSnapshot(model, renderer), [
+				service,
+				key,
+				renderer
+			]);
+			const subscribe = (0, react.useCallback)((listener) => service.subscribe(model, renderer, listener), [
+				service,
+				key,
+				renderer
+			]);
+			const portrait = (0, react.useSyncExternalStore)(subscribe, read, read);
+			(0, react.useEffect)(() => service.retain(model, renderer), [
+				service,
+				key,
+				renderer
+			]);
+			return {
+				url: portrait.url ?? BUILTIN_ASSISTANT_AVATAR_SOURCES[model.id] ?? BUILTIN_ASSISTANT_AVATAR_SOURCES[BUILTIN_ASSISTANT_AVATAR.id],
+				generated: portrait.url !== void 0
+			};
+		}
+		/** 消息头像仅显示静态 PNG；名字和按钮本身提供无障碍说明。 */
+		function AssistantAvatarPortrait({ services, model, size = 28 }) {
+			const portrait = useAssistantAvatarPortrait(services, model);
+			return (0, react.createElement)("span", {
+				"data-codingns-avatar-portrait": model.id,
+				"aria-hidden": true,
+				style: {
+					display: "inline-flex",
+					width: size,
+					height: size,
+					flex: `0 0 ${size}px`,
+					borderRadius: "50%",
+					overflow: "hidden"
+				}
+			}, (0, react.createElement)("img", {
+				src: portrait.url,
+				alt: "",
+				draggable: false,
+				style: assistantAvatarPortraitImageStyle(portrait.generated),
+				onError: (event) => fallbackPortraitImage(event.currentTarget)
+			}));
+		}
+		function assistantAvatarPortraitImageStyle(generated) {
+			return {
+				display: "block",
+				width: "100%",
+				height: "100%",
+				objectFit: "contain",
+				pointerEvents: "none",
+				...generated ? {} : { transform: "translateY(26%) scale(1.7)" }
+			};
+		}
+		/** 更新填充而不重建原生按钮，保留点击、焦点和无障碍属性。 */
+		function fillAssistantAvatarButton(button, portrait) {
+			let image = button.querySelector("img[data-codingns-avatar-button-portrait]");
+			if (image === null) {
+				image = button.ownerDocument.createElement("img");
+				image.alt = "";
+				image.draggable = false;
+				image.setAttribute("aria-hidden", "true");
+				image.setAttribute("data-codingns-avatar-button-portrait", "true");
+				button.replaceChildren(image);
+			}
+			image.style.transform = "";
+			Object.assign(image.style, assistantAvatarPortraitImageStyle(portrait.generated));
+			image.onerror = () => fallbackPortraitImage(image);
+			if (image.getAttribute("src") !== portrait.url) image.src = portrait.url;
+			button.style.overflow = "hidden";
+		}
+		function fallbackPortraitImage(image) {
+			const source = BUILTIN_ASSISTANT_AVATAR_SOURCES[BUILTIN_ASSISTANT_AVATAR.id];
+			if (image.getAttribute("src") === source) return;
+			Object.assign(image.style, assistantAvatarPortraitImageStyle(false));
+			image.src = source;
+		}
+		//#endregion
+		//#region src/client/avatar/manager.ts
+		var AssistantAvatarAdapterRegistry = class extends AssistantAvatarRegistration {
+			constructor() {
+				super(BUILTIN_ASSISTANT_AVATAR_ADAPTERS);
+			}
+			parse(manifest, manifestUrl, adapterId = "auto") {
+				const adapter = adapterId === "auto" ? this.getSnapshot().find((item) => item.matches(manifest)) : this.get(adapterId);
+				if (adapter === void 0 || !adapter.matches(manifest)) throw new TypeError("无法识别形象包，或所选适配器未注册");
+				const model = adapter.parse(manifest, { manifestUrl });
+				const result = {
+					...model,
+					package: {
+						...model.package,
+						adapterId: adapter.id,
+						manifestUrl
+					}
+				};
+				validateAssistantAvatarModel(result);
+				return copyAssistantAvatarModel(result);
+			}
+		};
+		/** 唯一写入入口：包导入与手工素材最终都变成同一清单，不拥有语音或会话。 */
+		var AssistantAvatarManager = class {
+			settings;
+			adapters;
+			fetchManifest;
+			baseUrl;
+			rpc;
+			removePortrait;
+			writes = Promise.resolve();
+			appearance;
+			catalog = [];
+			constructor(settings, adapters = new AssistantAvatarAdapterRegistry(), fetchManifest = (...args) => fetch(...args), baseUrl = typeof location === "undefined" ? void 0 : location.href, rpc, removePortrait = (id) => {
+				assistantAvatarPortraitStore.removeModel(id).catch(() => void 0);
+				assistantAvatarPortraitOverrideStore.removeModel(id).catch(() => void 0);
+			}) {
+				this.settings = settings;
+				this.adapters = adapters;
+				this.fetchManifest = fetchManifest;
+				this.baseUrl = baseUrl;
+				this.rpc = rpc;
+				this.removePortrait = removePortrait;
+			}
+			/** React 和扩展都可以订阅这一份稳定快照，语音设置变化不会刷新形象列表。 */
+			getSnapshot = () => {
+				const next = normalizeAssistantAppearance(this.settings.getSnapshot().value?.assistant.appearance);
+				if (this.appearance === void 0 || !sameSettingsValue(this.appearance, next)) {
+					this.appearance = next;
+					this.catalog = Object.freeze(listAssistantAvatars(next));
+				}
+				return this.appearance;
+			};
+			subscribe = (listener) => {
+				let previous = this.getSnapshot();
+				return this.settings.subscribe(() => {
+					const next = this.getSnapshot();
+					if (previous === next) return;
+					previous = next;
+					listener();
+				});
+			};
+			getAppearance() {
+				return this.getSnapshot();
+			}
+			list() {
+				this.getSnapshot();
+				return this.catalog;
+			}
+			getSelected() {
+				return selectedAssistantAvatar(this.getAppearance());
+			}
+			select(id) {
+				return this.write((current) => {
+					this.requireModel(current, id);
+					return {
+						...current,
+						selectedId: id
+					};
+				});
+			}
+			async add(model) {
+				validateAssistantAvatarModel(model);
+				const copy = copyAssistantAvatarModel(model);
+				return this.insert(copy);
+			}
+			async update(model) {
+				this.requireCustom(model.id);
+				validateAssistantAvatarModel(model);
+				const copy = copyAssistantAvatarModel(model);
+				return this.write((current) => {
+					this.requireModel(current, copy.id);
+					return {
+						...current,
+						models: current.models.some((item) => item.id === copy.id) ? current.models.map((item) => item.id === copy.id ? copy : item) : [...current.models, copy]
+					};
+				});
+			}
+			async remove(id) {
+				this.requireCustom(id);
+				const installation = this.list().find((model) => model.id === id)?.package?.installationId;
+				await this.write((current) => {
+					this.requireModel(current, id);
+					return {
+						...current,
+						selectedId: current.selectedId === id ? BUILTIN_ASSISTANT_AVATAR.id : current.selectedId,
+						models: current.models.filter((item) => item.id !== id)
+					};
+				});
+				assistantAvatarPreviewStore.removeModel(id).catch(() => void 0);
+				this.removePortrait(id);
+				if (installation !== void 0 && !this.list().some((model) => model.package?.installationId === installation)) await this.call("remove", { id: installation });
+			}
+			async configure(update) {
+				if (Object.keys(update).some((key) => ![
+					"floatingEnabled",
+					"dialogEnabled",
+					"floatingSize",
+					"dialogSize"
+				].includes(key))) throw new TypeError("展示设置字段无效");
+				return this.write((current) => ({
+					...current,
+					...update
+				}));
+			}
+			/** 必须从独立协议操作调用；展示配置不会隐式开启第三方目录。 */
+			setThirdPartyEnabled(enabled) {
+				return this.write((current) => {
+					const { thirdPartyConsent: _previous, ...appearance } = current;
+					return enabled ? {
+						...appearance,
+						thirdPartyConsent: {
+							version: ASSISTANT_AVATAR_CONSENT_VERSION,
+							acceptedAt: Date.now()
+						}
+					} : appearance;
+				});
+			}
+			/** 引擎许可与第三方素材协议分开记录；撤销同意不卸载已安装引擎。 */
+			setEngineEnabled(enabled) {
+				return this.write((current) => {
+					const { engineConsent: _previous, ...appearance } = current;
+					return enabled ? {
+						...appearance,
+						engineConsent: {
+							version: ASSISTANT_AVATAR_ENGINE_CONSENT_VERSION,
+							acceptedAt: Date.now()
+						}
+					} : appearance;
+				});
+			}
+			/** 只读探测；已确认许可后由安装接口写入 CodingNS 自有引擎目录。 */
+			async engineStatus(signal) {
+				return readEngineStatus(await this.call("engineStatus", {}, signal));
+			}
+			async installEngine(signal) {
+				this.requireWritable();
+				this.requireEngineConsent();
+				signal?.throwIfAborted();
+				const result = readEngineStatus(await this.call("installEngine", { engineConsent: this.getAppearance().engineConsent }, signal));
+				signal?.throwIfAborted();
+				if (!result.installed) throw new Error("Live2D 引擎安装后仍未就绪，请重试");
+				invalidateAssistantAvatarRuntime();
+				return result;
+			}
+			async getCatalog(signal) {
+				this.requireConsent();
+				signal?.throwIfAborted();
+				return this.call("catalog", {}, signal);
+			}
+			async previewCatalog(id, revision, lease, signal) {
+				this.requireWritable();
+				this.requireConsent();
+				signal?.throwIfAborted();
+				const result = await this.call("previewCatalog", {
+					id,
+					revision,
+					lease
+				}, signal);
+				validateAssistantAvatarModel(result.model);
+				if (result.lease !== lease) throw new TypeError("临时形象预览标识不一致");
+				return result;
+			}
+			async releasePreview(lease) {
+				await this.call("releasePreview", { lease });
+			}
+			async keepPreview(lease) {
+				await this.call("keepPreview", { lease });
+			}
+			async installCatalog(id, revision, licenseAccepted, signal, lease) {
+				this.requireWritable();
+				this.requireConsent();
+				signal?.throwIfAborted();
+				if (!licenseAccepted) throw new TypeError("请确认所选形象的许可及应用");
+				const installed = await this.call("installCatalog", {
+					id,
+					revision,
+					licenseAccepted,
+					...lease === void 0 ? {} : { lease }
+				}, signal);
+				return this.registerInstallation(installed, signal, true);
+			}
+			/** 只读清单 JSON；网络/解析/取消失败都不新增形象，不修改当前选择。 */
+			async importPackage(source, adapterId = "auto", signal) {
+				this.requireWritable();
+				signal?.throwIfAborted();
+				if (!isAssistantAvatarSource(source)) throw new TypeError("形象包清单地址无效");
+				const url = new URL(source, this.baseUrl).href;
+				const response = await this.fetchManifest(url, {
+					credentials: "same-origin",
+					...signal === void 0 ? {} : { signal }
+				});
+				if (!response.ok) throw new Error(`avatar_manifest_http_${response.status}`);
+				const text = await response.text();
+				if (text.length > 262144) throw new TypeError("形象包清单过大");
+				signal?.throwIfAborted();
+				const model = this.adapters.parse(JSON.parse(text), response.url || url, adapterId);
+				await this.insert(model, signal);
+				return model;
+			}
+			/** 新入口在 Host 安装完整素材后才写入形象列表；旧外链导入 API 保持兼容。 */
+			async discover(source, signal) {
+				this.requireWritable();
+				signal?.throwIfAborted();
+				return this.call("discover", { source }, signal);
+			}
+			async installPackage(source, adapterId = "auto", signal) {
+				this.requireWritable();
+				signal?.throwIfAborted();
+				const installed = await this.call("install", {
+					source,
+					adapterId
+				}, signal);
+				return this.registerInstallation(installed, signal);
+			}
+			async registerInstallation(installed, signal, fromCatalog = false) {
+				let replacedInstallation;
+				try {
+					validateAssistantAvatarModel(installed.model);
+					await this.write((current) => {
+						signal?.throwIfAborted();
+						if (fromCatalog && !hasAssistantAvatarConsent(current.thirdPartyConsent)) throw new TypeError("第三方形象列表已关闭");
+						const existing = current.models.find((model) => model.id === installed.model.id);
+						replacedInstallation = existing?.package?.installationId;
+						const sameSource = existing?.package?.manifestUrl !== void 0 && existing.package.manifestUrl === installed.model.package?.manifestUrl;
+						if (existing !== void 0 && existing.package?.installationId !== installed.id && !sameSource) throw new TypeError("形象 ID 已存在，请先移除已有记录");
+						if (installed.model.package?.installationId !== installed.id || !/^[a-f0-9]{64}$/u.test(installed.id)) throw new TypeError("形象安装结果无效");
+						return {
+							...current,
+							selectedId: installed.model.id,
+							models: existing === void 0 ? [...current.models, installed.model] : current.models.map((model) => model.id === existing.id ? installed.model : model)
+						};
+					});
+					if (replacedInstallation !== void 0 && replacedInstallation !== installed.id && !this.list().some((model) => model.package?.installationId === replacedInstallation)) await this.call("remove", { id: replacedInstallation }).catch(() => void 0);
+					return installed.model;
+				} catch (error) {
+					if (installed.created && !this.list().some((model) => model.package?.installationId === installed.id)) await this.call("remove", { id: installed.id }).catch(() => void 0);
+					throw error;
+				}
+			}
+			async call(action, payload, signal) {
+				if (this.rpc === void 0) throw new Error("形象本地安装服务不可用");
+				const result = await this.rpc.call(require_transport.CODINGNS_RPC_CHANNEL, `avatar/${action}`, payload, signal);
+				if (!result.ok) throw new Error(result.error.message);
+				return result.value;
+			}
+			insert(model, signal) {
+				this.requireCustom(model.id);
+				return this.write((current) => {
+					signal?.throwIfAborted();
+					if (current.models.some((item) => item.id === model.id)) throw new TypeError("形象 ID 已存在，请更新已有形象或使用其他 ID");
+					return {
+						...current,
+						selectedId: model.id,
+						models: [...current.models, model]
+					};
+				});
+			}
+			write(update) {
+				const task = this.writes.then(() => this.saveAppearance(update));
+				this.writes = task.catch(() => void 0);
+				return task;
+			}
+			async saveAppearance(update) {
+				for (let attempt = 0; attempt < 3; attempt++) {
+					const snapshot = this.requireWritable();
+					const current = normalizeAssistantAppearance(snapshot.value.assistant.appearance);
+					const next = update(current);
+					validateAssistantAppearance(next);
+					if (JSON.stringify(next) === JSON.stringify(current)) return;
+					try {
+						if (!await this.settings.mutate([{
+							op: "set",
+							path: ["assistant", "appearance"],
+							value: next
+						}], snapshot.revision)) throw new Error("形象设置保存被拒绝，请刷新后重试");
+						return;
+					} catch (error) {
+						if (!isSettingsConflict(error) || this.settings.reload === void 0) throw error;
+						if (attempt === 2) throw new Error("形象设置持续被其他操作更新，请稍后重试", { cause: error });
+						await this.settings.reload();
+					}
+				}
+			}
+			requireWritable() {
+				const snapshot = this.settings.getSnapshot();
+				if (snapshot.status !== "ready" || snapshot.value === void 0) throw new Error("形象设置尚未就绪");
+				if (!snapshot.writable) throw new Error("当前形象设置为只读");
+				return snapshot;
+			}
+			requireConsent() {
+				if (!hasAssistantAvatarConsent(this.getAppearance().thirdPartyConsent)) throw new TypeError("请先同意第三方形象使用说明");
+			}
+			requireEngineConsent() {
+				if (!hasAssistantAvatarEngineConsent(this.getAppearance().engineConsent)) throw new TypeError("请先确认 Live2D 引擎许可");
+			}
+			requireModel(current, id) {
+				if (!listAssistantAvatars(current).some((item) => item.id === id)) throw new TypeError("形象不在清单中");
+			}
+			requireCustom(id) {
+				if (getBuiltinAssistantAvatar(id) !== void 0) throw new TypeError("内置形象不可替换或删除");
+			}
+		};
+		/** 引擎状态来自 Host；形状异常按不可用处理，避免把坏数据当成就绪。 */
+		function readEngineStatus(value) {
+			const status = value;
+			if (status === null || typeof status !== "object" || typeof status.installed !== "boolean" || typeof status.version !== "string" || ![
+				"managed",
+				"dependency",
+				"missing"
+			].includes(status.source)) throw new TypeError("Live2D 引擎状态无效");
+			return {
+				installed: status.installed,
+				version: status.version,
+				source: status.source
+			};
+		}
+		/** 兼容原生异常、RPC 稳定错误码，以及旧 Host 只透传正文的响应。 */
+		function isSettingsConflict(error) {
+			if (error === null || typeof error !== "object") return false;
+			const failure = error;
+			return failure.code === "SETTINGS_CONFLICT" || failure.code === "SettingsConflictError" || failure.name === "SettingsConflictError" || typeof failure.message === "string" && /^settings namespace ".+" changed since it was read \(expected revision /u.test(failure.message);
+		}
+		const managers = /* @__PURE__ */ new WeakMap();
+		function bindAssistantAvatarManager(services, manager) {
+			managers.set(services, manager);
+		}
+		function getAssistantAvatarManager(services) {
+			let manager = managers.get(services);
+			if (manager === void 0) {
+				manager = new AssistantAvatarManager(services.settings, void 0, void 0, void 0, services.rpc, (id) => getAssistantAvatarPortraitService(services).removeModel(id));
+				managers.set(services, manager);
+			}
+			return manager;
+		}
+		/** 扩展应将注销函数登记到 context.resources，已导入的数据不会随适配器注销丢失。 */
+		function registerAssistantAvatarAdapter(services, adapter) {
+			return getAssistantAvatarManager(services).adapters.register(adapter);
+		}
+		//#endregion
+		Object.defineProperty(exports, "ASSISTANT_AVATAR_CONSENT_VERSION", {
+			enumerable: true,
+			get: function() {
+				return ASSISTANT_AVATAR_CONSENT_VERSION;
+			}
+		});
+		Object.defineProperty(exports, "ASSISTANT_AVATAR_ENGINE_CONSENT_VERSION", {
+			enumerable: true,
+			get: function() {
+				return ASSISTANT_AVATAR_ENGINE_CONSENT_VERSION;
+			}
+		});
+		Object.defineProperty(exports, "ASSISTANT_PERSONALITY_MAX_CHARS", {
+			enumerable: true,
+			get: function() {
+				return ASSISTANT_PERSONALITY_MAX_CHARS;
+			}
+		});
+		Object.defineProperty(exports, "ASSISTANT_TTS_PARAMETER_LIMITS", {
+			enumerable: true,
+			get: function() {
+				return ASSISTANT_TTS_PARAMETER_LIMITS;
+			}
+		});
+		Object.defineProperty(exports, "ASSISTANT_TTS_PATH", {
+			enumerable: true,
+			get: function() {
+				return ASSISTANT_TTS_PATH;
+			}
+		});
+		Object.defineProperty(exports, "ASSISTANT_VOICE_SITES", {
+			enumerable: true,
+			get: function() {
+				return ASSISTANT_VOICE_SITES;
+			}
+		});
+		Object.defineProperty(exports, "AssistantAvatarAdapterRegistry", {
+			enumerable: true,
+			get: function() {
+				return AssistantAvatarAdapterRegistry;
+			}
+		});
+		Object.defineProperty(exports, "AssistantAvatarLoading", {
+			enumerable: true,
+			get: function() {
+				return AssistantAvatarLoading;
+			}
+		});
+		Object.defineProperty(exports, "AssistantAvatarManager", {
+			enumerable: true,
+			get: function() {
+				return AssistantAvatarManager;
+			}
+		});
+		Object.defineProperty(exports, "AssistantAvatarPortrait", {
+			enumerable: true,
+			get: function() {
+				return AssistantAvatarPortrait;
+			}
+		});
+		Object.defineProperty(exports, "AssistantAvatarPortraitService", {
+			enumerable: true,
+			get: function() {
+				return AssistantAvatarPortraitService;
+			}
+		});
+		Object.defineProperty(exports, "AssistantAvatarSlot", {
+			enumerable: true,
+			get: function() {
+				return AssistantAvatarSlot;
+			}
+		});
+		Object.defineProperty(exports, "BUILTIN_ASSISTANT_AVATAR", {
+			enumerable: true,
+			get: function() {
+				return BUILTIN_ASSISTANT_AVATAR;
+			}
+		});
+		Object.defineProperty(exports, "DEFAULT_ASSISTANT_TTS_PARAMETERS", {
+			enumerable: true,
+			get: function() {
+				return DEFAULT_ASSISTANT_TTS_PARAMETERS;
+			}
+		});
+		Object.defineProperty(exports, "MOSS_BUILTIN_VOICES", {
+			enumerable: true,
+			get: function() {
+				return MOSS_BUILTIN_VOICES;
+			}
+		});
+		Object.defineProperty(exports, "accepted", {
+			enumerable: true,
+			get: function() {
+				return accepted;
+			}
+		});
+		Object.defineProperty(exports, "assistantAvatarPortraitKey", {
+			enumerable: true,
+			get: function() {
+				return assistantAvatarPortraitKey;
+			}
+		});
+		Object.defineProperty(exports, "assistantAvatarPortraitOverrideStore", {
+			enumerable: true,
+			get: function() {
+				return assistantAvatarPortraitOverrideStore;
+			}
+		});
+		Object.defineProperty(exports, "bindAssistantAvatarManager", {
+			enumerable: true,
+			get: function() {
+				return bindAssistantAvatarManager;
+			}
+		});
+		Object.defineProperty(exports, "bindAssistantAvatarPortraitService", {
+			enumerable: true,
+			get: function() {
+				return bindAssistantAvatarPortraitService;
+			}
+		});
+		Object.defineProperty(exports, "bindAssistantAvatarRegistry", {
+			enumerable: true,
+			get: function() {
+				return bindAssistantAvatarRegistry;
+			}
+		});
+		Object.defineProperty(exports, "builtinAssistantAvatarLabelKey", {
+			enumerable: true,
+			get: function() {
+				return builtinAssistantAvatarLabelKey;
+			}
+		});
+		Object.defineProperty(exports, "captureAssistantAvatarPreview", {
+			enumerable: true,
+			get: function() {
+				return captureAssistantAvatarPreview;
+			}
+		});
+		Object.defineProperty(exports, "clampAssistantAvatarPosition", {
+			enumerable: true,
+			get: function() {
+				return clampAssistantAvatarPosition;
+			}
+		});
+		Object.defineProperty(exports, "cropAssistantAvatarPortrait", {
+			enumerable: true,
+			get: function() {
+				return cropAssistantAvatarPortrait;
+			}
+		});
+		Object.defineProperty(exports, "fillAssistantAvatarButton", {
+			enumerable: true,
+			get: function() {
+				return fillAssistantAvatarButton;
+			}
+		});
+		Object.defineProperty(exports, "getAssistantAvatarManager", {
+			enumerable: true,
+			get: function() {
+				return getAssistantAvatarManager;
+			}
+		});
+		Object.defineProperty(exports, "getAssistantAvatarPortraitService", {
+			enumerable: true,
+			get: function() {
+				return getAssistantAvatarPortraitService;
+			}
+		});
+		Object.defineProperty(exports, "getAssistantAvatarPreset", {
+			enumerable: true,
+			get: function() {
+				return getAssistantAvatarPreset;
+			}
+		});
+		Object.defineProperty(exports, "getAssistantAvatarRegistry", {
+			enumerable: true,
+			get: function() {
+				return getAssistantAvatarRegistry;
+			}
+		});
+		Object.defineProperty(exports, "getBuiltinAssistantAvatar", {
+			enumerable: true,
+			get: function() {
+				return getBuiltinAssistantAvatar;
+			}
+		});
+		Object.defineProperty(exports, "getGlobalVoiceAdapter", {
+			enumerable: true,
+			get: function() {
+				return getGlobalVoiceAdapter;
+			}
+		});
+		Object.defineProperty(exports, "hasAssistantAvatarConsent", {
+			enumerable: true,
+			get: function() {
+				return hasAssistantAvatarConsent;
+			}
+		});
+		Object.defineProperty(exports, "hasAssistantAvatarEngineConsent", {
+			enumerable: true,
+			get: function() {
+				return hasAssistantAvatarEngineConsent;
+			}
+		});
+		Object.defineProperty(exports, "initialAssistantAvatarPortraitArea", {
+			enumerable: true,
+			get: function() {
+				return initialAssistantAvatarPortraitArea;
+			}
+		});
+		Object.defineProperty(exports, "isAssistantAvatarSource", {
+			enumerable: true,
+			get: function() {
+				return isAssistantAvatarSource;
+			}
+		});
+		Object.defineProperty(exports, "listAssistantAvatars", {
+			enumerable: true,
+			get: function() {
+				return listAssistantAvatars;
+			}
+		});
+		Object.defineProperty(exports, "normalizeAssistantAppearance", {
+			enumerable: true,
+			get: function() {
+				return normalizeAssistantAppearance;
+			}
+		});
+		Object.defineProperty(exports, "readAssistantPersonality", {
+			enumerable: true,
+			get: function() {
+				return readAssistantPersonality;
+			}
+		});
+		Object.defineProperty(exports, "readAssistantProfile", {
+			enumerable: true,
+			get: function() {
+				return readAssistantProfile;
+			}
+		});
+		Object.defineProperty(exports, "readAssistantTtsParameters", {
+			enumerable: true,
+			get: function() {
+				return readAssistantTtsParameters;
+			}
+		});
+		Object.defineProperty(exports, "readAssistantTtsSettings", {
+			enumerable: true,
+			get: function() {
+				return readAssistantTtsSettings;
+			}
+		});
+		Object.defineProperty(exports, "registerAssistantAvatarAdapter", {
+			enumerable: true,
+			get: function() {
+				return registerAssistantAvatarAdapter;
+			}
+		});
+		Object.defineProperty(exports, "registerAssistantAvatarRenderer", {
+			enumerable: true,
+			get: function() {
+				return registerAssistantAvatarRenderer;
+			}
+		});
+		Object.defineProperty(exports, "registerGlobalVoiceAdapter", {
+			enumerable: true,
+			get: function() {
+				return registerGlobalVoiceAdapter;
+			}
+		});
+		Object.defineProperty(exports, "resolveAssistantAvatarAsset", {
+			enumerable: true,
+			get: function() {
+				return resolveAssistantAvatarAsset;
+			}
+		});
+		Object.defineProperty(exports, "resolveAssistantAvatarState", {
+			enumerable: true,
+			get: function() {
+				return resolveAssistantAvatarState;
+			}
+		});
+		Object.defineProperty(exports, "sameSettingsSnapshot", {
+			enumerable: true,
+			get: function() {
+				return sameSettingsSnapshot;
+			}
+		});
+		Object.defineProperty(exports, "sameSettingsValue", {
+			enumerable: true,
+			get: function() {
+				return sameSettingsValue;
+			}
+		});
+		Object.defineProperty(exports, "selectedAssistantAvatar", {
+			enumerable: true,
+			get: function() {
+				return selectedAssistantAvatar;
+			}
+		});
+		Object.defineProperty(exports, "useAssistantAvatarPortrait", {
+			enumerable: true,
+			get: function() {
+				return useAssistantAvatarPortrait;
+			}
+		});
+		Object.defineProperty(exports, "validateAssistantTtsParameters", {
+			enumerable: true,
+			get: function() {
+				return validateAssistantTtsParameters;
+			}
+		});
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.manager.js.map