@eddyskywalker/dsh-chatgpt-subscription 0.29.0 → 0.31.0

package/lib/client.js

@@ -29,6 +29,7 @@ window.__ModuleLoader__.load({
 		let react = require("react");
 		react = __toESM(react, 1);
 		let react_jsx_runtime = require("react/jsx-runtime");
+		let react_dom = require("react-dom");
 		//#region src/shared/minimax-code-contracts.ts
 		/**
 		* 全线共用的思考档位，按从小到大的顺序排列。
@@ -36,10 +37,9 @@ window.__ModuleLoader__.load({
 		* 设置卡片只渲染这一份列表：档位是线路级的词汇表（`isMinimaxCodeReasoningEffort`
 		* 就是按它校验的），而不是单个模型的能力表。某个模型实际接受哪些档位由
 		* `MinimaxCodeModelOption.reasoningEfforts` 单独给出——把两者合成一份会让卡片
-		* 在给一个只认 `default` 的模型显示 `max` 时无从判断是模型不支持还是文案没写。
+		* 在给一个只认 high 的模型显示 max 时无从判断是模型不支持还是文案没写。
 		*/
 		const MINIMAX_CODE_REASONING_EFFORTS = [
-			"default",
 			"low",
 			"medium",
 			"high",
@@ -158,10 +158,10 @@ window.__ModuleLoader__.load({
 		function CodexImageToolView({ block, loadImage, t }) {
 			const settled = "kind" in block;
 			const isError = settled ? block.isError : false;
-			const prompt = promptFromBlock(block);
+			const prompt = promptFromBlock$1(block);
 			const images = settled && !isError ? imageBlocks(block.content) : [];
 			const label = isError ? t("imageToolFailed") : settled ? t("imageToolDone") : t("imageToolRunning");
-			const summary = prompt ?? textSummary(settled ? block.content : []);
+			const summary = prompt ?? textSummary$1(settled ? block.content : []);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: "dsh-codex-image-tool",
 				"data-state": isError ? "error" : settled ? "done" : "running",
@@ -222,7 +222,7 @@ window.__ModuleLoader__.load({
 				alt: label
 			});
 		}
-		function promptFromBlock(block) {
+		function promptFromBlock$1(block) {
 			const partial = partialPromptFromBlock(block);
 			if (partial !== null) return partial;
 			const raw = "kind" in block ? block.call?.argsRaw : dispatchedArgsRaw(block);
@@ -263,7 +263,7 @@ window.__ModuleLoader__.load({
 			}
 			return result;
 		}
-		function textSummary(blocks) {
+		function textSummary$1(blocks) {
 			const text = blocks.map((block) => block.type === "text" || block.type === "reasoning" ? block.text : "").filter(Boolean).join(" ").trim();
 			return text === "" ? null : text;
 		}
@@ -6800,9 +6800,9 @@ window.__ModuleLoader__.load({
 			regionCn: "中国大陆 (minimax.cn)",
 			regionGlobal: "国际 (minimax.io)",
 			expiresAt: "令牌到期",
-			expiresRemaining: "剩余 {hours} 小时",
+			expiresRemaining: "剩余 {minutes} 分钟",
 			expiresExpired: "已过期",
-			expiresHint: "访问令牌约 24 小时有效；Host 会在令牌过期或上游返回 401 时自动刷新。刷新被拒绝时请回到 MiniMax Code 重新登录。",
+			expiresHint: "访问令牌约 1 小时有效；Host 会在令牌过期或上游返回 401 时自动刷新。刷新被拒绝时请回到 MiniMax Code 重新登录。",
 			signIn: "登录 MiniMax Code",
 			signingIn: "正在申请设备码...",
 			signOut: "登出",
@@ -6894,7 +6894,75 @@ window.__ModuleLoader__.load({
 			capText: "文本",
 			capImage: "图片",
 			loading: "加载中...",
-			unknown: "—"
+			unknown: "—",
+			videoToolTitle: "视频",
+			videoToolRunning: "正在生成视频",
+			videoToolDone: "视频已生成",
+			videoToolFailed: "视频生成失败",
+			videoGenerating: "上游还在生成，完成后会自动出现",
+			videoReading: "正在读取视频",
+			videoTooLarge: "这个视频超出了 {limit} 的整文件读取上限，用系统播放器打开仍然可以看",
+			videoUnreadable: "读不到这个视频的字节，文件可能已经被移动或删除",
+			videoUnplayable: "这个视频的字节解不开，无法播放",
+			videoNoMeta: "这次调用没有留下视频信息，无法定位文件",
+			videoChannelOff: "当前环境没有打开文件读取通道，暂时无法播放",
+			videoFailed: "这次生成没有成功，没有可播放的文件",
+			videoSize: "{size}",
+			videoTitle: "视频",
+			videoCommandLabel: "生成视频",
+			videoCommandDesc: "挑选参数，填成一句话再发送",
+			videoPresetGroup: "常用档位",
+			videoPresetCustom: "自定义…",
+			videoPresetCustomDesc: "打开完整参数表单",
+			videoDialogTitle: "生成视频参数",
+			videoDialogDesc: "填好后会写入输入框，确认无误再发送",
+			videoPromptLabel: "提示词",
+			videoPromptPlaceholder: "描述你想要的画面",
+			videoPromptRequired: "请先填提示词",
+			videoModelLabel: "模型",
+			videoRatioLabel: "比例",
+			videoRatioLockedKeyframes: "给了首帧或末帧，比例固定为自适应",
+			videoRatioLockedTextOnly: "纯文本不能选自适应，服务端没有可自适应的对象",
+			videoDurationLabel: "时长",
+			videoDurationUnit: "秒",
+			videoResolutionLabel: "分辨率",
+			videoWatermarkLabel: "AIGC 水印",
+			videoMediaSection: "参考媒体",
+			videoMediaHint: "填绝对路径或工作区相对路径，一行一个",
+			videoInputImageLabel: "首帧图",
+			videoLastFrameLabel: "末帧图",
+			videoReferenceImagesLabel: "参考图",
+			videoReferenceVideosLabel: "参考视频",
+			videoReferenceVideoDurationsLabel: "参考视频时长",
+			videoReferenceAudiosLabel: "参考音频",
+			videoMediaUnsupported: "{model} 不接受参考图、参考视频或参考音频",
+			videoLastFrameUnsupported: "{model} 不接受末帧图",
+			videoTooManyImages: "参考图有 {count} 张，最多 {limit} 张",
+			videoTooManyVideos: "参考视频有 {count} 个，最多 {limit} 个",
+			videoTooManyAudios: "参考音频有 {count} 个，最多 {limit} 个",
+			videoTooManyTotal: "参考媒体共 {count} 个，最多 {limit} 个",
+			videoDurationInvalid: "{model} 不支持 {duration} 秒",
+			videoSubmit: "填入输入框",
+			videoCancel: "取消",
+			videoClose: "关闭",
+			videoDraftFilled: "参数已填入输入框，确认后发送",
+			videoDraftFailed: "没有找到这个会话的输入框，参数未填入",
+			videoNotMinimax: "这个命令只在 MiniMax Code 会话里可用",
+			videoDefaultsSection: "视频默认参数",
+			videoDefaultsHint: "打开 /video 时表单的初始值，只影响表单，不会自动生成",
+			videoDefaultsSaved: "已保存",
+			videoHistorySection: "视频生成历史",
+			videoHistoryHint: "最近生成的视频，只记录路径不保存视频内容",
+			videoHistoryEmpty: "还没有生成记录",
+			videoHistoryUnavailable: "暂时读不到生成历史",
+			videoHistoryRefresh: "刷新",
+			videoHistoryRefreshing: "读取中…",
+			videoHistoryAt: "{time}",
+			videoHistoryMeta: "{model} · {ratio} · {duration} 秒 · {size}",
+			videoHistoryNoRatio: "未指定比例",
+			videoHistoryStorage: "记录位置：{path}",
+			videoHistoryEncrypted: "已由系统凭据后端加密",
+			videoHistoryPlain: "本机没有可用的凭据后端，记录为明文"
 		};
 		const en$6 = {
 			...accountPoolEn,
@@ -6910,9 +6978,9 @@ window.__ModuleLoader__.load({
 			regionCn: "Mainland China (minimax.cn)",
 			regionGlobal: "Global (minimax.io)",
 			expiresAt: "Token expires",
-			expiresRemaining: "{hours} h left",
+			expiresRemaining: "{minutes} min left",
 			expiresExpired: "Expired",
-			expiresHint: "The access token lives about 24 hours; the Host refreshes it once it expires or the upstream answers 401. When a refresh is rejected, sign in again from MiniMax Code.",
+			expiresHint: "The access token lives about 1 hour; the Host refreshes it once it expires or the upstream answers 401. When a refresh is rejected, sign in again from MiniMax Code.",
 			signIn: "Sign in to MiniMax Code",
 			signingIn: "Requesting a device code...",
 			signOut: "Sign out",
@@ -7004,7 +7072,75 @@ window.__ModuleLoader__.load({
 			capText: "Text",
 			capImage: "Image",
 			loading: "Loading...",
-			unknown: "—"
+			unknown: "—",
+			videoToolTitle: "Video",
+			videoToolRunning: "Generating video",
+			videoToolDone: "Video generated",
+			videoToolFailed: "Video generation failed",
+			videoGenerating: "Still generating upstream; the video appears here once it lands.",
+			videoReading: "Reading the video",
+			videoTooLarge: "This video is past the {limit} full-file read cap; your system player can still open it.",
+			videoUnreadable: "The video bytes could not be read — the file may have been moved or deleted.",
+			videoUnplayable: "The video bytes could not be opened for playback.",
+			videoNoMeta: "This call recorded no video metadata, so the file cannot be located.",
+			videoChannelOff: "No file-read channel is available here, so playback is unavailable.",
+			videoFailed: "This generation did not succeed, so there is no file to play.",
+			videoSize: "{size}",
+			videoTitle: "Video",
+			videoCommandLabel: "Generate video",
+			videoCommandDesc: "Pick parameters, then fill them into the composer",
+			videoPresetGroup: "Presets",
+			videoPresetCustom: "Custom…",
+			videoPresetCustomDesc: "Open the full parameter form",
+			videoDialogTitle: "Video parameters",
+			videoDialogDesc: "The form writes into the composer; review it before sending",
+			videoPromptLabel: "Prompt",
+			videoPromptPlaceholder: "Describe the clip you want",
+			videoPromptRequired: "A prompt is required",
+			videoModelLabel: "Model",
+			videoRatioLabel: "Aspect ratio",
+			videoRatioLockedKeyframes: "A first or last frame is set, so the ratio is fixed to adaptive",
+			videoRatioLockedTextOnly: "Text-only cannot use adaptive: there is nothing to adapt to",
+			videoDurationLabel: "Duration",
+			videoDurationUnit: "s",
+			videoResolutionLabel: "Resolution",
+			videoWatermarkLabel: "AIGC watermark",
+			videoMediaSection: "Reference media",
+			videoMediaHint: "Absolute or workspace-relative paths, one per line",
+			videoInputImageLabel: "First frame",
+			videoLastFrameLabel: "Last frame",
+			videoReferenceImagesLabel: "Reference images",
+			videoReferenceVideosLabel: "Reference videos",
+			videoReferenceVideoDurationsLabel: "Reference video durations",
+			videoReferenceAudiosLabel: "Reference audio",
+			videoMediaUnsupported: "{model} does not accept reference images, videos or audio",
+			videoLastFrameUnsupported: "{model} does not accept a last-frame image",
+			videoTooManyImages: "{count} reference images, at most {limit} are accepted",
+			videoTooManyVideos: "{count} reference videos, at most {limit} are accepted",
+			videoTooManyAudios: "{count} reference audio files, at most {limit} are accepted",
+			videoTooManyTotal: "{count} reference media files in total, at most {limit} are accepted",
+			videoDurationInvalid: "{model} does not accept {duration} seconds",
+			videoSubmit: "Fill the composer",
+			videoCancel: "Cancel",
+			videoClose: "Close",
+			videoDraftFilled: "Parameters are in the composer; send when ready",
+			videoDraftFailed: "This session has no composer to fill, so nothing was inserted",
+			videoNotMinimax: "This command is only available in a MiniMax Code session",
+			videoDefaultsSection: "Video defaults",
+			videoDefaultsHint: "Initial values for the /video form; they only prefill it and never generate",
+			videoDefaultsSaved: "Saved",
+			videoHistorySection: "Video history",
+			videoHistoryHint: "Recent generations; paths only, never the video content",
+			videoHistoryEmpty: "No generations yet",
+			videoHistoryUnavailable: "Video history is unreadable right now",
+			videoHistoryRefresh: "Refresh",
+			videoHistoryRefreshing: "Reading…",
+			videoHistoryAt: "{time}",
+			videoHistoryMeta: "{model} · {ratio} · {duration}s · {size}",
+			videoHistoryNoRatio: "no ratio",
+			videoHistoryStorage: "Stored at {path}",
+			videoHistoryEncrypted: "Encrypted by the platform credential backend",
+			videoHistoryPlain: "No credential backend on this host; stored as plain text"
 		};
 		const dictionaries$6 = {
 			zh: zh$6,
@@ -7024,7 +7160,7 @@ window.__ModuleLoader__.load({
 		* rather than inferred from the JSX.
 		*/
 		/** The card's own dictionary; stable identity keeps effect dependencies intact. */
-		const fallbackTranslate$3 = (key) => zh$6[key];
+		const fallbackTranslate$4 = (key) => zh$6[key];
 		/**
 		* The shared pool card's labels, resolved through this card's dictionary.
 		*
@@ -7120,7 +7256,7 @@ window.__ModuleLoader__.load({
 		/** Device-code poll cadence. The host owns the real expiry. */
 		const LOGIN_POLL_INTERVAL_MS$2 = 2e3;
 		function useMinimaxCodeSection({ onModelChange }) {
-			const t = fallbackTranslate$3;
+			const t = fallbackTranslate$4;
 			const [status, setStatus] = (0, react.useState)(null);
 			const [loading, setLoading] = (0, react.useState)(true);
 			const [busy, setBusy] = (0, react.useState)(null);
@@ -7584,86 +7720,1048 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
-		//#region src/client/minimax-code/MinimaxCodeSection.tsx
+		//#region src/client/minimax-code/video-contract.ts
 		/**
-		* The MiniMax Code settings card.
+		* MiniMax 视频能力在浏览器半边的共享契约与纯函数。
 		*
-		* Markup only: every piece of state, every effect and every request this card
-		* makes lives in 'useMinimaxCodeSection.ts', which returns one named shape the
-		* JSX below reads. The two files are the split of a single 915-line component —
-		* the behaviour is unchanged, and this one should stay render-shaped.
+		* ## 为什么形状要在这里再写一遍
+		*
+		* host 那一份（`MinimaxVideoPresentationMeta`）住在 `src/host/minimax-code/` 下。
+		* 客户端 tsconfig 的 `include` 只覆盖 `src/client/**` 与 `src/shared/**`——
+		* 从浏览器半边 import 宿主模块既越界，也会把宿主的 node 依赖拖进浏览器闭包。
+		* 两份形状必须逐字一致（字段名、可选性），由
+		* `test/minimax-code-video-toolview.test.tsx` 的赋值断言钉住。
+		*
+		* ## 视频怎么从工作区走到 `<video>`
+		*
+		* meta 里的 `videoPath` 是**工作区相对路径**，而浏览器只有一个取字节通道：
+		* `ctx.remote.workspaceFiles.readBytes(sessionId, path, options, signal)`
+		* （宿主侧边栏图像预览走的是同一条，见
+		* `ui-sidebar-documentpreview/src/client/rpc.ts` 的 `ReadDocumentBytes`）。
+		* 拿到的 `Uint8Array` 包成 Blob，再 `URL.createObjectURL` 交给 `<video>`：
+		* 视频不能像图片那样走 `loadImage`（那是附件专用的），也不能直接写文件路径
+		* ——浏览器的 `<video src>` 读不到工作区。
+		*
+		* 对象 URL 是**手动生命周期**：拿到就建、卸载就 `revokeObjectURL`，见两个组件里的
+		* `useObjectUrl`。漏掉那一步等于把整段视频留在内存里。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/video-contract
 		*/
-		/** Human label per thinking mode, so the card states what the model does. */
-		function thinkingLabel(mode, t) {
-			if (mode === "always-on") return t("thinkingAlwaysOn");
-			if (mode === "forced-effort") return t("thinkingForced");
-			return t("thinkingToggle");
+		/**
+		* `minimax_generate_video` 的线上工具名。
+		*
+		* `tool.call.toolview` 是按这个字符串 keyed 分发的，拼错一个字视图就永远不渲染
+		* （槽位不会报错，它只是永远命不中），所以两边共用这一个常量。
+		*/
+		const MINIMAX_VIDEO_TOOL_NAME = "minimax_generate_video";
+		/**
+		* 从工具结果的 `meta` 里读出视频事实，读不到就是 `undefined`。
+		*
+		* `meta` 在类型上是 `unknown`，且它由**另一个运行时**写入——会话日志可能是
+		* 旧版本插件写的、可能缺字段、也可能根本不是这个工具的对象。所以这里逐字段
+		* 校验，任何一项不合格就整体当作「没有 meta」，由卡片改画占位块，
+		* 而不是让一次审计过的 JSON 把整个对话流带崩。
+		*
+		* @param meta - `ToolResultNode.meta`（通常是 `output.presentationMeta`）。
+		* @returns 通过校验的视频事实；不是本工具的 meta 时 undefined。
+		*/
+		function readVideoMeta(meta) {
+			if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return void 0;
+			const candidate = meta;
+			const videoPath = candidate.videoPath;
+			const mediaType = candidate.mediaType;
+			const bytes = candidate.bytes;
+			const model = candidate.model;
+			const taskId = candidate.taskId;
+			const durationSeconds = candidate.durationSeconds;
+			if (typeof videoPath !== "string" || videoPath === "") return void 0;
+			if (typeof mediaType !== "string" || !mediaType.startsWith("video/")) return void 0;
+			if (typeof bytes !== "number" || !Number.isFinite(bytes) || bytes < 0) return void 0;
+			if (typeof model !== "string") return void 0;
+			if (typeof taskId !== "string") return void 0;
+			if (durationSeconds !== void 0 && (typeof durationSeconds !== "number" || !Number.isFinite(durationSeconds) || durationSeconds <= 0)) return;
+			return {
+				videoPath,
+				mediaType,
+				bytes,
+				model,
+				taskId,
+				...durationSeconds === void 0 ? {} : { durationSeconds }
+			};
 		}
 		/**
-		* Hours still left on the access token, or null once it has run out.
+		* 把工作区相对路径拼成绝对路径。
 		*
-		* MiniMax Code's token lives about 24 hours, so hours are the unit the card
-		* reports; a value worth a fraction of an hour keeps one decimal instead of
-		* rounding down to 0.
+		* 分隔符**按 posix 拼**，不按宿主平台拼：这段代码跑在浏览器里，而工作区路径
+		* 的规范形是 `/` 分隔（宿主的 `parseFileAddress` 也按这个认）。反斜杠进来的
+		* 相对路径先归一化，避免拼出 `C:\\ws\\clips\\a.mp4` 这种混合形态。
+		*
+		* `cwd` 缺省时（宿主从不认识这个会话的工作区）**原样返回相对路径**：它仍然是
+		* 这个会话地址空间里的合法路径，`openFile` 与 `readBytes` 都能用；只是别再声称
+		* 它是绝对的——调用方要的是「能打开的路径」，不是「看起来像绝对路径的字符串」。
+		*
+		* @param cwd - 会话工作区根；未提供时按相对路径处理。
+		* @param videoPath - meta 里的工作区相对路径。
+		* @returns 绝对路径，或 `cwd` 缺省时的相对路径。
 		*/
-		function remainingHours(expiresAtMs) {
-			if (expiresAtMs === void 0 || !Number.isFinite(expiresAtMs) || expiresAtMs <= 0) return null;
-			const hours = (expiresAtMs - Date.now()) / 36e5;
-			if (hours <= 0) return null;
-			return hours >= 10 ? hours.toFixed(0) : hours.toFixed(1);
+		function absoluteVideoPath(cwd, videoPath) {
+			const relative = videoPath.replaceAll("\\", "/");
+			if (cwd === void 0 || cwd === "") return relative;
+			const root = cwd.replaceAll("\\", "/").replace(/\/+$/, "");
+			if (root === "") return relative;
+			if (/^(?:[A-Za-z]:\/|\/)/.test(relative)) return relative;
+			return `${root}/${relative}`;
 		}
-		function MinimaxCodeSection({ onModelChange }) {
-			const { state, derived, actions } = useMinimaxCodeSection({ onModelChange });
-			const { status, loading, busy, error, flow, copied, connectionNotice, contextDrafts, savingModel, pool, resetCards, resetNotice, selectedResetCardId } = state;
-			const { authenticated, account, quota, models, contextModels, overrideCount, poolLabels, resetCardList, resetCardFlows } = derived;
-			const { login, cancelLogin, copyCode, logout, poolAction, setStrategy, toggleModel, setAllModels, setCheckinEnabled, runCheckinNow, updateEffort, saveContextWindow, resetContextWindow, resetAllContextWindows, refreshQuota, refreshResetCards, selectResetCard, useResetCard, testConnection, updateContextDraft } = actions;
-			const t = fallbackTranslate$3;
-			if (loading) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-				className: "dsha-page",
-				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-					className: "dsha-empty",
-					children: t("loading")
-				})
+		/**
+		* 把一次取字节的异常读成「太大」还是「读不到」。
+		*
+		* 判定**只看错误上的 `code`**，与宿主自己的文档预览同款做法
+		* （`ui-sidebar-documentpreview/src/client/failure-line.ts`）：远端失败的形状是
+		* `{ code, message, details }`，`code` 就是那条稳定的判别字段，不要去解析
+		* `message` 里的英文，也不要靠 `instanceof`——跨包、跨 realm 都不成立。
+		*
+		* 任何拿不到 `code` 的东西（通道根本没装上、浏览器抛的 TypeError、undefined）
+		* 一律归入「读不到」：那是默认的那句话，不能因为一个畸形异常就把文案换成
+		* 「文件太大」。
+		*
+		* @param error - `catch` 到的任意值。
+		* @returns `'too-large'` 仅当宿主明确报了这个码，否则 `'unreadable'`。
+		*/
+		function videoReadFailureOf(error) {
+			return typeof error === "object" && error !== null && error.code === "workspace-file/too-large" ? "too-large" : "unreadable";
+		}
+		/**
+		* 从一次 too-large 失败里读出那个上限。
+		*
+		* 宿主把它放在 `details.limit`（`packages/api/workspace-files/src/index.ts` 的
+		* `RemoteError('workspace-file/too-large', …, { path, limit })`）。读不到就不显示
+		* 上限——文案里留一个「—」比编一个数字出来好。
+		*
+		* @param error - `catch` 到的任意值。
+		* @returns 上限字节数，或 undefined。
+		*/
+		function videoReadLimitOf(error) {
+			if (typeof error !== "object" || error === null) return void 0;
+			const details = error.details;
+			if (typeof details !== "object" || details === null) return void 0;
+			const limit = details.limit;
+			return typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? limit : void 0;
+		}
+		/**
+		* 字节数转人读的体积。
+		*
+		* 只有 11px 的位置放它，所以最多三位有效数字：`986 KB`、`12.4 MB`、`1.02 GB`。
+		* 单位之间是普通空格，不引小数点前的零。
+		* @param bytes - 文件字节数。
+		* @returns 形如 `12.4 MB` 的短标签。
+		*/
+		function formatBytes(bytes) {
+			if (!Number.isFinite(bytes) || bytes < 0) return "—";
+			if (bytes < 1024) return `${Math.round(bytes)} B`;
+			const units = [
+				"KB",
+				"MB",
+				"GB",
+				"TB"
+			];
+			let value = bytes / 1024;
+			let unit = 0;
+			while (value >= 1024 && unit < units.length - 1) {
+				value /= 1024;
+				unit += 1;
+			}
+			const rounded = value >= 100 ? value.toFixed(0) : value >= 10 ? value.toFixed(1) : value.toFixed(2);
+			return `${rounded.includes(".") ? rounded.replace(/0+$/, "").replace(/\.$/, "") : rounded} ${units[unit]}`;
+		}
+		/**
+		* 「文件太大，读不出来」那一句，带上宿主报的上限。
+		*
+		* 宿主把 `details.limit` 交给文案（`failureLine` 的
+		* `t('error.tooLarge', { limit: humanBytes(failure.details.limit) })`），这里照做，
+		* 只是换成本插件自己的 {@link formatBytes}——两边对同一个数字的写法必须与本卡片
+		* 右下角那行体积一致。
+		*
+		* 上限缺失时退回「—」（`formatBytes` 对非数字的既有行为）：一句话里少一个数字，
+		* 好过为了凑数字去猜一个上限。
+		*
+		* @param t - 命名空间化的翻译。
+		* @param limit - 宿主报的上限字节数；undefined 时按未知处理。
+		* @returns 一句占位文案（中文一句、结尾不加句号）。
+		*/
+		function videoTooLargeText(t, limit) {
+			return t("videoTooLarge").replace("{limit}", formatBytes(limit ?? NaN));
+		}
+		/**
+		* 秒数转 `m:ss` / `h:mm:ss`。
+		*
+		* 视频时长是元数据，不是大数字：只补零到分钟位，超过一小时才出现小时段。
+		* @param seconds - 时长秒数。
+		* @returns 形如 `0:07` 或 `1:02:03` 的短标签。
+		*/
+		function formatDuration(seconds) {
+			const total = Math.max(0, Math.round(seconds));
+			const hours = Math.floor(total / 3600);
+			const minutes = Math.floor(total % 3600 / 60);
+			const rest = total % 60;
+			const tail = `${minutes}:${String(rest).padStart(2, "0")}`;
+			return hours === 0 ? tail : `${hours}:${String(minutes).padStart(2, "0")}:${String(rest).padStart(2, "0")}`;
+		}
+		/**
+		* 从路径里取文件名，用于侧边栏那一行元数据。
+		* @param path - 绝对或相对路径，`/` 与 `\` 都认。
+		* @returns 最后一个分隔符之后的部分；没有分隔符时返回原串。
+		*/
+		function fileNameOf(path) {
+			const normalized = path.replaceAll("\\", "/");
+			const name = normalized.slice(normalized.lastIndexOf("/") + 1);
+			return name === "" ? normalized : name;
+		}
+		//#endregion
+		//#region src/client/minimax-code/video-form-rules.ts
+		/**
+		* MiniMax 视频参数的**浏览器侧规则副本**与表单状态机。
+		*
+		* ## 为什么这里又抄了一遍宿主那张表
+		*
+		* 每个模型的合法时长/分辨率、以及比例随首帧/参考媒体被改写的联动，都写在宿主
+		* 的 `src/host/minimax-code/video-tool.ts` 里。浏览器半边 **import 不到**它：
+		* 客户端 tsconfig 只覆盖 `src/client/**` 与 `src/shared/**`，跨过去会把宿主的
+		* node 依赖拖进浏览器闭包（同 `video-contract.ts` 顶部那条注释的理由）。
+		*
+		* 所以这里是**逐字抄写**，不是重新推导。抄的是那一份**实测**表
+		* （`docs/minimax-video-model-rules.md`），不是文档或猜测：
+		*
+		* | model                | duration          | resolutions  |
+		* | -------------------- | ----------------- | ------------ |
+		* | `MiniMax-H3`         | 4-15              | 768P, 2K     |
+		* | `MiniMax-H3-Max`     | 5-15              | 480P, 768P   |
+		* | `MiniMax-Hailuo-2.3` | 6 或 10           | 768P, 1080P  |
+		*
+		* 三张表**两两不同，且没有一张等于并集**——2K 只有 H3 有、480P 只有 H3-Max 有、
+		* 1080P 只有 Hailuo 有。所以客户端也**不能**用一张并集去校验：那会让 H3-Max 的
+		* 用户选到 2K，然后被服务端在计费之后拒掉。
+		*
+		* `test/minimax-code-video-form-rules.test.ts` 里的一个用例把这三行钉死，改任何
+		* 一边而忘了另一边都会红。
+		*
+		* ## 比例联动为什么必须在表单层就做掉
+		*
+		* 宿主的 `resolveVideoSubmissionRatio` 是照上游逐分支抄的：
+		*
+		* ```ts
+		* isH3(model)
+		*   ? hasKeyframes ? 'adaptive'
+		*     : hasReferences ? (ratio ?? 'adaptive')
+		*     : (ratio ?? '16:9')
+		*   : ratio
+		* ```
+		*
+		* 也就是说：**给了首帧，用户选的比例会被无声改写成 `adaptive`**；纯文本又
+		* **不允许** `adaptive`（没有可自适应的对象，宿主会直接拒绝）。
+		*
+		* 让用户先选一个「16:9」再被改写成「adaptive」，是这个入口最不该犯的错——用户
+		* 看到的和发出去的不是一个东西。所以这里把「最终比例」直接算出来给用户看，
+		* 并且**不给选择**：`resolveVideoRatioChoice` 返回的 `locked` 就是那个意思。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/video-form-rules
+		*/
+		/** 三个视频模型，顺序与宿主 `MINIMAX_VIDEO_MODELS` 一致。 */
+		const MINIMAX_VIDEO_MODELS = [
+			"MiniMax-H3",
+			"MiniMax-H3-Max",
+			"MiniMax-Hailuo-2.3"
+		];
+		/** 服务端认识的每一个比例拼写，顺序照上游。 */
+		const MINIMAX_VIDEO_RATIOS = [
+			"21:9",
+			"16:9",
+			"4:3",
+			"1:1",
+			"3:4",
+			"9:16",
+			"adaptive"
+		];
+		/** 首帧/末帧在场时宿主**强制**发送的比例。 */
+		const MINIMAX_KEYFRAME_RATIO = "adaptive";
+		/**
+		* 实测的每模型规则，逐字抄自宿主 `MINIMAX_VIDEO_MODEL_RULES`。
+		*
+		* 抄错一个字的表现是「客户端放行 → 服务端计费后拒绝」，所以这里连顺序都不改。
+		*/
+		const VIDEO_MODEL_RULES = [
+			{
+				model: "MiniMax-H3",
+				duration: {
+					kind: "range",
+					min: 4,
+					max: 15
+				},
+				resolutions: ["768P", "2K"],
+				supportsReferenceMedia: true,
+				isH3Family: true
+			},
+			{
+				model: "MiniMax-H3-Max",
+				duration: {
+					kind: "range",
+					min: 5,
+					max: 15
+				},
+				resolutions: ["480P", "768P"],
+				supportsReferenceMedia: true,
+				isH3Family: true
+			},
+			{
+				model: "MiniMax-Hailuo-2.3",
+				duration: {
+					kind: "values",
+					values: [6, 10]
+				},
+				resolutions: ["768P", "1080P"],
+				supportsReferenceMedia: false,
+				isH3Family: false
+			}
+		];
+		/** @param model - 模型 id。 @returns 该模型的规则，未知时为 undefined。 */
+		function videoModelRule(model) {
+			return VIDEO_MODEL_RULES.find((rule) => rule.model === model);
+		}
+		/**
+		* 一个模型可以选的时长，**从短到长、去重后**给选择器用。
+		*
+		* 区间型的模型给的是 1 秒一档的整数刻度（服务端接受区间内任意整数），取值集型的
+		* 模型只有那几个值。两者都返回数组，表单因此不必分支。
+		*
+		* @param model - 模型 id。
+		* @returns 合法时长列表；模型未知时为空。
+		*/
+		function durationChoices(model) {
+			const rule = videoModelRule(model);
+			if (rule === void 0) return [];
+			if (rule.duration.kind === "values") return [...rule.duration.values];
+			const values = [];
+			for (let value = rule.duration.min; value <= rule.duration.max; value += 1) values.push(value);
+			return values;
+		}
+		/**
+		* 一个模型的默认时长。
+		*
+		* 区间型的模型取**下界**：那是最便宜的一次生成，也是用户第一次点开表单时最不
+		* 容易心疼的值。取值集型的模型取第一个值（Hailuo 的 6）。
+		*
+		* @param model - 模型 id。
+		* @returns 默认时长；模型未知时为 undefined。
+		*/
+		function defaultDuration(model) {
+			const rule = videoModelRule(model);
+			if (rule === void 0) return void 0;
+			return rule.duration.kind === "values" ? rule.duration.values[0] : rule.duration.min;
+		}
+		/**
+		* 一个模型的默认分辨率。
+		*
+		* 取**该模型自己的**第一项，而不是宿主的 `2K`：2K 是 H3 专属，H3-Max 与 Hailuo
+		* 都没有，硬套过去就是一个必被拒绝的默认值。
+		*
+		* @param model - 模型 id。
+		* @returns 默认分辨率；模型未知时为 undefined。
+		*/
+		function defaultResolution(model) {
+			return videoModelRule(model)?.resolutions[0];
+		}
+		/** 路径是不是「真的给了」：空白字符不算给。 */
+		function hasPath(value) {
+			return typeof value === "string" && value.trim() !== "";
+		}
+		/** 非空路径的条数。 */
+		function countPaths(values) {
+			if (!Array.isArray(values)) return 0;
+			return values.filter(hasPath).length;
+		}
+		/**
+		* 这份媒体输入决定的两件事：有没有首帧、有没有参考媒体。
+		*
+		* 两个布尔直接对应用户能看见的那句提示，以及比例能不能选。
+		*
+		* @param media - 表单里的媒体路径。
+		* @returns 两个判定。
+		*/
+		function mediaPresence(media) {
+			return {
+				hasKeyframes: hasPath(media.inputImagePath) || hasPath(media.lastFrameImagePath),
+				hasReferences: countPaths(media.referenceImagePaths) > 0 || countPaths(media.referenceVideoPaths) > 0 || countPaths(media.referenceAudioPaths) > 0
+			};
+		}
+		/**
+		* 决定比例这一栏的形态，**在表单层就把联动做掉**。
+		*
+		* 三条规则与宿主 {@link resolveVideoSubmissionRatio} 一一对应，只是把「静默改写」
+		* 换成「当场显示」：
+		*
+		* 1. **有首帧** → 强制 `adaptive`，不给选。用户选了也会被改写，所以干脆不给。
+		* 2. **有参考媒体** → 默认 `adaptive`，但**可以改**：上游对这个分支是
+		*    `ratio ?? 'adaptive'`，用户给了就照发。所以这里列出的每一个拼写都是
+		*    真正会发出去的那个。
+		* 3. **纯文本** → 默认 `16:9`（H3 家族）或「不发」（Hailuo），**`adaptive` 不可选**
+		*    ——服务端没有可自适应的对象，选了必被拒。
+		*
+		* @param input - 模型、用户当前选的比例、媒体在场情况。
+		* @returns 这一栏的形态。
+		*/
+		function resolveVideoRatioChoice(input) {
+			const { model, requested, hasKeyframes, hasReferences } = input;
+			const isH3 = videoModelRule(model)?.isH3Family === true;
+			if (hasKeyframes) return {
+				ratio: MINIMAX_KEYFRAME_RATIO,
+				selectable: false,
+				lockedReason: "keyframes",
+				options: []
+			};
+			if (hasReferences) return {
+				ratio: requested ?? "adaptive",
+				selectable: true,
+				options: MINIMAX_VIDEO_RATIOS
+			};
+			const textOptions = MINIMAX_VIDEO_RATIOS.filter((entry) => entry !== "adaptive");
+			return {
+				ratio: requested ?? (isH3 ? "16:9" : void 0),
+				selectable: true,
+				lockedReason: "text-only",
+				options: textOptions
+			};
+		}
+		/**
+		* 把多行文本框切成路径数组。
+		*
+		* 一行一条，去掉首尾空白，丢掉空行。**不做**通配符展开、不做存在性检查：路径
+		* 由宿主在提交时解析，浏览器里没有工作区文件系统。
+		*
+		* @param text - 多行文本。
+		* @returns 路径数组。
+		*/
+		function parsePathLines(text) {
+			return text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "");
+		}
+		/**
+		* 校验整个表单。
+		*
+		* 顺序照着服务端自己的检查顺序（model → duration → resolution → prompt → ratio），
+		* 因为报告一条服务端根本不会提的规则，比不报告更糟。
+		*
+		* **提示词为空是唯一挡住提交的理由**；其余都是本地就拦下的、必然被拒的组合
+		* （参考媒体给了 Hailuo、条数超限），拦下来只为省一次计费请求。
+		*
+		* @param values - 表单值。
+		* @returns 问题列表；空数组表示可以提交。
+		*/
+		function validateVideoForm(values) {
+			const issues = [];
+			const rule = videoModelRule(values.model);
+			const { hasKeyframes } = mediaPresence(values.media);
+			const images = countPaths(values.media.referenceImagePaths);
+			const videos = countPaths(values.media.referenceVideoPaths);
+			const audios = countPaths(values.media.referenceAudioPaths);
+			if (rule !== void 0 && !rule.supportsReferenceMedia) {
+				if (images + videos + audios > 0) issues.push({
+					code: "reference-unsupported",
+					params: { model: values.model }
+				});
+				if (hasPath(values.media.lastFrameImagePath)) issues.push({
+					code: "last-frame-unsupported",
+					params: { model: values.model }
+				});
+			}
+			if (images > 9) issues.push({
+				code: "too-many-images",
+				params: {
+					count: images,
+					limit: 9
+				}
 			});
-			const hours = remainingHours(account?.expiresAtMs);
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-				className: "dsha-page",
+			if (videos > 3) issues.push({
+				code: "too-many-videos",
+				params: {
+					count: videos,
+					limit: 3
+				}
+			});
+			if (audios > 3) issues.push({
+				code: "too-many-audios",
+				params: {
+					count: audios,
+					limit: 3
+				}
+			});
+			if (images + videos + audios > 12) issues.push({
+				code: "too-many-total",
+				params: {
+					count: images + videos + audios,
+					limit: 12
+				}
+			});
+			if (values.durationSeconds !== void 0 && !durationChoices(values.model).includes(values.durationSeconds)) issues.push({
+				code: "duration-invalid",
+				params: {
+					model: values.model,
+					duration: values.durationSeconds
+				}
+			});
+			if (values.prompt.trim() === "") issues.push({ code: "prompt-empty" });
+			return issues;
+		}
+		/**
+		* 表单是否满足**提交**的最低条件。
+		*
+		* 比 {@link validateVideoForm} 宽：那个列表里除了提示词以外的问题都会在提交时被
+		* 服务端拒绝，而这里只回答「按钮能不能亮」。真正挡住生成的是提示词——那一条
+		* 是任务书里点名的：**缺提示词时不能提交**。
+		*
+		* @param values - 表单值。
+		* @returns 能否提交。
+		*/
+		function canSubmitVideoForm(values) {
+			return values.prompt.trim() !== "";
+		}
+		/**
+		* 把表单拼成一句**给模型看**的话，填进输入框。
+		*
+		* ## 为什么是这个形状
+		*
+		* 工具是模型自主调用的，所以这段文字要同时做到三件事：点名工具、把参数写成模型
+		* 抄得下来的形态、说清「只发一次」。用等号写字段是刻意的——模型最容易照抄的就是
+		* 这种形如签名的行。
+		*
+		* 比例**只在真的会发出去时才写**：纯文本 + Hailuo 的最终比例是 undefined（宿主
+		* 不发这个字段，服务端用自己的默认），这时候替用户编一个 16:9 就是在描述一次
+		* 不会发生的请求。
+		*
+		* ## 「只发一次」为什么必须写进去
+		*
+		* 提交是**计费**且**终态**的：重发不是续传，是再买一次生成。宿主自己的守卫也只
+		* 在同一 session 同一 turn 内生效（`videoSubmissionKey`），换个 turn 就拦不住了。
+		* 把这句话交给模型，是这道防线上客户端能出力的那一半。
+		*
+		* @param values - 表单值（应已通过 {@link resolveVideoRatioChoice} 归一化）。
+		* @returns 填进输入框的整段文本。
+		*/
+		function buildVideoDraftText(values) {
+			const { hasKeyframes, hasReferences } = mediaPresence(values.media);
+			const ratio = resolveVideoRatioChoice({
+				model: values.model,
+				...values.ratio === void 0 ? {} : { requested: values.ratio },
+				hasKeyframes,
+				hasReferences
+			}).ratio;
+			const lines = [];
+			lines.push("用 minimax_generate_video 生成视频：");
+			lines.push("prompt=" + values.prompt.trim());
+			lines.push("model=" + values.model);
+			if (ratio !== void 0) lines.push("ratio=" + ratio);
+			if (values.durationSeconds !== void 0) lines.push("durationSeconds=" + values.durationSeconds);
+			if (values.resolution !== void 0) lines.push("resolution=" + values.resolution);
+			const inputImagePath = values.media.inputImagePath?.trim();
+			if (inputImagePath !== void 0 && inputImagePath !== "") lines.push("inputImagePath=" + inputImagePath);
+			const lastFrameImagePath = values.media.lastFrameImagePath?.trim();
+			if (lastFrameImagePath !== void 0 && lastFrameImagePath !== "") lines.push("lastFrameImagePath=" + lastFrameImagePath);
+			const images = (values.media.referenceImagePaths ?? []).map((path) => path.trim()).filter((path) => path !== "");
+			if (images.length > 0) lines.push("referenceImagePaths=" + images.join(","));
+			const videos = (values.media.referenceVideoPaths ?? []).map((path) => path.trim()).filter((path) => path !== "");
+			if (videos.length > 0) lines.push("referenceVideoPaths=" + videos.join(","));
+			const videoDurations = (values.media.referenceVideoDurationSeconds ?? []).filter((value) => Number.isFinite(value) && value > 0);
+			if (videos.length > 0 && videoDurations.length === videos.length) lines.push("referenceVideoDurationSeconds=" + videoDurations.join(","));
+			const audios = (values.media.referenceAudioPaths ?? []).map((path) => path.trim()).filter((path) => path !== "");
+			if (audios.length > 0) lines.push("referenceAudioPaths=" + audios.join(","));
+			if (values.watermark !== void 0) lines.push("aigc_watermark=" + (values.watermark ? "true" : "false"));
+			lines.push("");
+			lines.push("这些参数已经按服务端规则校验过，请原样使用，不要改动或补充");
+			lines.push("提交是计费的终态操作：只调用一次，失败也不重发");
+			return lines.join("\n");
+		}
+		/**
+		* 归一化一份默认参数。
+		*
+		* 存在的理由是**模型换了而时长没跟着换**：用户把默认模型从 H3 改成 Hailuo，原来
+		* 的 8 秒就不合法了。这里当场把它换成新模型的默认值，而不是把非法值一路带到表单
+		* 里，再让用户在弹窗里看到一条自己没设过的错误。
+		*
+		* @param value - 任意解析出来的对象。
+		* @returns 一份自洽的默认参数。
+		*/
+		function normalizeVideoDefaults(value) {
+			const record = typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+			const model = MINIMAX_VIDEO_MODELS.find((known) => known === record.model) ?? "MiniMax-H3";
+			const requestedDuration = typeof record.durationSeconds === "number" && Number.isFinite(record.durationSeconds) ? record.durationSeconds : void 0;
+			const durationSeconds = requestedDuration !== void 0 && durationChoices(model).includes(requestedDuration) ? requestedDuration : defaultDuration(model);
+			const ratio = MINIMAX_VIDEO_RATIOS.find((known) => known === record.ratio);
+			return {
+				model,
+				...ratio === void 0 ? {} : { ratio },
+				...durationSeconds === void 0 ? {} : { durationSeconds },
+				watermark: record.watermark === true
+			};
+		}
+		//#endregion
+		//#region src/client/minimax-code/VideoSettingsSections.tsx
+		/**
+		* 设置页里的两个视频分区：**默认参数**与**生成历史**。
+		*
+		* 视觉语言逐条照抄 `MinimaxCodeSection.tsx` 的既有分区（`.dsha-group` /
+		* `.dsha-grouphead` / `.dsha-row` / `.dsha-muted` / `.dsha-btn`），不新增任何
+		* 颜色、字号刻度或字重。
+		*
+		* ## 一次加载只用一个加载态
+		*
+		* 历史是**列表**，所以它的加载态是骨架（`.dshm-video-skeleton` 三条灰条）；
+		* 默认参数不是列表，它直接从 localStorage 同步读出来，根本没有加载态。这条是
+		* `dsh-client-ui-ux` 的硬约束：列表用骨架、其他用裸 spinner，且**不写 loading 文案**。
+		*
+		* ## 破坏性操作保留数据
+		*
+		* 读历史失败时**不清空已经拿到的行**：上一次成功的列表留在屏幕上，只在上方加一句
+		* 提示（`videoHistoryUnavailable`）。清空会让一次网络抖动看起来像「历史被删了」。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/VideoSettingsSections
+		*/
+		/**
+		* 校验一份历史载荷。
+		*
+		* 宿主那一半可能比浏览器这一半旧（同样的「两半不同版本」问题 `line-api.ts` 开头
+		* 那一大段注释在讲），所以每一行都逐字段过一遍，坏行**丢掉**而不是让整个列表渲染成
+		* 一堆 `undefined`。
+		*
+		* @param value - 路由的 `value`。
+		* @returns 规范化后的载荷。
+		*/
+		function parseVideoHistoryDto(value) {
+			if (typeof value !== "object" || value === null) return {
+				entries: [],
+				storagePath: "",
+				encryptedAtRest: false
+			};
+			const record = value;
+			const entries = [];
+			if (Array.isArray(record.entries)) for (const raw of record.entries) {
+				if (typeof raw !== "object" || raw === null) continue;
+				const row = raw;
+				if (typeof row.createdAtMs !== "number" || !Number.isFinite(row.createdAtMs)) continue;
+				if (typeof row.model !== "string" || row.model === "") continue;
+				if (typeof row.videoPath !== "string" || row.videoPath === "") continue;
+				if (typeof row.bytes !== "number" || !Number.isFinite(row.bytes)) continue;
+				if (typeof row.taskId !== "string") continue;
+				entries.push({
+					createdAtMs: row.createdAtMs,
+					model: row.model,
+					videoPath: row.videoPath,
+					bytes: row.bytes,
+					taskId: row.taskId,
+					...typeof row.ratio === "string" && row.ratio !== "" ? { ratio: row.ratio } : {},
+					...typeof row.durationSeconds === "number" && Number.isFinite(row.durationSeconds) ? { durationSeconds: row.durationSeconds } : {}
+				});
+			}
+			return {
+				entries,
+				storagePath: typeof record.storagePath === "string" ? record.storagePath : "",
+				encryptedAtRest: record.encryptedAtRest === true
+			};
+		}
+		/**
+		* 生成历史分区。
+		*
+		* 数据只来自宿主路由：浏览器侧没有任何事件能知道「刚刚生成了一段视频」——那次调用发
+		* 生在宿主的工具执行里。所以这份列表是**主动去读**的，第一次挂载读一次，用户可以
+		* 手动刷新。
+		*/
+		function VideoHistorySection({ t }) {
+			const [data, setData] = (0, react.useState)(null);
+			const [failure, setFailure] = (0, react.useState)(null);
+			const [loading, setLoading] = (0, react.useState)(true);
+			const alive = (0, react.useRef)(true);
+			(0, react.useEffect)(() => () => {
+				alive.current = false;
+			}, []);
+			const load = (0, react.useCallback)(async () => {
+				try {
+					const value = await get$2("/video-history");
+					if (!alive.current) return;
+					setData(parseVideoHistoryDto(value));
+					setFailure(null);
+				} catch (error) {
+					if (!alive.current) return;
+					setFailure(messageOf$2(error));
+				} finally {
+					if (alive.current) setLoading(false);
+				}
+			}, []);
+			(0, react.useEffect)(() => {
+				load();
+			}, [load]);
+			const rows = (0, react.useMemo)(() => data?.entries ?? [], [data]);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				className: "dsha-group",
 				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsha-grouphead",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: t("videoHistorySection") }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							className: "dsha-btn",
+							disabled: loading,
+							onClick: () => {
+								setLoading(true);
+								load();
+							},
+							children: loading ? t("videoHistoryRefreshing") : t("videoHistoryRefresh")
+						})]
+					}),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 						className: "dsha-muted",
-						children: t("pageDesc")
+						children: t("videoHistoryHint")
 					}),
-					pool !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AccountPoolSection, {
-						labels: poolLabels,
-						accounts: pool.accounts,
-						rotationStrategy: pool.rotationStrategy,
-						...pool.activeAccountId === void 0 ? {} : { activeAccountId: pool.activeAccountId },
-						busy,
-						onLogin: () => void login(),
-						onSetPrimary: (accountId) => void poolAction("set-primary", accountId),
-						onDelete: (accountId) => void poolAction("delete", accountId),
-						onClearCooldown: (accountId) => void poolAction("clear-cooldown", accountId),
-						onRelogin: (accountId) => void poolAction("relogin", accountId),
-						onSetStrategy: (strategy) => void setStrategy(strategy),
-						showQuota: true
+					failure !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsha-notice",
+						children: t("videoHistoryUnavailable")
 					}),
-					status?.checkin != null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
-						className: "dsha-group",
+					loading && data === null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dshm-video-skeleton",
+						"aria-hidden": "true",
 						children: [
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-								className: "dsha-grouphead",
-								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: t("dailyCheckin") })
-							}),
-							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
-								className: "dsha-muted",
-								children: t("checkinHint")
-							}),
-							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-								className: "dsha-row",
-								style: { marginBottom: 8 },
-								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-									className: "dsha-label",
-									style: { fontWeight: 600 },
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {})
+						]
+					}) : rows.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsha-empty",
+						children: t("videoHistoryEmpty")
+					}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dshm-video-history",
+						children: rows.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dsha-row",
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dshm-video-history-path dshm-mono",
+								title: entry.videoPath,
+								children: entry.videoPath
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dsha-value dshm-video-history-meta",
+								children: t("videoHistoryMeta", {
+									model: entry.model,
+									ratio: entry.ratio ?? t("videoHistoryNoRatio"),
+									duration: entry.durationSeconds === void 0 ? t("unknown") : formatDuration(entry.durationSeconds),
+									size: formatBytes(entry.bytes)
+								})
+							})]
+						}, entry.taskId + ":" + String(entry.createdAtMs)))
+					}),
+					data !== null && data.storagePath !== "" && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsha-muted dshm-quota-note",
+						children: t("videoHistoryStorage", { path: data.storagePath })
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsha-muted",
+						children: data.encryptedAtRest ? t("videoHistoryEncrypted") : t("videoHistoryPlain")
+					})] })
+				]
+			});
+		}
+		/**
+		* 默认参数分区。
+		*
+		* 改动立即写回，不设保存按钮：这四项都只是 `/video` 表单的起手值，没有「暂存」与
+		* 「已生效」的区别要表达；一个保存按钮反而会让用户以为不点就不生效。
+		*/
+		function VideoDefaultsSection({ t, initial, onSave }) {
+			const [defaults, setDefaults] = (0, react.useState)(() => normalizeVideoDefaults(initial));
+			const [notice, setNotice] = (0, react.useState)(null);
+			const apply = (0, react.useCallback)((next) => {
+				const normalized = normalizeVideoDefaults(next);
+				setDefaults(normalized);
+				setNotice(onSave(normalized) ? t("videoDefaultsSaved") : null);
+			}, [onSave, t]);
+			const rule = videoModelRule(defaults.model);
+			const durations = durationChoices(defaults.model);
+			const ratios = MINIMAX_VIDEO_RATIOS.filter((entry) => entry !== "adaptive");
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				className: "dsha-group",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsha-grouphead",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: t("videoDefaultsSection") })
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsha-muted",
+						children: t("videoDefaultsHint")
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsha-row",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsha-label",
+							children: t("videoModelLabel")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+							className: "dsha-select",
+							"aria-label": t("videoModelLabel"),
+							value: defaults.model,
+							onChange: (event) => {
+								const model = event.currentTarget.value;
+								apply({
+									...defaults,
+									model
+								});
+							},
+							children: MINIMAX_VIDEO_MODELS.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: entry,
+								children: entry
+							}, entry))
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsha-row",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsha-label",
+							children: t("videoDurationLabel")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+							className: "dsha-select",
+							"aria-label": t("videoDurationLabel"),
+							value: defaults.durationSeconds === void 0 ? "" : String(defaults.durationSeconds),
+							onChange: (event) => {
+								const value = Number(event.currentTarget.value);
+								apply({
+									...defaults,
+									durationSeconds: Number.isFinite(value) ? value : void 0
+								});
+							},
+							children: durations.map((value) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("option", {
+								value: String(value),
+								children: [
+									value,
+									" ",
+									t("videoDurationUnit")
+								]
+							}, value))
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsha-row",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsha-label",
+							children: t("videoRatioLabel")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+							className: "dsha-select",
+							"aria-label": t("videoRatioLabel"),
+							value: defaults.ratio ?? "",
+							onChange: (event) => {
+								const value = event.currentTarget.value;
+								const ratio = ratios.find((entry) => entry === value);
+								apply({
+									...defaults,
+									ratio
+								});
+							},
+							children: ratios.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: entry,
+								children: entry
+							}, entry))
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsha-row",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+							className: "dsha-label",
+							htmlFor: "dshm-video-default-watermark",
+							children: t("videoWatermarkLabel")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+							id: "dshm-video-default-watermark",
+							type: "checkbox",
+							checked: defaults.watermark,
+							onChange: (event) => {
+								apply({
+									...defaults,
+									watermark: event.currentTarget.checked
+								});
+							}
+						})]
+					}),
+					rule !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
+						className: "dsha-muted dshm-quota-note",
+						children: [
+							t("videoResolutionLabel"),
+							": ",
+							defaultResolution(defaults.model) ?? t("unknown")
+						]
+					}),
+					notice !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsha-muted",
+						role: "status",
+						children: notice
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/minimax-code/video-defaults-store.ts
+		/**
+		* 「视频默认参数」的浏览器侧存储。
+		*
+		* ## 为什么存在浏览器里，而不是 `$DSH_HOME/storages`
+		*
+		* 这份数据是**表单的初始值**，不是凭据、不是配额、也不影响任何一次请求的内容：
+		* 用户没打开设置页时它什么也不做，打开 `/video` 时它只决定三个下拉框的起手值。
+		* 存到宿主就要新开一条路由、一个新文件和一套平台加密后端，而那条路由的每一个
+		* 读者都是同一个浏览器的同一个页面。
+		*
+		* 对照的是**生成历史**：那个必须落在宿主，因为写它的是宿主（视频工具在生成成功
+		* 之后落一行），浏览器根本没有那次事件。默认参数相反，它是纯 UI 偏好。
+		*
+		* ## 读不到就当没有
+		*
+		* localStorage 在三种情况下会抛或返回垃圾：隐私模式下禁用、被别的代码写坏、以及
+		* 存储配额满。三种都退化成「一份出厂默认」，而不是让设置页打不开——这是整个仓库
+		* 对可选依赖的一贯处理（见 `progress-updates/index.ts` 的 `serviceOf`）。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/video-defaults-store
+		*/
+		/** localStorage 的键。带命名空间前缀，避免与宿主其它插件的键撞名。 */
+		const VIDEO_DEFAULTS_STORAGE_KEY = "dsh-minimax-code.video-defaults";
+		/**
+		* 取浏览器 localStorage，取不到就是 undefined。
+		*
+		* 走 `globalThis` 而不是直接写 `localStorage`：这段代码也会在 jsdom 与 SSR 风格的
+		* 渲染里跑，那种环境下这个全局可能根本不存在。
+		*
+		* @returns storage，或 undefined。
+		*/
+		function browserStorage() {
+			try {
+				const storage = globalThis.localStorage;
+				return typeof storage?.getItem === "function" ? storage : void 0;
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 读一份默认参数。
+		*
+		* 任何解析失败都退化成出厂默认，并且**不写回**：一个被写坏的值留在原处，用户下一次
+		* 保存就覆盖掉它了，中途重建一份没有意义。
+		*
+		* @param storage - 存储；缺省取浏览器 localStorage。
+		* @returns 自洽的默认参数（见 `normalizeVideoDefaults`）。
+		*/
+		function readVideoDefaults(storage = browserStorage()) {
+			if (storage === void 0) return normalizeVideoDefaults({});
+			try {
+				const raw = storage.getItem(VIDEO_DEFAULTS_STORAGE_KEY);
+				if (raw === null || raw.trim() === "") return normalizeVideoDefaults({});
+				return normalizeVideoDefaults(JSON.parse(raw));
+			} catch {
+				return normalizeVideoDefaults({});
+			}
+		}
+		/**
+		* 写一份默认参数。
+		*
+		* 写入被拒绝（配额满、隐私模式）时**返回 false 而不是抛**：设置页要把这件事显示成
+		* 一句提示，而不是让一次点击把整页带崩。
+		*
+		* @param defaults - 要保存的值。
+		* @param storage - 存储；缺省取浏览器 localStorage。
+		* @returns 是否真的写进去了。
+		*/
+		function writeVideoDefaults(defaults, storage = browserStorage()) {
+			if (storage === void 0) return false;
+			try {
+				storage.setItem(VIDEO_DEFAULTS_STORAGE_KEY, JSON.stringify(defaults));
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		//#endregion
+		//#region src/client/minimax-code/MinimaxCodeSection.tsx
+		/**
+		* The MiniMax Code settings card.
+		*
+		* Markup only: every piece of state, every effect and every request this card
+		* makes lives in 'useMinimaxCodeSection.ts', which returns one named shape the
+		* JSX below reads. The two files are the split of a single 915-line component —
+		* the behaviour is unchanged, and this one should stay render-shaped.
+		*/
+		/** Human label per thinking mode, so the card states what the model does. */
+		function thinkingLabel(mode, t) {
+			if (mode === "always-on") return t("thinkingAlwaysOn");
+			if (mode === "forced-effort") return t("thinkingForced");
+			return t("thinkingToggle");
+		}
+		/**
+		* Minutes still left on the access token, or null once it has run out.
+		*
+		* MiniMax Code's token lives about ONE HOUR — measured, not the day an earlier
+		* note assumed — so minutes are the unit the card reports: hours would turn the
+		* whole remaining life into a single digit and hide the point at which the Host
+		* renews the credential. One decimal is kept, so a countdown that is running
+		* out reads as 0.4 rather than as nothing; below one minute the token is
+		* treated as already gone.
+		*/
+		function remainingMinutes(expiresAtMs) {
+			if (expiresAtMs === void 0 || !Number.isFinite(expiresAtMs) || expiresAtMs <= 0) return null;
+			const minutes = (expiresAtMs - Date.now()) / 6e4;
+			if (minutes < 1) return null;
+			return minutes.toFixed(1);
+		}
+		function MinimaxCodeSection({ onModelChange }) {
+			const { state, derived, actions } = useMinimaxCodeSection({ onModelChange });
+			const { status, loading, busy, error, flow, copied, connectionNotice, contextDrafts, savingModel, pool, resetCards, resetNotice, selectedResetCardId } = state;
+			const { authenticated, account, quota, models, contextModels, overrideCount, poolLabels, resetCardList, resetCardFlows } = derived;
+			const { login, cancelLogin, copyCode, logout, poolAction, setStrategy, toggleModel, setAllModels, setCheckinEnabled, runCheckinNow, updateEffort, saveContextWindow, resetContextWindow, resetAllContextWindows, refreshQuota, refreshResetCards, selectResetCard, useResetCard, testConnection, updateContextDraft } = actions;
+			const t = fallbackTranslate$4;
+			const videoDefaultsRef = react.default.useRef(null);
+			if (videoDefaultsRef.current === null) videoDefaultsRef.current = readVideoDefaults();
+			const saveVideoDefaults = react.default.useCallback((next) => {
+				if (!writeVideoDefaults(next)) return false;
+				videoDefaultsRef.current = next;
+				return true;
+			}, []);
+			if (loading) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "dsha-page",
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					className: "dsha-empty",
+					children: t("loading")
+				})
+			});
+			const minutes = remainingMinutes(account?.expiresAtMs);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dsha-page",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsha-muted",
+						children: t("pageDesc")
+					}),
+					pool !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AccountPoolSection, {
+						labels: poolLabels,
+						accounts: pool.accounts,
+						rotationStrategy: pool.rotationStrategy,
+						...pool.activeAccountId === void 0 ? {} : { activeAccountId: pool.activeAccountId },
+						busy,
+						onLogin: () => void login(),
+						onSetPrimary: (accountId) => void poolAction("set-primary", accountId),
+						onDelete: (accountId) => void poolAction("delete", accountId),
+						onClearCooldown: (accountId) => void poolAction("clear-cooldown", accountId),
+						onRelogin: (accountId) => void poolAction("relogin", accountId),
+						onSetStrategy: (strategy) => void setStrategy(strategy),
+						showQuota: true
+					}),
+					status?.checkin != null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+						className: "dsha-group",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "dsha-grouphead",
+								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: t("dailyCheckin") })
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "dsha-muted",
+								children: t("checkinHint")
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "dsha-row",
+								style: { marginBottom: 8 },
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									className: "dsha-label",
+									style: { fontWeight: 600 },
 									children: t("checkinAuto")
 								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 									type: "checkbox",
@@ -7748,7 +8846,7 @@ window.__ModuleLoader__.load({
 										children: t("expiresAt")
 									}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 										className: "dsha-value",
-										children: [formatDate$1(account?.expiresAtMs), hours === null ? ` · ${t("expiresExpired")}` : ` · ${t("expiresRemaining").replace("{hours}", hours)}`]
+										children: [formatDate$1(account?.expiresAtMs), minutes === null ? ` · ${t("expiresExpired")}` : ` · ${t("expiresRemaining").replace("{minutes}", minutes)}`]
 									})]
 								})
 							] }),
@@ -8092,6 +9190,12 @@ window.__ModuleLoader__.load({
 							}, `${entry.cardId}:${entry.createdAtMs}:${index}`))
 						]
 					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(VideoDefaultsSection, {
+						t,
+						initial: videoDefaultsRef.current,
+						onSave: saveVideoDefaults
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(VideoHistorySection, { t }),
 					error !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 						className: "dsha-error",
 						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: error })
@@ -8382,7 +9486,7 @@ window.__ModuleLoader__.load({
 		/** 登录状态机的轮询节奏。真实超时与间隔由 host 拥有，卡片只是跟随。 */
 		const LOGIN_POLL_INTERVAL_MS$1 = 2e3;
 		/** 本卡片的字典；身份稳定，依赖它的 effect 才不会每次渲染重建。 */
-		const fallbackTranslate$2 = (key) => zh$5[key];
+		const fallbackTranslate$3 = (key) => zh$5[key];
 		/**
 		* 共享账号池卡片需要的标签集，按本卡片的字典逐键查出来。
 		*
@@ -8447,7 +9551,7 @@ window.__ModuleLoader__.load({
 			});
 		}
 		function useGlmCodingPlanSection({ onModelChange } = {}) {
-			const t = fallbackTranslate$2;
+			const t = fallbackTranslate$3;
 			const [status, setStatus] = (0, react.useState)(null);
 			const [loading, setLoading] = (0, react.useState)(true);
 			const [busy, setBusy] = (0, react.useState)(null);
@@ -11536,7 +12640,7 @@ window.__ModuleLoader__.load({
 		/** 登录状态机的轮询节奏。真实超时与间隔由 host 拥有，卡片只是跟随。 */
 		const LOGIN_POLL_INTERVAL_MS = 2e3;
 		/** 本卡片的字典；身份稳定，依赖它的 effect 才不会每次渲染重建。 */
-		const fallbackTranslate$1 = (key) => zh$2[key];
+		const fallbackTranslate$2 = (key) => zh$2[key];
 		/**
 		* 共享账号池卡片需要的标签集，按本卡片的字典逐键查出来。
 		*
@@ -11666,7 +12770,7 @@ window.__ModuleLoader__.load({
 		/** 写侧的线路常量；卡片用它渲染说明，而不是渲染一条永远为 0 的进度条。 */
 		const CACHE_WRITE_NOTE = STEP_CODE_CACHE_WRITE_NOTE;
 		function useStepCodeSection({ onModelChange } = {}) {
-			const t = fallbackTranslate$1;
+			const t = fallbackTranslate$2;
 			const [status, setStatus] = (0, react.useState)(null);
 			const [loading, setLoading] = (0, react.useState)(true);
 			const [busy, setBusy] = (0, react.useState)(null);
@@ -14470,79 +15574,733 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
-		//#region src/client/minimax-code/styles.ts
-		const STYLE_ID$3 = "dsh-minimax-code-settings-style";
+		//#region src/client/minimax-code/video-media.tsx
 		/**
-		* MiniMax Code-only additions to the shared settings design system.
+		* 视频字节 → `<video>` 的那一段：对象 URL 的生命周期，以及两个界面共用的
+		* 「视频台」外框。
 		*
-		* The base control styles (.dsha-page, .dsha-group, .dsha-row, .dsha-models,
-		* the device-code box, the meter, the composer badge, ...) come from the
-		* stylesheet the sibling routes install, in the same order the client installs
-		* them, so this file declares only what stays unique to this card: the mono
-		* credential path and the model-name list.
+		* ## 为什么对象 URL 必须由这里管
+		*
+		* `URL.createObjectURL` 生成的地址把整段字节钉在内存里，直到显式
+		* `revokeObjectURL`。视频动辄几十 MB，漏一次就是一次长期泄漏；而 `<video>` 一旦
+		* 拿到 `src` 又会自己缓存。所以生命周期只写在 `useObjectUrl` 里一处：
+		* 字节变了就换新地址并撤旧的，组件卸载就撤当前的。
+		*
+		* ## 为什么两个界面共用一个外框
+		*
+		* 对话流卡片只有约 520px 宽，侧边栏是全尺寸，两者尺寸差一倍——但观众看到的应该
+		* 是**同一个东西的两个尺寸**，不是两套设计。所以 16:9 的视频台只定义一次
+		* （`.dshm-video-stage`），两处都渲染 {@link VideoStage}，差别只剩容器的宽度。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/video-media
 		*/
-		function installMinimaxCodeStyles() {
-			installPluginStyle("minimax-code", `
-.dshm-mono{font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:11px}
-.dshm-model-list{display:flex;flex-wrap:wrap;gap:7px;padding-top:8px}
-.dshm-model-list code{background:var(--dsw-alias-bg-layer-2);border:0.5px solid var(--dsw-alias-border-l2);border-radius:6px;color:var(--dsw-alias-label-secondary);font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:11px;padding:5px 8px;white-space:nowrap}
-.dshm-quota-note{margin-top:12px}
-.dshm-reset-list{display:flex;flex-direction:column;gap:6px;padding-top:8px}
-.dshm-reset-row{align-items:center;justify-content:space-between}
-.dshm-reset-pick{background:none;border:0.5px solid var(--dsw-alias-border-l2);cursor:pointer;padding:4px 8px}
-.dshm-reset-pick[aria-pressed="true"]{border-color:var(--dsw-alias-border-focus,var(--dsw-alias-border-l3));background:var(--dsw-alias-bg-layer-2)}
-`, STYLE_ID$3);
-		}
-		//#endregion
-		//#region src/client/workbuddy/WorkBuddyComposerQuota.tsx
-		const api = createLineApi("/workbuddy/api", "WorkBuddy");
 		/**
-		* Pick the most meaningful number for the badge.
+		* 把一段字节变成一个可播放的对象 URL，并在字节变化或组件卸载时撤销它。
 		*
-		* A bounded allowance is what a user spends down, so it wins over a bare credit
-		* balance; the balance shows only when no percentage is reported. The billing
-		* payload reports both a cycle meter and a package meter, and the cycle meter
-		* is the one that actually resets, so it is preferred when both exist.
+		* 失败（浏览器不支持 Blob URL、或构造抛错）时返回 `failed`，由调用方把占位块
+		* 的文字换成失败措辞——**不抛异常**：一块视频读不出来，不该把整段对话流带崩。
+		*
+		* @param data - 视频字节；`undefined` 表示还没拿到。
+		* @param mediaType - Blob 的 MIME 类型，如 `video/mp4`。
+		* @returns 就绪时的 `url`，或 `failed`，或两者皆无（仍在等字节）。
 		*/
-		function selectBadgeFacts$2(status) {
-			const quota = status?.quota;
-			if (quota === null || quota === void 0) return {
-				text: "—",
-				tooltip: "WorkBuddy quota unavailable — click to refresh",
-				level: "normal"
-			};
-			const meter = (quota.meters ?? []).find((candidate) => candidate.id === "cycle" && candidate.remainingFraction !== null) ?? (quota.meters ?? []).find((candidate) => candidate.remainingFraction !== null);
-			if (meter !== void 0 && meter.remainingFraction !== null) {
-				const remaining = Math.round(meter.remainingFraction * 100);
-				return {
-					text: `${remaining}%`,
-					tooltip: `[WorkBuddy] ${meter.label}: ${remaining}% left`,
-					level: quotaLevel(remaining)
+		function useObjectUrl(data, mediaType) {
+			const [source, setSource] = (0, react.useState)({
+				url: null,
+				failed: false
+			});
+			(0, react.useEffect)(() => {
+				if (data === void 0) {
+					setSource({
+						url: null,
+						failed: false
+					});
+					return;
+				}
+				let url;
+				try {
+					url = URL.createObjectURL(new Blob([data], { type: mediaType }));
+				} catch {
+					setSource({
+						url: null,
+						failed: true
+					});
+					return;
+				}
+				setSource({
+					url,
+					failed: false
+				});
+				return () => {
+					URL.revokeObjectURL(url);
 				};
-			}
-			if (quota.remainingCredits !== null) return {
-				text: String(quota.remainingCredits),
-				tooltip: `[WorkBuddy] Remaining credits: ${quota.remainingCredits}`,
-				level: "normal"
-			};
-			return {
-				text: "—",
-				tooltip: "WorkBuddy quota unavailable — click to refresh",
-				level: "normal"
-			};
+			}, [data, mediaType]);
+			return source;
 		}
-		function WorkBuddyComposerQuota({ directory, loadModelDirectory, t }) {
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ComposerQuotaBadge, {
-				directory,
-				loadModelDirectory,
-				providerId: "workbuddy-subscription",
-				readStatus: (refresh) => refresh ? api.post("/quota") : api.get("/status"),
-				selectFacts: selectBadgeFacts$2,
-				label: t("composerLabel")
+		/**
+		* 16:9 的视频台：深色底、发丝线、letterbox。
+		*
+		* 就绪时是 `<video controls preload="metadata">`（`preload="metadata"` 让浏览器
+		* 先拿时长与首帧，而不是立刻开始整段下载）；否则是同一个外框的虚线形态，
+		* 里面一行 tertiary 说明。**失败时外框不变**——数据仍在屏幕上，只是它读不出来。
+		*
+		* @param props - 对象 URL、占位文案与无障碍名。
+		* @returns 视频台。
+		*/
+		function VideoStage({ url, placeholder, label }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "dshm-video-stage",
+				"data-state": url === null ? "empty" : "ready",
+				children: url === null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: "dshm-video-placeholder",
+					"data-tone": placeholder.tone,
+					children: placeholder.text
+				}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("video", {
+					className: "dshm-video-el",
+					src: url,
+					controls: true,
+					preload: "metadata",
+					"aria-label": label
+				})
 			});
 		}
 		//#endregion
-		//#region src/client/workbuddy/styles.ts
+		//#region src/client/minimax-code/MinimaxVideoDocumentBody.tsx
+		/**
+		* 右侧栏里的视频渲染器：把工作区里的一个 mp4/webm/mov/m4v 播成一段视频。
+		*
+		* ## 它是怎么被选中的
+		*
+		* 两个注册各管一半，缺一不可（形状照抄宿主
+		* `ui-sidebar-documentpreview/src/client/image/index.ts`）：
+		*
+		* 1. `ctx.documentPreviews.register(…)` 声明「mp4 等后缀归我」；
+		*    `priority: 'extension'` 让外部实现排在内置实现之前
+		*    （`document/registry.ts` 的排序规则：档位 → 后缀长度 → 注册先后）。
+		* 2. `sidebar.right.tab.document` 的 keyed 槽用**同一个 id** 注册正文。
+		*    侧边栏按地址选渲染器，选中谁就渲染谁的 keyed 槽。
+		*
+		* `binaryExtensions` 必须与 `extensions` 是同一组后缀：`register` 会拒绝
+		* `binaryExtensions` 里出现在 `extensions` 之外的项。
+		*
+		* ## 字节从哪来
+		*
+		* 宿主的内置图像渲染器不自己取字节——文档预览插件读好了通过 `content` 发下来。
+		* 我们的定义是**后注册的外部实现**，拿不到那条 `bytes-complete` 通路，
+		* 所以按任务要求自己取：`ctx.remote.workspaceFiles.readBytes`，与宿主
+		* `ReadDocumentBytes` 调的是同一个远端。会话 id 取自页签的
+		* `resourceAddress`（`dsh-resource://file/session/<id>/<path>`），路径就是地址里
+		* 那一段——它已经按该会话的工作区根解析过。
+		*
+		* ## 为什么和对话流卡片长得一样
+		*
+		* 两处共用 `.dshm-video-stage` 与 `useObjectUrl`：视频台是**同一个东西的两个尺寸**，
+		* 差别只有容器宽度。侧边栏多一行安静的元数据（文件名 + 体积），因为这里的视频台
+		* 是全尺寸的，下面空着反而显眼。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/MinimaxVideoDocumentBody
+		*/
+		/** 兜底翻译：只在没有 locale 座位时用到。 */
+		function translate$1(key) {
+			return zh$6[key] ?? key;
+		}
+		/**
+		* 一个文件地址里的会话与路径。
+		*
+		* 只认 `session` 作用域：`absolute` 地址没有会话，取字节通道需要会话身份，
+		* 所以那种地址这里当作「没有可读的文件」，由视频台画占位块。
+		* @param address - `dsh-resource://file/…` 地址。
+		* @returns 会话 id 与路径；不是会话地址时 undefined。
+		*/
+		function sessionFileOf(address) {
+			if (address === void 0 || !address.startsWith("dsh-resource://file/")) return void 0;
+			const end = address.search(/[?#]/);
+			const [scope, id, ...rest] = address.slice(20, end === -1 ? void 0 : end).split("/");
+			if (scope !== "session" || id === void 0 || id === "" || rest.length === 0) return void 0;
+			try {
+				return {
+					sessionId: decodeURIComponent(id),
+					path: rest.map(decodeURIComponent).join("/")
+				};
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 侧边栏视频正文。
+		* @param props - 地址、会话、取字节通道与文案。
+		* @returns 16:9 视频台与下方一行元数据。
+		*/
+		function MinimaxVideoDocumentBody(props) {
+			const t = props.t ?? translate$1;
+			const file = sessionFileOf(props.resourceAddress);
+			const sessionId = props.sessionId ?? file?.sessionId;
+			const path = file?.path;
+			const data = useDocumentBytes({
+				readVideo: props.readVideo,
+				sessionId,
+				path
+			});
+			const mediaType = mediaTypeOf(path);
+			const source = useObjectUrl(data.kind === "ready" ? data.data : void 0, mediaType);
+			const placeholder = placeholderFor$1(data, t);
+			const bytes = data.kind === "ready" ? data.data.byteLength : void 0;
+			const name = path === void 0 ? void 0 : fileName(path);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dshm-video-document",
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(VideoStage, {
+					url: source.failed ? null : source.url,
+					placeholder,
+					label: name ?? t("videoTitle")
+				}), name === void 0 || bytes === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: "dshm-video-doc-meta",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dshm-video-doc-name",
+						title: name,
+						children: name
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dshm-video-doc-size",
+						children: t("videoSize").replace("{size}", formatBytes(bytes))
+					})]
+				})]
+			});
+		}
+		/**
+		* 取一次整段视频字节。
+		*
+		* 没有「加载中」这一态：视频台在拿到字节前本来就是虚线占位，多一个中间态只是
+		* 多一次重渲染。卸载或换文件时 abort。
+		* @param input - 通道、会话与路径。
+		* @returns 当前字节状态。
+		*/
+		function useDocumentBytes(input) {
+			const { readVideo, sessionId, path } = input;
+			const [state, setState] = (0, react.useState)({ kind: "idle" });
+			(0, react.useEffect)(() => {
+				if (readVideo === void 0 || sessionId === void 0 || path === void 0) {
+					setState({ kind: "idle" });
+					return;
+				}
+				const controller = new AbortController();
+				let live = true;
+				readVideo(sessionId, path, controller.signal).then((data) => {
+					if (live) setState({
+						kind: "ready",
+						data
+					});
+				}, (error) => {
+					if (live) setState({
+						kind: "failed",
+						reason: videoReadFailureOf(error),
+						limit: videoReadLimitOf(error)
+					});
+				});
+				return () => {
+					live = false;
+					controller.abort();
+				};
+			}, [
+				readVideo,
+				sessionId,
+				path
+			]);
+			return state;
+		}
+		/**
+		* 视频台此刻该说什么。
+		*
+		* 与对话流卡片的同名字面同一套措辞，但这里只有字节这一条信息：侧边栏的地址就是
+		* 用户点开的那个文件，没有「还在生成」这个阶段。**中文最多两句、结尾不加句号**
+		* （DSH 文案规则）。
+		*
+		* `too-large` 是唯一一个「文件没坏、只是不交给浏览器」的失败：那时说成「可能被
+		* 移动或删除」是错的，所以单独一句，并带上宿主报的上限。
+		*
+		* @param data - 当前字节状态。
+		* @param t - 命名空间化的翻译。
+		* @returns 占位文案与色调。
+		*/
+		function placeholderFor$1(data, t) {
+			if (data.kind === "failed") {
+				if (data.reason === "too-large") return {
+					text: videoTooLargeText((key) => t(key), data.limit),
+					tone: "danger"
+				};
+				return {
+					text: t("videoUnreadable"),
+					tone: "danger"
+				};
+			}
+			if (data.kind === "ready") return {
+				text: t("videoUnplayable"),
+				tone: "danger"
+			};
+			return {
+				text: t("videoReading"),
+				tone: "quiet"
+			};
+		}
+		/**
+		* 后缀 → MIME。
+		*
+		* 只覆盖本实现认领的四个后缀，所以查表就是穷举：不认识的进来是编程错误，
+		* 退回 `video/mp4` 而不是抛——一个后缀不该让侧边栏白屏。
+		* @param path - 文件路径。
+		* @returns 该后缀的 MIME 类型。
+		*/
+		function mediaTypeOf(path) {
+			const extension = path === void 0 ? "" : path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+			if (extension === "webm") return "video/webm";
+			if (extension === "mov") return "video/quicktime";
+			if (extension === "m4v") return "video/x-m4v";
+			return "video/mp4";
+		}
+		/**
+		* 路径里的文件名。
+		* @param path - 文件路径。
+		* @returns 最后一个分隔符之后的部分。
+		*/
+		function fileName(path) {
+			const normalized = path.replaceAll("\\", "/");
+			const name = normalized.slice(normalized.lastIndexOf("/") + 1);
+			return name === "" ? normalized : name;
+		}
+		//#endregion
+		//#region src/client/minimax-code/MinimaxVideoToolView.tsx
+		/**
+		* `minimax_generate_video` 在对话流里的工具卡片。
+		*
+		* ## 解剖结构照抄同一仓库的生图卡片
+		*
+		* 状态点 + 标题 + 摘要 + 媒体区，与 `src/client/CodexImageToolView.tsx` 一字不差的
+		* 骨架（`.dsh-codex-image-tool` 那一族）。同一个对话里两张卡片是**同一种东西**：
+		* 一条发丝线、8px 圆角、13px 标题、8px 状态点。差别只在媒体区——那边是图片格，
+		* 这边是 16:9 的视频台。
+		*
+		* ## 三个阶段都要画
+		*
+		* `tool.call.toolview` 交来的 `block` 是阶段相关的：
+		* - `phase: 'preparing'` —— 参数还在流式生成，结果无从谈起；
+		* - `phase: 'start'` —— 参数完整，上游还在生成（**进行中**，视频台空着）；
+		* - `'kind' in block` —— 已结算，`isError` 决定成功还是失败。
+		*
+		* 判断写法与生图卡片同款（`'kind' in block`），因为要面对的正是同一批阶段形状。
+		*
+		* ## 数据只来自 meta
+		*
+		* 视频路径在 `ToolResultNode.meta`（宿主写的 `output.presentationMeta`）里。工具的
+		* 结构化 `value` 不随会话日志持久化，所以这里**不读 `value`**，也不读结果正文
+		* 里的自然语言——读不到 meta 就画占位块，卡片照常显示标题与状态。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/MinimaxVideoToolView
+		*/
+		/** 兜底翻译：只在没有 locale 座位时用到，走同一份 zh 字典。 */
+		function translate(key) {
+			return zh$6[key] ?? key;
+		}
+		/**
+		* 一张视频工具卡片。
+		* @param props - 阶段块、工作区根、打开/取字节通道与文案。
+		* @returns 卡片。
+		*/
+		function MinimaxVideoToolView(props) {
+			const { block, cwd, openFile, readVideo, sessionId } = props;
+			const t = props.t ?? translate;
+			const settled = block.kind !== void 0;
+			const isError = settled && block.isError === true;
+			const meta = settled && !isError ? readVideoMeta(block.meta) : void 0;
+			const summary = promptFromBlock(block) ?? textSummary(block.content);
+			const label = isError ? t("videoToolFailed") : settled ? t("videoToolDone") : t("videoToolRunning");
+			const absolute = meta === void 0 ? void 0 : absoluteVideoPath(cwd, meta.videoPath);
+			const data = useVideoBytes({
+				readVideo,
+				sessionId,
+				path: absolute,
+				enabled: meta !== void 0
+			});
+			const source = useObjectUrl(data.kind === "ready" ? data.data : void 0, meta?.mediaType ?? "video/mp4");
+			const placeholder = placeholderFor({
+				settled,
+				isError,
+				meta,
+				data,
+				source,
+				t
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dshm-video-tool",
+				"data-state": isError ? "error" : settled ? "done" : "running",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dshm-video-head",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dshm-video-dot",
+								"aria-hidden": "true"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dshm-video-title",
+								children: label
+							}),
+							summary === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dshm-video-summary",
+								children: summary
+							})
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(VideoStage, {
+						url: source.failed ? null : source.url,
+						placeholder,
+						label: meta === void 0 ? t("videoToolTitle") : fileNameOf(meta.videoPath)
+					}),
+					meta === void 0 || absolute === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dshm-video-foot",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "dshm-video-path",
+							onClick: () => {
+								openFile?.(absolute, { line: 1 });
+							},
+							title: absolute,
+							children: meta.videoPath
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+							className: "dshm-video-meta",
+							children: [meta.durationSeconds === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: formatDuration(meta.durationSeconds) }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("videoSize").replace("{size}", formatBytes(meta.bytes)) })]
+						})]
+					})
+				]
+			});
+		}
+		/**
+		* 取一次视频字节。
+		*
+		* `enabled` 为假、或通道缺席时什么都不做——一张没有 meta 的卡片不该发出请求。
+		* 卸载或换文件时 abort：面板关掉之后不该还有字节在路上。
+		*
+		* @param input - 通道、会话、路径与开关。
+		* @returns 当前字节状态。
+		*/
+		function useVideoBytes(input) {
+			const { readVideo, sessionId, path, enabled } = input;
+			const [state, setState] = (0, react.useState)({ kind: "idle" });
+			(0, react.useEffect)(() => {
+				if (!enabled || path === void 0 || readVideo === void 0 || sessionId === void 0) {
+					setState({ kind: "idle" });
+					return;
+				}
+				const controller = new AbortController();
+				let live = true;
+				setState({ kind: "loading" });
+				readVideo(sessionId, path, controller.signal).then((data) => {
+					if (live) setState({
+						kind: "ready",
+						data
+					});
+				}, (error) => {
+					if (live) setState({
+						kind: "failed",
+						reason: videoReadFailureOf(error),
+						limit: videoReadLimitOf(error)
+					});
+				});
+				return () => {
+					live = false;
+					controller.abort();
+				};
+			}, [
+				readVideo,
+				sessionId,
+				path,
+				enabled
+			]);
+			return state;
+		}
+		/**
+		* 视频台此刻该说什么。
+		*
+		* 四句话按「谁的问题」排：读不出来是产物的问题，通道缺席是本插件没接上，
+		* 还在生成是时间的问题。**中文最多两句、结尾不加句号**（DSH 文案规则），
+		* 英文同理用句点收尾。
+		*
+		* `too-large` 单独一句：那时文件好好的，只是宿主的整文件上限没把它交出来，
+		* 说成「可能被移动或删除」是在冤枉它。
+		*
+		* @param input - 阶段、meta、字节状态与对象 URL 状态。
+		* @returns 占位文案与色调。
+		*/
+		function placeholderFor(input) {
+			const { settled, isError, meta, data, source, t } = input;
+			if (isError) return {
+				text: t("videoFailed"),
+				tone: "danger"
+			};
+			if (!settled) return {
+				text: t("videoGenerating"),
+				tone: "quiet"
+			};
+			if (meta === void 0) return {
+				text: t("videoNoMeta"),
+				tone: "danger"
+			};
+			if (source.failed) return {
+				text: t("videoUnplayable"),
+				tone: "danger"
+			};
+			if (data.kind === "failed") {
+				if (data.reason === "too-large") return {
+					text: videoTooLargeText((key) => t(key), data.limit),
+					tone: "danger"
+				};
+				return {
+					text: t("videoUnreadable"),
+					tone: "danger"
+				};
+			}
+			if (data.kind === "idle") return {
+				text: t("videoChannelOff"),
+				tone: "danger"
+			};
+			return {
+				text: t("videoReading"),
+				tone: "quiet"
+			};
+		}
+		/**
+		* 从参数里读提示词。
+		*
+		* 三个阶段的读法不同：流式阶段只有前缀视图（`args.text`），完整阶段才有
+		* `argsRaw`。与生图卡片的 `promptFromBlock` 同款。
+		* @param block - 当前阶段块。
+		* @returns 提示词，或 `null`。
+		*/
+		function promptFromBlock(block) {
+			const partial = partialPrompt(block);
+			if (partial !== null) return partial;
+			const raw = block.argsRaw;
+			if (typeof raw !== "string" || raw.trim() === "") return null;
+			try {
+				const value = JSON.parse(raw);
+				return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.prompt === "string" ? value.prompt : null;
+			} catch {
+				return null;
+			}
+		}
+		/**
+		* 流式阶段的提示词前缀。
+		* @param block - 当前阶段块。
+		* @returns 已到达的提示词前缀，或 `null`。
+		*/
+		function partialPrompt(block) {
+			const read = block.args?.text;
+			if (typeof read !== "function") return null;
+			try {
+				const prompt = read.call(block.args, "prompt");
+				return typeof prompt === "string" && prompt !== "" ? prompt : null;
+			} catch {
+				return null;
+			}
+		}
+		/**
+		* 结果正文的第一行文字，当作摘要。
+		* @param blocks - 结算结果的内容块。
+		* @returns 一行摘要，或 `null`。
+		*/
+		function textSummary(blocks) {
+			if (blocks === void 0) return null;
+			const text = blocks.map((content) => content.type === "text" ? content.text : "").filter((line) => typeof line === "string" && line.trim() !== "").join(" ").replace(/s+/g, " ").trim();
+			return text === "" ? null : text;
+		}
+		//#endregion
+		//#region src/client/minimax-code/document-preview.ts
+		/**
+		* MiniMax 视频渲染器的实现身份与 `documentPreviews` 定义。
+		*
+		* 定义形状照抄宿主 `ui-sidebar-documentpreview/src/client/image/index.ts` 的
+		* `imageBodyDefinition`：id / extensions / binaryExtensions / priority / title /
+		* loading / wrap。**id 同时是 keyed 槽的键**——定义与正文必须用同一个字符串，
+		* 否则侧边栏选中了我们、却渲染不出正文。
+		*
+		* 这里是纯数据，不 import 任何槽位或 cordis 类型：定义要能在测试里直接断言形状，
+		* 而 `priority` / `loading` 是字符串字面量联合，写宽了编译器就抓不住笔误。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/document-preview
+		*/
+		/** 本实现在文档预览系统里的身份，也是正文 keyed 槽的键。 */
+		const MINIMAX_VIDEO_PREVIEW_ID = "@eddyskywalker/dsh-chatgpt-subscription/video";
+		/** 本实现认领的文件后缀。 */
+		const MINIMAX_VIDEO_EXTENSIONS = [
+			"mp4",
+			"webm",
+			"mov",
+			"m4v"
+		];
+		/**
+		* 构造视频渲染器的定义。
+		*
+		* `binaryExtensions` 与 `extensions` 用同一个数组：这四个后缀的字节都不能当文本
+		* 读，`register` 也要求前者是后者的子集。
+		*
+		* @param title - 惰性求值的实现名（走本线路的 locale 命名空间）。
+		* @returns 可交给 `ctx.documentPreviews.register` 的定义。
+		*/
+		function minimaxVideoPreviewDefinition(title) {
+			return {
+				id: MINIMAX_VIDEO_PREVIEW_ID,
+				extensions: MINIMAX_VIDEO_EXTENSIONS,
+				binaryExtensions: MINIMAX_VIDEO_EXTENSIONS,
+				priority: "extension",
+				title,
+				loading: "bytes-complete",
+				wrap: false
+			};
+		}
+		//#endregion
+		//#region src/client/minimax-code/styles.ts
+		const STYLE_ID$3 = "dsh-minimax-code-settings-style";
+		/**
+		* MiniMax Code-only additions to the shared settings design system.
+		*
+		* The base control styles (.dsha-page, .dsha-group, .dsha-row, .dsha-models,
+		* the device-code box, the meter, the composer badge, ...) come from the
+		* stylesheet the sibling routes install, in the same order the client installs
+		* them, so this file declares only what stays unique to this card: the mono
+		* credential path and the model-name list.
+		*/
+		function installMinimaxCodeStyles() {
+			installPluginStyle("minimax-code", `
+.dshm-mono{font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:11px}
+.dshm-model-list{display:flex;flex-wrap:wrap;gap:7px;padding-top:8px}
+.dshm-model-list code{background:var(--dsw-alias-bg-layer-2);border:0.5px solid var(--dsw-alias-border-l2);border-radius:6px;color:var(--dsw-alias-label-secondary);font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:11px;padding:5px 8px;white-space:nowrap}
+.dshm-quota-note{margin-top:12px}
+.dshm-reset-list{display:flex;flex-direction:column;gap:6px;padding-top:8px}
+.dshm-reset-row{align-items:center;justify-content:space-between}
+.dshm-reset-pick{background:none;border:0.5px solid var(--dsw-alias-border-l2);cursor:pointer;padding:4px 8px}
+.dshm-reset-pick[aria-pressed="true"]{border-color:var(--dsw-alias-border-focus,var(--dsw-alias-border-l3));background:var(--dsw-alias-bg-layer-2)}
+
+/* ---- MiniMax 视频工具卡片与侧边栏视频台 ----
+ * 解剖结构照抄同仓库的 .dsh-codex-image-tool 一族（发丝线、radius 8、13px 标题、
+ * 8px 状态点、虚线占位块），所以两族卡片放在一起是同一个东西。字重全部 ≤500：
+ * 强调靠字号与墨色，不靠加粗。颜色只用语义 token，不新增任何色值。
+ *
+ * 视频台是两个界面共用的同一个外框：对话流里约 460px 宽，侧边栏里通栏。16:9 的
+ * 固定比例让它在两个尺寸下都是同一个形状。 */
+.dshm-video-tool{border:0.5px solid var(--dsw-alias-border-l2);border-radius:8px;corner-shape:round;display:flex;flex-direction:column;gap:8px;margin:4px 0 4px 4px;max-width:520px;min-width:0;padding:10px 12px}
+.dshm-video-head{align-items:center;display:flex;font-size:13px;gap:8px;min-width:0}
+.dshm-video-dot{background:var(--dsw-alias-button-info-fill,#397ee8);border-radius:50%;corner-shape:round;display:inline-block;flex:none;height:8px;width:8px}
+.dshm-video-tool[data-state=error] .dshm-video-dot{background:var(--dsw-alias-label-danger,#d94b4b)}
+.dshm-video-title{font-weight:500;white-space:nowrap}
+.dshm-video-summary{color:var(--dsw-alias-label-tertiary);font-size:12px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.dshm-video-stage{aspect-ratio:16/9;background:var(--dsw-alias-bg-layer-2);border:0.5px solid var(--dsw-alias-border-l2);border-radius:8px;corner-shape:round;display:flex;min-width:0;overflow:hidden;position:relative;width:100%}
+.dshm-video-stage[data-state=empty]{align-items:center;border-style:dashed;border-width:1px;justify-content:center;padding:16px}
+.dshm-video-el{background:var(--dsw-alias-bg-layer-1,#000);display:block;height:100%;object-fit:contain;width:100%}
+.dshm-video-placeholder{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5;text-align:center}
+.dshm-video-placeholder[data-tone=danger]{color:var(--dsw-alias-label-danger,#d94b4b)}
+.dshm-video-foot{align-items:center;display:flex;font-size:11px;gap:10px;justify-content:space-between;min-width:0}
+.dshm-video-path{background:var(--dsw-alias-bg-layer-2);border:0.5px solid var(--dsw-alias-border-l2);border-radius:6px;color:var(--dsw-alias-label-secondary);cursor:pointer;flex:0 1 auto;font:inherit;font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:11px;line-height:1.35;min-width:0;overflow:hidden;padding:3px 7px;text-align:left;text-overflow:ellipsis;white-space:nowrap}
+.dshm-video-path:hover{background:var(--dsw-alias-interactive-bg-hover)}
+.dshm-video-path:focus-visible{outline:2px solid var(--dsw-alias-button-info-fill,#397ee8);outline-offset:2px}
+.dshm-video-meta{color:var(--dsw-alias-label-tertiary);display:flex;flex:none;font-size:11px;font-variant-numeric:tabular-nums;gap:8px;white-space:nowrap}
+.dshm-video-document{display:flex;flex-direction:column;gap:10px;min-width:0;padding:16px}
+.dshm-video-doc-meta{align-items:baseline;color:var(--dsw-alias-label-tertiary);display:flex;font-size:11px;gap:12px;justify-content:space-between;min-width:0}
+.dshm-video-doc-name{color:var(--dsw-alias-label-secondary);font-family:ui-monospace,SFMono-Regular,Consolas,monospace;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.dshm-video-doc-size{flex:none;font-variant-numeric:tabular-nums;white-space:nowrap}
+@media(max-width:560px){.dshm-video-tool{margin-left:0;max-width:100%}.dshm-video-foot{align-items:flex-start;flex-direction:column;gap:4px}.dshm-video-document{padding:12px 10px}}
+@media(prefers-reduced-motion:reduce){.dshm-video-path{transition:none}}
+/* ---- /video 参数弹窗与设置页的视频分区 ----
+ * 解剖结构照抄同文件的 .dshm-video-* 一族与设置卡的 .dsha-* 基础类：发丝线 0.5px、
+ * radius 8 配 corner-shape:round、字号只用 11/12/13 三档、字重 ≤500、颜色只走
+ * --dsw-alias-* 语义 token，不新增任何色值。
+ *
+ * 弹窗本身是 body portal：输入框所在的容器有 overflow，就地渲染会被裁掉。 */
+.dshm-video-modal-root{align-items:center;display:flex;inset:0;justify-content:center;position:fixed;z-index:1000}
+.dshm-video-modal-mask{background:color-mix(in srgb,var(--dsw-alias-label-primary,#000) 32%,transparent);inset:0;position:absolute}
+.dshm-video-modal{background:var(--dsw-alias-bg-layer-1,#fff);border:0.5px solid var(--dsw-alias-border-l2);border-radius:8px;corner-shape:round;box-shadow:0 12px 40px color-mix(in srgb,var(--dsw-alias-label-primary,#000) 18%,transparent);display:flex;flex-direction:column;max-height:82vh;max-width:560px;min-width:0;position:relative;width:calc(100% - 32px)}
+.dshm-video-modal:focus-visible{outline:2px solid var(--dsw-alias-button-info-fill,#397ee8);outline-offset:2px}
+.dshm-video-modal-head{align-items:center;border-bottom:0.5px solid var(--dsw-alias-border-l2);display:flex;gap:12px;justify-content:space-between;padding:12px 16px}
+.dshm-video-modal-title{font-size:13px;font-weight:500;margin:0}
+.dshm-video-modal-close{background:none;border:0;border-radius:6px;corner-shape:round;color:var(--dsw-alias-label-tertiary);cursor:pointer;font-size:13px;line-height:1;padding:4px 8px}
+.dshm-video-modal-close:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}
+.dshm-video-modal-close:focus-visible{outline:2px solid var(--dsw-alias-button-info-fill,#397ee8);outline-offset:2px}
+.dshm-video-modal-desc{color:var(--dsw-alias-label-tertiary);font-size:11px;margin:0;padding:8px 16px 0}
+.dshm-video-modal-body{display:flex;flex-direction:column;gap:10px;min-height:0;overflow:auto;padding:12px 16px}
+.dshm-video-modal-foot{border-top:0.5px solid var(--dsw-alias-border-l2);display:flex;gap:8px;justify-content:flex-end;padding:12px 16px}
+.dshm-video-field{display:flex;flex-direction:column;gap:5px;min-width:0}
+.dshm-video-field-row{display:flex;flex-wrap:wrap;gap:10px}
+.dshm-video-field-row .dshm-video-field{flex:1 1 140px}
+.dshm-video-field-label{color:var(--dsw-alias-label-secondary);font-size:11px;font-weight:500}
+.dshm-video-input{background:var(--dsw-alias-bg-layer-2);border:0.5px solid var(--dsw-alias-border-l2);border-radius:6px;corner-shape:round;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;min-width:0;padding:6px 8px;width:100%}
+.dshm-video-input:focus-visible{outline:2px solid var(--dsw-alias-button-info-fill,#397ee8);outline-offset:1px}
+.dshm-video-textarea{font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:11px;line-height:1.5;resize:vertical}
+.dshm-video-ratio-locked{align-items:center;display:flex;flex-wrap:wrap;gap:8px}
+.dshm-video-hint{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:1.5}
+.dshm-video-watermark{align-items:center;flex-direction:row;gap:8px}
+.dshm-video-media{border-top:0.5px solid var(--dsw-alias-border-l2);display:flex;flex-direction:column;gap:10px;padding-top:12px}
+.dshm-video-media-title{font-size:12px;font-weight:500;margin:0}
+.dshm-video-issue{color:var(--dsw-alias-label-secondary);font-size:11px;line-height:1.5;margin:0}
+.dshm-video-issue[data-tone=danger]{color:var(--dsw-alias-label-danger,#d94b4b)}
+/* 列表的加载态：骨架，不是 loading 文案。 */
+.dshm-video-skeleton{display:flex;flex-direction:column;gap:6px;padding:10px 0}
+.dshm-video-skeleton span{animation:dshm-video-pulse 1.4s ease-in-out infinite;background:var(--dsw-alias-bg-layer-2);border-radius:6px;corner-shape:round;display:block;height:14px}
+.dshm-video-skeleton span:nth-child(2){opacity:.7;width:82%}
+.dshm-video-skeleton span:nth-child(3){opacity:.45;width:64%}
+@keyframes dshm-video-pulse{0%,100%{opacity:.55}50%{opacity:1}}
+.dshm-video-history{display:flex;flex-direction:column;min-width:0}
+.dshm-video-history-path{color:var(--dsw-alias-label-secondary);flex:1 1 auto;font-size:11px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.dshm-video-history-meta{color:var(--dsw-alias-label-tertiary);flex:none;font-size:11px;font-variant-numeric:tabular-nums}
+@media(max-width:560px){.dshm-video-modal{max-height:88vh;width:calc(100% - 16px)}.dshm-video-field-row{flex-direction:column;gap:8px}}
+@media(prefers-reduced-motion:reduce){.dshm-video-skeleton span{animation:none;opacity:.6}}
+`, STYLE_ID$3);
+		}
+		//#endregion
+		//#region src/client/workbuddy/WorkBuddyComposerQuota.tsx
+		const api = createLineApi("/workbuddy/api", "WorkBuddy");
+		/**
+		* Pick the most meaningful number for the badge.
+		*
+		* A bounded allowance is what a user spends down, so it wins over a bare credit
+		* balance; the balance shows only when no percentage is reported. The billing
+		* payload reports both a cycle meter and a package meter, and the cycle meter
+		* is the one that actually resets, so it is preferred when both exist.
+		*/
+		function selectBadgeFacts$2(status) {
+			const quota = status?.quota;
+			if (quota === null || quota === void 0) return {
+				text: "—",
+				tooltip: "WorkBuddy quota unavailable — click to refresh",
+				level: "normal"
+			};
+			const meter = (quota.meters ?? []).find((candidate) => candidate.id === "cycle" && candidate.remainingFraction !== null) ?? (quota.meters ?? []).find((candidate) => candidate.remainingFraction !== null);
+			if (meter !== void 0 && meter.remainingFraction !== null) {
+				const remaining = Math.round(meter.remainingFraction * 100);
+				return {
+					text: `${remaining}%`,
+					tooltip: `[WorkBuddy] ${meter.label}: ${remaining}% left`,
+					level: quotaLevel(remaining)
+				};
+			}
+			if (quota.remainingCredits !== null) return {
+				text: String(quota.remainingCredits),
+				tooltip: `[WorkBuddy] Remaining credits: ${quota.remainingCredits}`,
+				level: "normal"
+			};
+			return {
+				text: "—",
+				tooltip: "WorkBuddy quota unavailable — click to refresh",
+				level: "normal"
+			};
+		}
+		function WorkBuddyComposerQuota({ directory, loadModelDirectory, t }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ComposerQuotaBadge, {
+				directory,
+				loadModelDirectory,
+				providerId: "workbuddy-subscription",
+				readStatus: (refresh) => refresh ? api.post("/quota") : api.get("/status"),
+				selectFacts: selectBadgeFacts$2,
+				label: t("composerLabel")
+			});
+		}
+		//#endregion
+		//#region src/client/workbuddy/styles.ts
 		const STYLE_ID$2 = "dsh-workbuddy-settings-style";
 		/**
 		* WorkBuddy-only additions to the shared settings design system.
@@ -15056,81 +16814,890 @@ window.__ModuleLoader__.load({
 						}, 1500);
 					} catch {}
 				});
-				const handleZoom = (e) => {
-					e.stopPropagation();
-					openZoomModal(cleanSvg);
+				const handleZoom = (e) => {
+					e.stopPropagation();
+					openZoomModal(cleanSvg);
+				};
+				wrapper.querySelector("[data-btn=\"zoom\"]")?.addEventListener("click", handleZoom);
+				chartEl?.addEventListener("click", handleZoom);
+				host.style.display = "none";
+				host.parentNode?.insertBefore(wrapper, host);
+				host.setAttribute("data-dsh-mermaid-status", "done");
+			} catch {
+				processedHosts.delete(host);
+				host.removeAttribute("data-dsh-mermaid-status");
+				const errContainer = document.getElementById(renderId);
+				if (errContainer) errContainer.remove();
+			}
+		}
+		function scanAndRenderMermaid() {
+			if (typeof document === "undefined") return;
+			const codeElements = document.querySelectorAll("pre code, .md-code-block code");
+			for (const codeEl of codeElements) {
+				const candidate = findMermaidCandidate(codeEl);
+				if (candidate) renderMermaidHost(candidate.host, candidate.code);
+			}
+		}
+		function setupMermaidObserver() {
+			if (typeof document === "undefined") return () => {};
+			installMermaidStyles();
+			let timer;
+			const debouncedScan = () => {
+				window.clearTimeout(timer);
+				timer = window.setTimeout(() => {
+					scanAndRenderMermaid();
+				}, 250);
+			};
+			debouncedScan();
+			const observer = new MutationObserver((mutations) => {
+				let shouldScan = false;
+				for (const m of mutations) {
+					for (const node of m.addedNodes) if (node.nodeType === 1) {
+						const el = node;
+						if (el.classList?.contains("dsh-mermaid-wrapper") || el.closest?.(".dsh-mermaid-wrapper")) continue;
+						shouldScan = true;
+						break;
+					}
+					if (shouldScan) break;
+				}
+				if (shouldScan) debouncedScan();
+			});
+			observer.observe(document.body, {
+				childList: true,
+				subtree: true
+			});
+			const themeObserver = new MutationObserver(() => {
+				initMermaidConfig();
+				for (const el of document.querySelectorAll("[data-dsh-mermaid-status=\"done\"]")) {
+					processedHosts.delete(el);
+					el.removeAttribute("data-dsh-mermaid-status");
+					const prevWrapper = el.previousElementSibling;
+					if (prevWrapper && prevWrapper.classList.contains("dsh-mermaid-wrapper")) prevWrapper.remove();
+					el.style.display = "";
+				}
+				debouncedScan();
+			});
+			themeObserver.observe(document.documentElement, {
+				attributes: true,
+				attributeFilter: [
+					"class",
+					"data-theme",
+					"data-color-mode"
+				]
+			});
+			return () => {
+				observer.disconnect();
+				themeObserver.disconnect();
+				window.clearTimeout(timer);
+			};
+		}
+		//#endregion
+		//#region src/client/minimax-code/VideoFormDialog.tsx
+		/**
+		* `/video` 的参数弹窗：把「有哪些参数」和「哪些组合合法」一次讲清楚。
+		*
+		* ## 为什么是一个自建弹窗，而不是宿主的 popupSelect
+		*
+		* 宿主的 popupSelect 只有 `options()` 与 `onSelect()`（`ui-commands/src/client/
+		* contract.ts:64-75`），**单选**，装不下「提示词 + 模型 + 比例 + 时长 + 分辨率 +
+		* 四类参考文件 + 水印」。而 `ActionSpec.run(session)` 的契约明写它「不提交任何
+		* 东西」，所以命令自己也发不出去。`/video` 因此是两级：popupSelect 给预设档
+		* （见 `video-command.ts`），「自定义…」这一档打开本组件。
+		*
+		* ## 关键行为：它**不发送**，只把参数写进输入框
+		*
+		* 这是这次入口的核心价值。视频参数有联动规则（给了首帧→比例被强制改成
+		* `adaptive`；纯文本→`adaptive` 不可选），如果直接发起生成，用户永远看不到
+		* 自己填的东西被改成了什么。所以这里只调用 `setDraft`，把
+		* {@link buildVideoDraftText} 拼出来的那段话放进输入框，剩下的交给用户。
+		*
+		* ## 弹窗怎么落地
+		*
+		* 宿主有 `@deepseek-ai/dsh-client-ui-primitives` 的 `Modal`（`Modal.tsx:48`，
+		* 内部 `createPortal(..., document.body)` 在 `:57-90`）。**本插件不依赖那个包的
+		* 运行时**（`progress-updates/markdown-lite.tsx:6` 记录了这个决定：它的 `lib`
+		* 是宿主装配产物，插件装不到），所以这里按同一形状自己 portal 到 `document.body`：
+		* 遮罩 + 居中卡片 + `role="dialog"` + `aria-modal` + Escape 关闭 + 点遮罩关闭。
+		* portal 到 body 是必须的——输入框所在的那片容器有 `overflow`，就地渲染会被裁掉。
+		*
+		* ## 键盘可达性
+		*
+		* 卡片带 `tabIndex={-1}` 并在打开时聚焦，Tab 因此从卡片内部开始按 DOM 顺序走遍
+		* 每个字段；Escape 关闭（在 `keydown` 捕获阶段处理，输入框里的 Escape 也生效）；
+		* 关闭后焦点还给打开它的元素，见 {@link VideoFormDialog} 里的 `restoreFocus`。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/video-form-dialog
+		*/
+		/** 把校验问题翻成一句话。中文最多两句、结尾不加句号。 */
+		function issueText(issue, t) {
+			const params = issue.params ?? {};
+			switch (issue.code) {
+				case "prompt-empty": return t("videoPromptRequired");
+				case "reference-unsupported": return t("videoMediaUnsupported", params);
+				case "last-frame-unsupported": return t("videoLastFrameUnsupported", params);
+				case "too-many-images": return t("videoTooManyImages", params);
+				case "too-many-videos": return t("videoTooManyVideos", params);
+				case "too-many-audios": return t("videoTooManyAudios", params);
+				case "too-many-total": return t("videoTooManyTotal", params);
+				case "duration-invalid": return t("videoDurationInvalid", params);
+				default: return t("unknown");
+			}
+		}
+		/** 一个带标签的表单行。标签与控件用 `useId` 关联，屏幕阅读器读得到。 */
+		function Field({ label, id, children }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dshm-video-field",
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+					className: "dshm-video-field-label",
+					htmlFor: id,
+					children: label
+				}), children]
+			});
+		}
+		/**
+		* 参数弹窗。
+		*
+		* 受控到组件内部：`/video` 只负责开与关，表单状态活在这里，关闭即丢弃——一次
+		* 生成填一次参数，没有「上次填到一半」的语义要维护。
+		*/
+		function VideoFormDialog({ open, onClose, onSubmit, defaults, t }) {
+			const seeded = (0, react.useMemo)(() => normalizeVideoDefaults(defaults ?? {}), [defaults]);
+			const [prompt, setPrompt] = (0, react.useState)("");
+			const [model, setModel] = (0, react.useState)(seeded.model);
+			const [ratio, setRatio] = (0, react.useState)(seeded.ratio);
+			const [durationSeconds, setDurationSeconds] = (0, react.useState)(seeded.durationSeconds);
+			const [resolution, setResolution] = (0, react.useState)(defaultResolution(seeded.model));
+			const [watermark, setWatermark] = (0, react.useState)(seeded.watermark);
+			const [inputImagePath, setInputImagePath] = (0, react.useState)("");
+			const [lastFrameImagePath, setLastFrameImagePath] = (0, react.useState)("");
+			const [referenceImages, setReferenceImages] = (0, react.useState)("");
+			const [referenceVideos, setReferenceVideos] = (0, react.useState)("");
+			const [referenceVideoDurations, setReferenceVideoDurations] = (0, react.useState)("");
+			const [referenceAudios, setReferenceAudios] = (0, react.useState)("");
+			const [notice, setNotice] = (0, react.useState)(null);
+			const dialog = (0, react.useRef)(null);
+			const restoreFocus = (0, react.useRef)(null);
+			const promptRef = (0, react.useRef)(null);
+			const promptId = "dshm-video-prompt";
+			const modelId = "dshm-video-model";
+			const ratioId = "dshm-video-ratio";
+			const durationId = "dshm-video-duration";
+			const resolutionId = "dshm-video-resolution";
+			(0, react.useEffect)(() => {
+				if (!open) return;
+				const seed = normalizeVideoDefaults(defaults ?? {});
+				setPrompt("");
+				setModel(seed.model);
+				setRatio(seed.ratio);
+				setDurationSeconds(seed.durationSeconds);
+				setResolution(defaultResolution(seed.model));
+				setWatermark(seed.watermark);
+				setInputImagePath("");
+				setLastFrameImagePath("");
+				setReferenceImages("");
+				setReferenceVideos("");
+				setReferenceVideoDurations("");
+				setReferenceAudios("");
+				setNotice(null);
+				restoreFocus.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+				const frame = requestAnimationFrame(() => {
+					promptRef.current?.focus();
+				});
+				return () => {
+					cancelAnimationFrame(frame);
+					restoreFocus.current?.focus();
+				};
+			}, [open]);
+			(0, react.useEffect)(() => {
+				if (!open) return;
+				const onKeyDown = (event) => {
+					if (event.key !== "Escape") return;
+					event.stopPropagation();
+					onClose();
+				};
+				document.addEventListener("keydown", onKeyDown, true);
+				return () => {
+					document.removeEventListener("keydown", onKeyDown, true);
+				};
+			}, [open, onClose]);
+			const media = (0, react.useMemo)(() => ({
+				...inputImagePath.trim() === "" ? {} : { inputImagePath },
+				...lastFrameImagePath.trim() === "" ? {} : { lastFrameImagePath },
+				referenceImagePaths: parsePathLines(referenceImages),
+				referenceVideoPaths: parsePathLines(referenceVideos),
+				referenceVideoDurationSeconds: parsePathLines(referenceVideoDurations).map((line) => Number(line)).filter((value) => Number.isFinite(value) && value > 0),
+				referenceAudioPaths: parsePathLines(referenceAudios)
+			}), [
+				inputImagePath,
+				lastFrameImagePath,
+				referenceImages,
+				referenceVideos,
+				referenceVideoDurations,
+				referenceAudios
+			]);
+			const presence = (0, react.useMemo)(() => mediaPresence(media), [media]);
+			const ratioChoice = (0, react.useMemo)(() => resolveVideoRatioChoice({
+				model,
+				...ratio === void 0 ? {} : { requested: ratio },
+				hasKeyframes: presence.hasKeyframes,
+				hasReferences: presence.hasReferences
+			}), [
+				model,
+				ratio,
+				presence.hasKeyframes,
+				presence.hasReferences
+			]);
+			const values = (0, react.useMemo)(() => ({
+				prompt,
+				model,
+				...ratioChoice.ratio === void 0 ? {} : { ratio: ratioChoice.ratio },
+				...durationSeconds === void 0 ? {} : { durationSeconds },
+				...resolution === void 0 ? {} : { resolution },
+				watermark,
+				media
+			}), [
+				prompt,
+				model,
+				ratioChoice.ratio,
+				durationSeconds,
+				resolution,
+				watermark,
+				media
+			]);
+			const issues = (0, react.useMemo)(() => validateVideoForm(values), [values]);
+			const submittable = canSubmitVideoForm(values);
+			const rule = videoModelRule(model);
+			const durations = durationChoices(model);
+			const ratios = ratioChoice.options;
+			const onModelChange = (0, react.useCallback)((next) => {
+				setModel(next);
+				const allowedDurations = durationChoices(next);
+				setDurationSeconds((current) => current !== void 0 && allowedDurations.includes(current) ? current : defaultDuration(next));
+				const allowedResolutions = videoModelRule(next)?.resolutions ?? [];
+				setResolution((current) => current !== void 0 && allowedResolutions.includes(current) ? current : defaultResolution(next));
+				setRatio(void 0);
+			}, []);
+			const submit = (0, react.useCallback)(() => {
+				if (!submittable) {
+					setNotice({
+						tone: "danger",
+						text: t("videoPromptRequired")
+					});
+					return;
+				}
+				if (!onSubmit(buildVideoDraftText({
+					...values,
+					...resolution === void 0 ? {} : { resolution }
+				}))) {
+					setNotice({
+						tone: "danger",
+						text: t("videoDraftFailed")
+					});
+					return;
+				}
+				onClose();
+			}, [
+				onClose,
+				onSubmit,
+				submittable,
+				t,
+				values
+			]);
+			if (!open) return null;
+			return (0, react_dom.createPortal)(/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dshm-video-modal-root",
+				role: "presentation",
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					className: "dshm-video-modal-mask",
+					"aria-hidden": "true",
+					onClick: onClose
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					ref: dialog,
+					className: "dshm-video-modal",
+					role: "dialog",
+					"aria-modal": "true",
+					"aria-label": t("videoDialogTitle"),
+					tabIndex: -1,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dshm-video-modal-head",
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+								className: "dshm-video-modal-title",
+								children: t("videoDialogTitle")
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: "dshm-video-modal-close",
+								"aria-label": t("videoClose"),
+								onClick: onClose,
+								children: "×"
+							})]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							className: "dshm-video-modal-desc",
+							children: t("videoDialogDesc")
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dshm-video-modal-body",
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+									label: t("videoPromptLabel"),
+									id: promptId,
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+										ref: promptRef,
+										id: promptId,
+										className: "dshm-video-input dshm-video-textarea",
+										rows: 3,
+										placeholder: t("videoPromptPlaceholder"),
+										value: prompt,
+										onChange: (event) => {
+											setPrompt(event.currentTarget.value);
+											setNotice(null);
+										}
+									})
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									className: "dshm-video-field-row",
+									children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+											label: t("videoModelLabel"),
+											id: modelId,
+											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+												id: modelId,
+												className: "dshm-video-input",
+												value: model,
+												onChange: (event) => {
+													onModelChange(event.currentTarget.value);
+												},
+												children: MINIMAX_VIDEO_MODELS.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+													value: entry,
+													children: entry
+												}, entry))
+											})
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+											label: t("videoDurationLabel"),
+											id: durationId,
+											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+												id: durationId,
+												className: "dshm-video-input",
+												value: durationSeconds === void 0 ? "" : String(durationSeconds),
+												onChange: (event) => {
+													const next = Number(event.currentTarget.value);
+													setDurationSeconds(Number.isFinite(next) ? next : void 0);
+												},
+												children: durations.map((value) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("option", {
+													value: String(value),
+													children: [
+														value,
+														" ",
+														t("videoDurationUnit")
+													]
+												}, value))
+											})
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+											label: t("videoResolutionLabel"),
+											id: resolutionId,
+											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+												id: resolutionId,
+												className: "dshm-video-input",
+												value: resolution ?? defaultResolution(model) ?? "",
+												onChange: (event) => {
+													const next = event.currentTarget.value;
+													setResolution(rule?.resolutions.includes(next) === true ? next : void 0);
+												},
+												children: (rule?.resolutions ?? []).map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+													value: entry,
+													children: entry
+												}, entry))
+											})
+										})
+									]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Field, {
+									label: t("videoRatioLabel"),
+									id: ratioId,
+									children: [ratioChoice.selectable ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+										id: ratioId,
+										className: "dshm-video-input",
+										value: ratioChoice.ratio ?? "",
+										onChange: (event) => {
+											const next = event.currentTarget.value;
+											setRatio(ratios.includes(next) ? next : void 0);
+										},
+										children: ratios.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+											value: entry,
+											children: entry
+										}, entry))
+									}) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+										className: "dshm-video-ratio-locked",
+										id: ratioId,
+										children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("code", {
+											className: "dshm-mono",
+											children: ratioChoice.ratio ?? t("unknown")
+										}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+											className: "dshm-video-hint",
+											children: t("videoRatioLockedKeyframes")
+										})]
+									}), ratioChoice.selectable && ratioChoice.lockedReason === "text-only" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "dshm-video-hint",
+										children: t("videoRatioLockedTextOnly")
+									})]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									className: "dshm-video-field-row dshm-video-watermark",
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+										className: "dshm-video-field-label",
+										htmlFor: "dshm-video-watermark",
+										children: t("videoWatermarkLabel")
+									}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+										id: "dshm-video-watermark",
+										type: "checkbox",
+										checked: watermark,
+										onChange: (event) => {
+											setWatermark(event.currentTarget.checked);
+										}
+									})]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									className: "dshm-video-media",
+									children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+											className: "dshm-video-media-title",
+											children: t("videoMediaSection")
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+											className: "dshm-video-hint",
+											children: t("videoMediaHint")
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+											label: t("videoInputImageLabel"),
+											id: "dshm-video-input-image",
+											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+												id: "dshm-video-input-image",
+												className: "dshm-video-input",
+												type: "text",
+												value: inputImagePath,
+												onChange: (event) => {
+													setInputImagePath(event.currentTarget.value);
+												}
+											})
+										}),
+										rule?.supportsReferenceMedia === true && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+											label: t("videoLastFrameLabel"),
+											id: "dshm-video-last-frame",
+											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+												id: "dshm-video-last-frame",
+												className: "dshm-video-input",
+												type: "text",
+												value: lastFrameImagePath,
+												onChange: (event) => {
+													setLastFrameImagePath(event.currentTarget.value);
+												}
+											})
+										}),
+										rule?.supportsReferenceMedia === true && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+											/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+												label: t("videoReferenceImagesLabel"),
+												id: "dshm-video-ref-images",
+												children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+													id: "dshm-video-ref-images",
+													className: "dshm-video-input dshm-video-textarea",
+													rows: 2,
+													value: referenceImages,
+													onChange: (event) => {
+														setReferenceImages(event.currentTarget.value);
+													}
+												})
+											}),
+											/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+												label: t("videoReferenceVideosLabel"),
+												id: "dshm-video-ref-videos",
+												children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+													id: "dshm-video-ref-videos",
+													className: "dshm-video-input dshm-video-textarea",
+													rows: 2,
+													value: referenceVideos,
+													onChange: (event) => {
+														setReferenceVideos(event.currentTarget.value);
+													}
+												})
+											}),
+											/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+												label: t("videoReferenceVideoDurationsLabel"),
+												id: "dshm-video-ref-video-durations",
+												children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+													id: "dshm-video-ref-video-durations",
+													className: "dshm-video-input dshm-video-textarea",
+													rows: 2,
+													value: referenceVideoDurations,
+													onChange: (event) => {
+														setReferenceVideoDurations(event.currentTarget.value);
+													}
+												})
+											}),
+											/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+												label: t("videoReferenceAudiosLabel"),
+												id: "dshm-video-ref-audios",
+												children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+													id: "dshm-video-ref-audios",
+													className: "dshm-video-input dshm-video-textarea",
+													rows: 2,
+													value: referenceAudios,
+													onChange: (event) => {
+														setReferenceAudios(event.currentTarget.value);
+													}
+												})
+											})
+										] })
+									]
+								}),
+								issues.filter((issue) => issue.code !== "prompt-empty").map((issue) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									className: "dshm-video-issue",
+									"data-tone": "danger",
+									children: issueText(issue, t)
+								}, issue.code)),
+								notice !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									className: "dshm-video-issue",
+									"data-tone": notice.tone,
+									role: "status",
+									children: notice.text
+								})
+							]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dshm-video-modal-foot",
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: "dsha-btn",
+								onClick: onClose,
+								children: t("videoCancel")
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: "dsha-btn dsha-btn-primary",
+								disabled: !submittable,
+								onClick: submit,
+								children: t("videoSubmit")
+							})]
+						})
+					]
+				})]
+			}), document.body);
+		}
+		/**
+		* 预设档表。
+		*
+		* 每一行都是「模型 × 比例 × 时长 × 分辨率」的一个**实测合法**组合：
+		*
+		* - H3：4-15 秒、768P/2K；H3-Max：5-15 秒、480P/768P；Hailuo：6 或 10 秒、768P/1080P；
+		* - 比例是纯文本分支，所以 `adaptive` 一律不出现（那是首帧/参考媒体的分支才会有的值）。
+		*
+		* 时长都取各模型的下界，理由与 {@link defaultDuration} 相同：第一档应当是最便宜的
+		* 一次生成。用户要别的组合，走「自定义…」。
+		*/
+		function videoPresets(t) {
+			const rows = [];
+			for (const rule of VIDEO_MODEL_RULES) {
+				const duration = defaultDuration(rule.model);
+				const resolution = defaultResolution(rule.model);
+				if (duration === void 0 || resolution === void 0) continue;
+				const ratio = rule.isH3Family ? "16:9" : void 0;
+				rows.push({
+					preset: {
+						id: rule.model + ":" + String(duration) + ":" + resolution,
+						model: rule.model,
+						ratio,
+						durationSeconds: duration,
+						resolution
+					},
+					label: rule.model + " · " + String(duration) + t("videoDurationUnit") + " · " + resolution + (ratio === void 0 ? "" : " · " + ratio)
+				});
+			}
+			return rows;
+		}
+		//#endregion
+		//#region src/client/minimax-code/video-command.ts
+		/** 本线路的 provider id（宿主 `PROVIDER_ID` 的同值副本）。 */
+		const MINIMAX_CODE_PROVIDER = "minimax-code";
+		/** `/video` 里「自定义…」那一行的 id。 */
+		const CUSTOM_OPTION_ID = "custom";
+		/** 本模块登记的命令名。 */
+		const VIDEO_COMMAND_NAME = "video";
+		/**
+		* 这条会话的模型路由，读不到就是 undefined。
+		*
+		* 路径与宿主 `submissionState` 一致：投影 → `next` 优先、`lastUsed` 兜底 →
+		* provider。**全程可选链**：投影没注册、快照是 undefined、字段缺失，都在这里
+		* 变成 undefined，而不是一次异常。
+		*
+		* @param ctx - 浏览器根上下文（或注入了 `sessions` 的 scope）。
+		* @param sessionId - 会话 id。
+		* @returns 形如 `{ provider, model }` 的路由，或 undefined。
+		*/
+		function sessionRouteOf(ctx, sessionId) {
+			try {
+				const snapshot = ((ctx.sessions?.binding?.(sessionId))?.session?.projections?.faceOf?.("modelSelection"))?.getSnapshot?.();
+				if (typeof snapshot !== "object" || snapshot === null) return void 0;
+				const record = snapshot;
+				const pick = (value) => {
+					if (typeof value !== "object" || value === null) return void 0;
+					const candidate = value;
+					if (typeof candidate.provider !== "string" || candidate.provider === "") return void 0;
+					if (typeof candidate.model !== "string" || candidate.model === "") return void 0;
+					return {
+						provider: candidate.provider,
+						model: candidate.model
+					};
 				};
-				wrapper.querySelector("[data-btn=\"zoom\"]")?.addEventListener("click", handleZoom);
-				chartEl?.addEventListener("click", handleZoom);
-				host.style.display = "none";
-				host.parentNode?.insertBefore(wrapper, host);
-				host.setAttribute("data-dsh-mermaid-status", "done");
+				return pick(record.next) ?? pick(record.lastUsed);
 			} catch {
-				processedHosts.delete(host);
-				host.removeAttribute("data-dsh-mermaid-status");
-				const errContainer = document.getElementById(renderId);
-				if (errContainer) errContainer.remove();
+				return;
 			}
 		}
-		function scanAndRenderMermaid() {
-			if (typeof document === "undefined") return;
-			const codeElements = document.querySelectorAll("pre code, .md-code-block code");
-			for (const codeEl of codeElements) {
-				const candidate = findMermaidCandidate(codeEl);
-				if (candidate) renderMermaidHost(candidate.host, candidate.code);
+		/**
+		* 把一段文本写进该会话的输入框。
+		*
+		* 走宿主的 `SessionInput.setDraft`（`ui-conversation/src/client/contract/input.ts:186`），
+		* 不是 `prompt`：后者会绕过输入框直接把一条用户消息发出去，用户就看不见自己填了
+		* 什么。`for(actx)` 要求一个**会话作用域的 Context**，正是
+		* `ctx.sessions.binding(id).ctx`（见 `session-controller/src/client/sessions/service.ts:101-108`）。
+		*
+		* @param ctx - 浏览器根上下文。
+		* @param sessionId - 目标会话。
+		* @param text - 要填入的文本。
+		* @returns 是否真的填进去了。
+		*/
+		function fillComposer(ctx, sessionId, text) {
+			try {
+				const actx = (ctx.sessions?.binding?.(sessionId))?.ctx;
+				if (actx === void 0) return false;
+				const input = ctx.conversation?.input?.for?.(actx);
+				if (typeof input?.setDraft !== "function") return false;
+				input.setDraft(text);
+				return true;
+			} catch {
+				return false;
 			}
 		}
-		function setupMermaidObserver() {
-			if (typeof document === "undefined") return () => {};
-			installMermaidStyles();
-			let timer;
-			const debouncedScan = () => {
-				window.clearTimeout(timer);
-				timer = window.setTimeout(() => {
-					scanAndRenderMermaid();
-				}, 250);
-			};
-			debouncedScan();
-			const observer = new MutationObserver((mutations) => {
-				let shouldScan = false;
-				for (const m of mutations) {
-					for (const node of m.addedNodes) if (node.nodeType === 1) {
-						const el = node;
-						if (el.classList?.contains("dsh-mermaid-wrapper") || el.closest?.(".dsh-mermaid-wrapper")) continue;
-						shouldScan = true;
-						break;
+		/** 兜底翻译：只在没有 locale 服务时用到（测试、以及菜单渲染早于字典注册）。 */
+		function fallbackTranslate$1(key, params) {
+			const template = zh$6[key] ?? key;
+			if (params === void 0) return template;
+			return template.replace(/\{(\w+)\}/g, (_match, name) => String(params[name] ?? ""));
+		}
+		/**
+		* 把一条预设档拼成填进输入框的那段话。
+		*
+		* 提示词留一条**待填的占位**，而不是随便编一句：用户选了「H3 · 4秒 · 768P」之后，
+		* 真正缺的只有画面描述，那一条应当由他来写。
+		*
+		* @param preset - 选中的预设档。
+		* @returns 填进输入框的文本。
+		*/
+		function presetDraftText(preset) {
+			return buildVideoDraftText({
+				prompt: "（在这里写画面描述）",
+				model: preset.model,
+				...preset.ratio === void 0 ? {} : { ratio: preset.ratio },
+				durationSeconds: preset.durationSeconds,
+				resolution: preset.resolution,
+				media: {}
+			});
+		}
+		/**
+		* 构造 `/video` 的 `CommandContribution`。
+		*
+		* 注册在插件的 `ctx.inject(['commandUi'], scope => …)` 里，与宿主
+		* `ui-message-feedback` 的 `/feedback` 装饰同一种接线方式。
+		*
+		* @param ctx - 浏览器根上下文。
+		* @param options - 打开弹窗与填输入框的通道。
+		* @returns 一份可直接交给 `commandUi.register` 的贡献。
+		*/
+		function createVideoCommand(ctx, options) {
+			const t = options.translate ?? fallbackTranslate$1;
+			const fill = options.fill ?? ((sessionId, text) => fillComposer(ctx, sessionId, text));
+			const defaultsOf = options.defaults ?? (() => normalizeVideoDefaults({}));
+			return {
+				name: VIDEO_COMMAND_NAME,
+				label: () => t("videoCommandLabel"),
+				description: () => t("videoCommandDesc"),
+				available: (session) => sessionRouteOf(ctx, session.sessionId)?.provider === MINIMAX_CODE_PROVIDER,
+				ui: {
+					kind: "popupSelect",
+					options: async () => {
+						const rows = videoPresets(t).map(({ preset, label }) => ({
+							id: preset.id,
+							label,
+							group: {
+								name: "preset",
+								label: t("videoPresetGroup")
+							}
+						}));
+						rows.push({
+							id: CUSTOM_OPTION_ID,
+							label: t("videoPresetCustom"),
+							detail: t("videoPresetCustomDesc"),
+							group: {
+								name: "custom",
+								label: t("videoPresetCustom")
+							}
+						});
+						return rows;
+					},
+					onSelect: async (option, session) => {
+						const defaults = defaultsOf();
+						if (option.id === "custom") {
+							options.openForm(session.sessionId, defaults);
+							return;
+						}
+						const preset = videoPresets(t).find((row) => row.preset.id === option.id)?.preset;
+						if (preset === void 0) return;
+						fill(session.sessionId, presetDraftText(preset));
 					}
-					if (shouldScan) break;
 				}
-				if (shouldScan) debouncedScan();
-			});
-			observer.observe(document.body, {
-				childList: true,
-				subtree: true
-			});
-			const themeObserver = new MutationObserver(() => {
-				initMermaidConfig();
-				for (const el of document.querySelectorAll("[data-dsh-mermaid-status=\"done\"]")) {
-					processedHosts.delete(el);
-					el.removeAttribute("data-dsh-mermaid-status");
-					const prevWrapper = el.previousElementSibling;
-					if (prevWrapper && prevWrapper.classList.contains("dsh-mermaid-wrapper")) prevWrapper.remove();
-					el.style.display = "";
+			};
+		}
+		//#endregion
+		//#region src/client/minimax-code/video-command-host.tsx
+		/**
+		* 「/video 命令 + 参数弹窗」的挂载点，由 `src/client/index.tsx` 调用。
+		*
+		* 挂两样东西：
+		*
+		* 1. **弹窗的渲染座位**：一个客户端容器，portal 到 `document.body`。它不挂在任何
+		*    会话槽位上——弹窗是**全局**的，而 `/video` 命令的回调在一段没有 React 树的
+		*    代码里；把两者连起来的是这个容器持有的 `open` 状态加一个模块级句柄。
+		* 2. **命令本体**：`createVideoCommand` 产出的 popupSelect 贡献，注册到
+		*    `ctx.commandUi`，与宿主 `ui-message-feedback` 的 `/feedback` 装饰同一形状。
+		*
+		* ## 为什么命令回调要经过一个句柄
+		*
+		* `CommandUiSpec` 的回调是普通函数，不是 React 组件，拿不到 setState。所以容器把
+		* 自己的 `openForm` 登记到一个模块级的可变引用上，命令回调通过它打开弹窗。容器
+		* 卸载时把这个引用清掉（只清自己那一个），回调因此永远调不到一个已卸载的组件。
+		*
+		* ## 注册失败了怎么办
+		*
+		* 与家族其它模块一致：吞掉、不抛。web shell 在插件 apply 抛错时整页启动失败，
+		* 一个外部插件不能因为「宿主这一版没有 commandUi」就把 GUI 带下水。
+		*
+		* @module @eddyskywalker/dsh-chatgpt-subscription/client/minimax-code/video-command-host
+		*/
+		/**
+		* 当前挂着的容器句柄。
+		*
+		* 模块级的可变引用是刻意的：命令回调由宿主持有，它没有别的通道能碰到 React 树。
+		* 只允许一个值，因为一个浏览器页只有一棵树、一个弹窗。
+		*/
+		let activeHandle;
+		/**
+		* 打开参数弹窗。
+		*
+		* 没有容器挂着时什么也不做——插件被禁用、或页面还没挂载时调到这里，静默即可；
+		* 抛错只会让一次斜杠菜单点击变成控制台里的一条异常。
+		*
+		* @param sessionId - 会话 id。
+		* @param defaults - 表单起手值。
+		*/
+		function openVideoForm(sessionId, defaults) {
+			activeHandle?.(sessionId, defaults);
+		}
+		/**
+		* 构造弹窗容器。
+		*
+		* 常驻挂载、`open` 为 false 时渲染出 null，而不是按需创建：请求来自命令回调，那时
+		* 组件树已经渲染完了，没有第二次渲染去创建它。
+		*
+		* @param ctx - 浏览器根上下文；提交时用它把文本写进对应会话的输入框。
+		* @returns 一个不需要 props 的组件。
+		*/
+		function createVideoCommandHost(ctx) {
+			return function VideoCommandHost() {
+				const [request, setRequest] = (0, react.useState)(null);
+				const sessionRef = (0, react.useRef)(null);
+				const handle = (0, react.useCallback)((sessionId, defaults) => {
+					sessionRef.current = sessionId;
+					setRequest({ defaults: normalizeVideoDefaults(defaults) });
+				}, []);
+				(0, react.useEffect)(() => {
+					activeHandle = handle;
+					return () => {
+						if (activeHandle === handle) activeHandle = void 0;
+					};
+				}, [handle]);
+				const close = (0, react.useCallback)(() => {
+					setRequest(null);
+				}, []);
+				const submit = (0, react.useCallback)((text) => {
+					const sessionId = sessionRef.current;
+					if (sessionId === null) return false;
+					return fillComposer(ctx, sessionId, text);
+				}, []);
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(VideoFormDialog, {
+					open: request !== null,
+					onClose: close,
+					onSubmit: submit,
+					defaults: request?.defaults ?? normalizeVideoDefaults({}),
+					t: fallbackTranslate$4
+				});
+			};
+		}
+		/**
+		* 从上下文里取 `commandUi`。
+		*
+		* 属性读只在 `'commandUi'` 已写进当前 scope 的 `inject` 名单时合法；本插件的静态
+		* `inject` 不包含它（以免无 `ui-commands` 的旧宿主卡在 pending），直接读
+		* `ctx.commandUi` 会被 Cordis 的属性守卫当场抛错、使整个插件 fiber 落入
+		* `failed`。因此这里先试属性（供 `ctx.inject(['commandUi'], scope => …)` 的子
+		* scope 与测试替身使用）、失败再退回 `get('commandUi')`。
+		*/
+		function commandUiOf(scope) {
+			try {
+				const direct = scope.commandUi;
+				if (direct !== void 0) return direct;
+			} catch {}
+			try {
+				return scope.get?.("commandUi");
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 把 `/video` 命令挂到宿主的命令服务上。
+		*
+		* 与宿主 `ui-message-feedback` 的 `/feedback` 装饰同一种接线方式：若 `commandUi`
+		* 已经在位（或当前是无 `inject` 能力的测试替身），就地注册；若 `commandUi` 晚于
+		* 本插件激活，则经 `ctx.inject(['commandUi'], scope => …)` 在它上线时补注册。
+		*
+		* 注册失败只吞掉：宿主这一版可能没有 `commandUi`（它由 `ui-commands` 提供），一个
+		* 可选依赖缺席不该让整个插件 apply 失败。
+		*
+		* @param ctx - 浏览器根上下文。
+		* @returns 卸载函数；服务缺席时是一个空操作。
+		*/
+		function installVideoCommand(ctx) {
+			const registerOn = (scope) => {
+				const commandUi = commandUiOf(scope);
+				if (typeof commandUi?.register !== "function") return () => {};
+				try {
+					return commandUi.register(createVideoCommand(ctx, {
+						openForm: openVideoForm,
+						defaults: () => readVideoDefaults(),
+						translate: fallbackTranslate$4
+					}));
+				} catch {
+					return () => {};
 				}
-				debouncedScan();
-			});
-			themeObserver.observe(document.documentElement, {
-				attributes: true,
-				attributeFilter: [
-					"class",
-					"data-theme",
-					"data-color-mode"
-				]
+			};
+			const immediate = commandUiOf(ctx);
+			const injectService = ctx.inject;
+			if (typeof immediate?.register === "function" || typeof injectService !== "function") return registerOn(ctx);
+			const child = injectService.call(ctx, ["commandUi"], (scope) => {
+				scope.effect(() => registerOn(scope), "dsh-minimax-code: /video command");
 			});
 			return () => {
-				observer.disconnect();
-				themeObserver.disconnect();
-				window.clearTimeout(timer);
+				child?.dispose?.();
 			};
 		}
 		//#endregion
@@ -17233,7 +19800,31 @@ window.__ModuleLoader__.load({
 				locale: NS,
 				inject: (sessionId) => ({ loadImage: imageLoader(ctx, sessionId) })
 			}, CodexImageToolView));
+			ctx.slots.inject("tool.call.toolview", () => ctx.slots.register({
+				name: "tool.call.toolview",
+				key: MINIMAX_VIDEO_TOOL_NAME,
+				locale: NS_MINIMAX_CODE,
+				inject: (sessionId) => ({
+					sessionId,
+					readVideo: videoBytesLoader(ctx)
+				})
+			}, MinimaxVideoToolView));
+			installVideoDocumentPreview(ctx);
 			installProgressUpdatesClient(ctx);
+			ctx.effect(() => installVideoCommand(ctx), "dsh-minimax-code: /video command");
+			const VideoCommandHost = createVideoCommandHost(ctx);
+			ctx.slots.inject("conversation.input.overlay", () => {
+				try {
+					return ctx.slots.register({
+						name: "conversation.input.overlay",
+						id: "minimax-video-form",
+						order: 3,
+						locale: NS_MINIMAX_CODE
+					}, VideoCommandHost);
+				} catch {
+					return () => {};
+				}
+			});
 		}
 		/**
 		* The seats every composer badge is handed.
@@ -17287,6 +19878,128 @@ window.__ModuleLoader__.load({
 			if (legacyResolve !== void 0) return (attachment) => legacyResolve(sessionId, attachment);
 			return () => Promise.reject(/* @__PURE__ */ new Error("no client service resolves an image URL"));
 		}
+		/**
+		* 从上下文里读一个**可选**的浏览器服务，读不到就当作没有。
+		*
+		* 只有 `get` 是 Cordis 的基础成员；没写进 `inject` 的服务名直接当属性读会抛错。
+		* 而本文件要读的这几个（`remote` 的命名空间、宿主的 `documentPreviews`）都属于
+		* 「装了才有」：文档预览插件不是本插件的依赖。
+		*
+		* 与 `./progress-updates/index.ts` 的 `serviceOf` 同形——那边这么写是因为
+		* `sidebarRight*` 可选，这边同理。测试里的上下文替身没有 `get`，所以取值本身
+		* 也必须包在 try 里，而不是只包 `ctx.get` 的调用。
+		*
+		* @param ctx - 浏览器根上下文。
+		* @param name - 服务名。
+		* @returns 服务实例，或 undefined。
+		*/
+		function optionalService(ctx, name) {
+			try {
+				return ctx.get?.(name);
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 从上下文里解析 `remote.workspaceFiles` 命名空间。
+		*
+		* 在真实宿主中，`remote.workspaceFiles` 是 `ClientRemoteService` 通过
+		* `new RemoteNamespaceService(ctx, 'workspaceFiles')` 注册的独立 Cordis 服务
+		* （服务名 `'remote.workspaceFiles'`）。由于本插件的静态 `inject` 只声明了
+		* `'remote'` 与 `'remote.session'`，直接读 `ctx.remote.workspaceFiles` 属性会触发
+		* Cordis 的属性守卫并抛出 `cannot get property "remote.workspaceFiles" without inject`。
+		* 因此这里优先走 `optionalService(ctx, 'remote.workspaceFiles')`（即 `ctx.get`），
+		* 仅在测试替身把 `workspaceFiles` 挂成普通对象属性时才在 `try/catch` 内回退读取。
+		*/
+		function resolveWorkspaceFiles(ctx) {
+			const direct = optionalService(ctx, "remote.workspaceFiles");
+			if (typeof direct?.readBytes === "function") return direct;
+			try {
+				const nested = optionalService(ctx, "remote")?.workspaceFiles;
+				if (typeof nested?.readBytes === "function") return nested;
+			} catch {}
+		}
+		/**
+		* 取视频字节：把 `ctx.remote.workspaceFiles.readBytes` 收成一条窄通道。
+		*
+		* 视频在浏览器里**没有别的取字节方式**：`loadImage` 是附件专用的，`<video src>`
+		* 也读不到工作区。宿主侧边栏的图像预览走的正是这条远端
+		* （`ui-sidebar-documentpreview/src/client/rpc.ts` 的 `ReadDocumentBytes`），
+		* 这里照抄同一调用：不传 `range` 即整文件，上限由宿主 `maxFileBytes` 决定。
+		*
+		* 远端是**可选的**且按需解析：不在 `apply(ctx)` 瞬间把服务抓死，以免
+		* `remote.workspaceFiles` 晚于本插件挂载时读到空值；取不到就拒绝这次读取——
+		* 两个界面都会把它显示成占位块，而不是崩掉。
+		*
+		* @param ctx - 浏览器根上下文。
+		* @returns 与 `readBytes` 同形的取字节通道。
+		*/
+		function videoBytesLoader(ctx) {
+			return async (sessionId, path, signal) => {
+				const workspaceFiles = resolveWorkspaceFiles(ctx);
+				if (typeof workspaceFiles?.readBytes !== "function") throw new Error("no remote workspaceFiles reader is mounted");
+				return (await workspaceFiles.readBytes.bind(workspaceFiles)(sessionId, path, {}, signal)).data;
+			};
+		}
+		/**
+		* 从上下文里取 `documentPreviews` 注册表。
+		*
+		* 先试属性读（供 `ctx.inject(['documentPreviews'], scope => …)` 的子 scope 与测试
+		* 替身使用），被 Cordis 拒绝时退回 `optionalService`（`ctx.get`）。
+		*/
+		function documentPreviewsOf(scope) {
+			try {
+				const direct = scope.documentPreviews;
+				if (direct !== void 0) return direct;
+			} catch {}
+			return optionalService(scope, "documentPreviews");
+		}
+		/**
+		* 挂载 MiniMax 视频的侧边栏渲染器。
+		*
+		* 两个注册各管一半，形状逐字照抄宿主
+		* `ui-sidebar-documentpreview/src/client/image/index.ts`：
+		*
+		* 1. `documentPreviews.register` 声明「mp4/webm/mov/m4v 归我」，`priority: 'extension'`
+		*    让外部实现排在内置实现之前（`document/registry.ts` 的排序规则）；
+		* 2. `sidebar.right.tab.document` 的 keyed 槽用**同一个 id** 注册正文。
+		*
+		* 两段都包在 `ctx.effect` 里，返回注册器给的幂等卸载函数：插件行被禁用时定义与
+		* 正文一起消失，不会留下一个注册了却渲染不出的实现。
+		*
+		* `documentPreviews` 是宿主文档预览插件通过 `ctx.reflect.provide` 给的服务，它的
+		* `inject` 比本插件多 `sidebarRightTabs` / `remote.workspaceFiles` / `resources`，
+		* 因此在浏览器启动时通常晚于本插件激活。若它在 `apply(ctx)` 瞬间尚未上线，则通过
+		* `ctx.inject(['documentPreviews'], …)` 在它上线时自动补注册。
+		*
+		* @param ctx - 浏览器根上下文。
+		*/
+		function installVideoDocumentPreview(ctx) {
+			const readVideo = videoBytesLoader(ctx);
+			const registerPreview = (scope) => {
+				const registry = documentPreviewsOf(scope);
+				if (typeof registry?.register !== "function") return () => {};
+				try {
+					const t = ctx.locale.bind(NS_MINIMAX_CODE);
+					return registry.register(minimaxVideoPreviewDefinition(() => t("videoTitle")));
+				} catch {
+					return () => {};
+				}
+			};
+			const immediate = documentPreviewsOf(ctx);
+			const injectService = ctx.inject;
+			if (typeof immediate?.register === "function" || typeof injectService !== "function") {
+				if (typeof immediate?.register === "function") ctx.effect(() => registerPreview(ctx), "dsh-minimax-code: video preview definition");
+			} else injectService.call(ctx, ["documentPreviews"], (scope) => {
+				scope.effect(() => registerPreview(scope), "dsh-minimax-code: video preview definition");
+			});
+			ctx.slots.inject("sidebar.right.tab.document", () => ctx.slots.register({
+				name: "sidebar.right.tab.document",
+				key: MINIMAX_VIDEO_PREVIEW_ID,
+				locale: NS_MINIMAX_CODE,
+				inject: () => ({ readVideo })
+			}, MinimaxVideoDocumentBody));
+		}
 		//#endregion
 		exports.apply = apply;
 		exports.inject = inject;