koishi-plugin-kkk 3.4.2 → 3.6.0

package/lib/index.js

@@ -123,8 +123,9 @@ exports.inject = {
     // ffmpeg：由 koishi-plugin-ffmpeg-path 提供，兼容层的 ffmpeg()/ffprobe() 会优先用它
     // assets：koishi-plugin-assets-qqbot-part-file 之类提供的图床服务，
     // 面板卡片要上传成 https 地址才能放进 QQ 的 markdown 图片里
-    // shotkit：koishi-plugin-shotkit 提供的内核截图服务；装了就用它渲染卡片（没装退回 puppeteer）
-    optional: ['shotkit', 'puppeteer', 'database', 'http', 'ffmpeg', 'assets', 'server', 'console']
+    // 渲染：只用浏览器渲染服务（koishi-plugin-puppeteer 或同类插件）
+    // 3.5.0 起不再支持 shotkit 内核（它在 Windows 上加载不了 https 资源，卡片会缺图）
+    optional: ['puppeteer', 'database', 'http', 'ffmpeg', 'assets', 'server', 'console']
 };
 /**
  * 配置表单 = 「Koishi 集成选项」 + 「上游插件配置」。
@@ -189,14 +190,14 @@ exports.Config = koishi_1.Schema.intersect([
         forward: koishi_1.Schema.object({
             global: koishi_1.Schema.boolean().default(false)
                 .description('全局合并转发。打开后所有平台都把一次解析的内容合成一条聊天记录发出；关着时下面各平台的开关才起作用。默认关闭'),
-            globalContent: koishi_1.Schema.array(koishi_1.Schema.union(['text', 'image', 'video', 'file'])).default([])
-                .description('全局合并转发里放哪些内容：text 文字 / image 图片 / video 视频 / file 文件。没勾的单独直发，留空等于只放文字和图片。视频体积大时有些适配器（比如 NapCat）会拒绝整个聊天记录，这时会自动改成单独发送，不会丢内容'),
+            globalContent: koishi_1.Schema.array(koishi_1.Schema.union(['text', 'image', 'video', 'file', 'chart'])).default([])
+                .description('全局合并转发里放哪些内容：text 文字 / image 图片 / video 视频 / file 文件 / chart 流程图（B站互动视频的剧情图）。没勾的单独直发，留空等于只放文字和图片。视频体积大时有些适配器（比如 NapCat）会拒绝整个聊天记录，这时会自动改成单独发送，不会丢内容'),
             douyin: koishi_1.Schema.boolean().default(false).description('抖音：单独打开合并转发（全局关着时才起作用）'),
             douyinContent: koishi_1.Schema.array(koishi_1.Schema.union(['text', 'image', 'video', 'file'])).default([])
                 .description('抖音合并转发里放哪些内容，留空表示用全局那一份'),
             bilibili: koishi_1.Schema.boolean().default(false).description('B站：单独打开合并转发（全局关着时才起作用）'),
-            bilibiliContent: koishi_1.Schema.array(koishi_1.Schema.union(['text', 'image', 'video', 'file'])).default([])
-                .description('B站合并转发里放哪些内容，留空表示用全局那一份'),
+            bilibiliContent: koishi_1.Schema.array(koishi_1.Schema.union(['text', 'image', 'video', 'file', 'chart'])).default([])
+                .description('B站合并转发里放哪些内容，chart 是互动视频的剧情流程图（只有 B站有）。留空表示用全局那一份'),
             kuaishou: koishi_1.Schema.boolean().default(false).description('快手：单独打开合并转发（全局关着时才起作用）'),
             kuaishouContent: koishi_1.Schema.array(koishi_1.Schema.union(['text', 'image', 'video', 'file'])).default([])
                 .description('快手合并转发里放哪些内容，留空表示用全局那一份'),
@@ -850,8 +851,14 @@ function registerCommands(ctx, logger, autoParse) {
         return next();
     });
 }
-/** 合并转发内容可选项（与 ParseForward 里的 FORWARD_KINDS 保持一致） */
-const FORWARD_KIND_VALUES = ['text', 'image', 'video', 'audio', 'file', 'markdown'];
+/**
+ * 合并转发内容可选项（与 ParseForward 里的 FORWARD_KINDS 保持一致）。
+ *
+ * 注意这里**不再有** audio / markdown：QQ 的聊天记录不支持语音气泡，markdown 只有官方 bot 认、
+ * 而官方适配器没有合并转发能力 —— 留着它们只会让人配了不生效（见 ParseForward 的说明）。
+ * chart 是 B站互动视频的剧情流程图。
+ */
+const FORWARD_KIND_VALUES = ['text', 'image', 'video', 'file', 'chart'];
 /** 平台名 → 上游配置段名 */
 const FORWARD_PLATFORMS = ['douyin', 'bilibili', 'kuaishou', 'xiaohongshu'];
 /**

package/lib/karin/apps/help.js

@@ -39,6 +39,7 @@ const module_1 = require("../module");
 const Config_1 = require("../module/utils/Config");
 const ErrorHandler_1 = require("../module/utils/ErrorHandler");
 const runtime_report_1 = require("../module/utils/runtime-report");
+const sendError_1 = require("../../compat/sendError");
 const HELP_MENU_CONFIG = [
     {
         title: '常用功能',
@@ -205,12 +206,22 @@ const handleHelp = (0, ErrorHandler_1.wrapWithErrorHandler)(async (e) => {
 });
 // 包装版本命令
 const handleVersion = (0, ErrorHandler_1.wrapWithErrorHandler)(async (e) => {
-    const img = await (0, module_1.Render)(e, 'other/runtime', (0, runtime_report_1.collectRuntimeReport)(e));
+    const img = await (0, module_1.Render)(e, 'other/runtime', await (0, runtime_report_1.collectRuntimeReport)(e));
     await e.reply(img);
     return true;
 }, {
     businessName: 'KKK版本'
 });
+/**
+ * 把 Markdown 更新日志压成纯文字。
+ *
+ * 图片发不出去时的降级用：去掉标题号与加粗符号就够了，内容本身不改写。
+ */
+const toPlainChangelog = (markdown) => markdown
+    .replace(/^#{1,6}\s*/gm, '')
+    .replace(/\*\*/g, '')
+    .slice(0, 1800)
+    .trim();
 // 包装更新日志命令
 const handleChangelog = (0, ErrorHandler_1.wrapWithErrorHandler)(async (e) => {
     const forwardLogs = (0, runtime_report_1.getLocalChangelog)(10);
@@ -223,7 +234,17 @@ const handleChangelog = (0, ErrorHandler_1.wrapWithErrorHandler)(async (e) => {
         localVersion: '',
         remoteVersion: ''
     });
-    await e.reply(img);
+    try {
+        await e.reply(img);
+    }
+    catch (error) {
+        /**
+         * 图片发不出去（体积超限、主动消息被拒、适配器抽风…）时退回纯文字。
+         * 更新日志本身是文字，降级之后用户照样看得到更新了什么，比只弹一张错误卡片好。
+         */
+        node_karin_1.logger.warn('[kkk] 更新日志图片发送失败，改用文字发送：' + (0, sendError_1.describeSendFailure)((0, sendError_1.classifySendFailure)(error)));
+        await e.reply(toPlainChangelog(forwardLogs));
+    }
     return true;
 }, {
     businessName: 'KKK更新日志'

package/lib/karin/module/utils/Base.js

@@ -444,15 +444,25 @@ const downloadFile = async (videoUrl, opt) => {
         autoReduceRatio: uploadConfig.downloadAutoReduce ? 0.6 : 1, // 降速比例
         minSpeed: (uploadConfig.downloadMinSpeed ?? 1) * 1024 * 1024 // MB/s -> bytes/s
     };
+    /**
+     * 速度采样点。速度必须按「两次回调之间的增量」算，不能按「累计字节 ÷ 总耗时」：
+     * 后者把重试的退避等待也算进分母，断点续传时分子还会被重置回续传点，
+     * 于是明明在正常下载也会显示成 `0.0 MB/s 剩余: 661min`（用户实测反馈）。
+     */
+    let lastSampleBytes = 0;
+    let lastSampleAt = startTime;
+    /** 平滑后的速度（byte/s） */
+    let smoothSpeed = 0;
     try {
         // 使用 networks 类进行文件下载，并通过回调函数实时更新下载进度
         const { filepath, totalBytes } = await new utils_1.Networks({
             url: videoUrl,
             headers: opt.headers ?? utils_1.baseHeaders,
             filepath: opt.filepath ?? utils_1.Common.tempDri.video + opt.title,
-            timeout: 60000, // 增加超时时间
+            timeout: 60000, // 空闲超时（连续 60s 没有新数据才算超时），传输途中会不断续期
             maxRetries: 3, // 增加重试次数
-            throttle: throttleConfig
+            throttle: throttleConfig,
+            backupUrls: opt.backupUrls
         }).downloadStream((downloadedBytes, totalBytes) => {
             // 定义进度条长度及生成进度条字符串的函数
             const barLength = 45;
@@ -467,14 +477,26 @@ const downloadFile = async (videoUrl, opt) => {
             // 计算动态 RGB 颜色
             const red = Math.floor(255 - (255 * progressPercentage) / 100); // 红色分量随进度减少
             const coloredPercentage = node_karin_1.logger.chalk.rgb(red, 255, 0)(`${progressPercentage.toFixed(1)}%`);
-            // 计算下载速度（MB/s）
-            const elapsedTime = (Date.now() - startTime) / 1000;
-            const speed = downloadedBytes / elapsedTime;
+            // 计算下载速度（MB/s）：增量法 + 一点平滑，避免数字乱跳
+            const sampleAt = Date.now();
+            const elapsedSinceSample = (sampleAt - lastSampleAt) / 1000;
+            if (elapsedSinceSample >= 0.2) {
+                // 断点续传时 downloadedBytes 会往回退，增量按 0 处理
+                const instant = Math.max(0, downloadedBytes - lastSampleBytes) / elapsedSinceSample;
+                smoothSpeed = smoothSpeed > 0 ? smoothSpeed * 0.6 + instant * 0.4 : instant;
+                lastSampleBytes = downloadedBytes;
+                lastSampleAt = sampleAt;
+            }
+            const speed = smoothSpeed;
             const formattedSpeed = (speed / 1048576).toFixed(1) + ' MB/s';
-            // 计算剩余时间
+            // 计算剩余时间（速度还没出来时不瞎猜）
             const remainingBytes = totalBytes - downloadedBytes; // 剩余字节数
-            const remainingTime = remainingBytes / speed; // 剩余时间（秒）
-            const formattedRemainingTime = remainingTime > 60 ? `${Math.floor(remainingTime / 60)}min ${Math.floor(remainingTime % 60)}s` : `${remainingTime.toFixed(0)}s`;
+            const remainingTime = speed > 1024 ? remainingBytes / speed : Number.POSITIVE_INFINITY;
+            const formattedRemainingTime = !Number.isFinite(remainingTime)
+                ? '--'
+                : remainingTime > 60
+                    ? `${Math.floor(remainingTime / 60)}min ${Math.floor(remainingTime % 60)}s`
+                    : `${remainingTime.toFixed(0)}s`;
             // 计算已下载和总下载的文件大小（MB）
             const downloadedSizeMB = (downloadedBytes / 1048576).toFixed(1);
             const totalSizeMB = (totalBytes / 1048576).toFixed(1);

package/lib/karin/module/utils/ErrorHandler/render.js

@@ -202,8 +202,14 @@ const renderErrorImage = async (ctx, opts = {}) => {
         pluginVersion: module_1.Root.pluginVersion,
         buildTime: buildMetadata?.buildTime ? (0, module_1.formatBuildTime)(buildMetadata.buildTime) : undefined,
         commitHash: buildMetadata?.commitHash,
-        // 之前这里可能传 undefined，模板读 adapterInfo.version.startsWith 直接 SSR 崩掉
-        adapterInfo: adapterInfo ?? { name: '未知适配器', version: '' },
+        /**
+         * 之前这里可能传 undefined，模板读 adapterInfo.version.startsWith 直接 SSR 崩掉。
+         * name 换成友好名（NapCat / OneBot）只是给卡片看：兼容层里 adapter.name 是**平台标识**，
+         * 别动原对象，免得面板那条链路拿到被改过的平台名。
+         */
+        adapterInfo: adapterInfo
+            ? { ...adapterInfo, name: String(adapterInfo.displayName || adapterInfo.name || '未知适配器') }
+            : { name: '未知适配器', version: '' },
         // 上报成功的编号与反馈群：印在卡片上，用户照着进群提问
         report: ctx.report
             ? { id: ctx.report.id, url: ctx.report.url, group: (0, ErrorReport_1.reportConfig)().group, groupUrl: (0, ErrorReport_1.groupLinkOf)((0, ErrorReport_1.reportConfig)().group) }

package/lib/karin/module/utils/InteractiveGraph.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearInteractiveGraphCache = exports.peekCachedGraph = exports.crawlInteractiveGraph = void 0;
+/**
+ * 把整张剧情图爬下来（给「剧情图」卡片画思维导图用）。
+ *
+ * 接口只有「按节点问」这一种（x/stein/edgeinfo_v2），所以要自己从根节点宽度优先展开：
+ * 每个节点问一次，拿到它的选项；每个选项的 cid 就是落点，再问落点，直到没有分支。
+ * 一张图动辄几十个节点，所以带**节点数 / 时间预算**：超了就停下并在卡片上标注「还有分支未展开」，
+ * 绝不让用户等着一张图渲不出来。
+ *
+ * 结果按 bvid + 剧情图版本号缓存 30 分钟（GRAPH_TTL）：剧情图是静态的，同一个人反复玩不用重复爬。
+ */
+const node_karin_1 = require("../../../compat/node-karin.js");
+const InteractiveVideo_1 = require("../../module/utils/InteractiveVideo");
+const GRAPH_CACHE = new Map();
+const GRAPH_TTL = 30 * 60 * 1000;
+const EDGE_INFO_URL = 'https://api.bilibili.com/x/stein/edgeinfo_v2';
+/** 解析一个节点（edgeinfo_v2 的一份响应） */
+const parseNode = (payload, cid) => {
+    const data = payload?.data;
+    if (!data || typeof data !== 'object')
+        return null;
+    const question = (data.edges?.questions ?? [])[0] ?? {};
+    const raw = Array.isArray(question.choices) ? question.choices : [];
+    const usable = raw
+        .map((choice) => ({
+        edgeId: Number(choice?.id),
+        cid: Number(choice?.cid),
+        rawText: String(choice?.option ?? ''),
+        isDefault: Boolean(choice?.is_default)
+    }))
+        .filter((item) => Number.isFinite(item.edgeId) && item.edgeId > 0 && Number.isFinite(item.cid) && item.cid > 0);
+    const choices = usable.map((item, index) => ({
+        label: (0, InteractiveVideo_1.choiceLabel)(index),
+        text: (0, InteractiveVideo_1.cleanChoiceText)(item.rawText) || item.rawText.trim() || (0, InteractiveVideo_1.choiceLabel)(index),
+        isDefault: item.isDefault,
+        edgeId: item.edgeId,
+        cid: item.cid
+    }));
+    return {
+        cid,
+        question: String(question.title ?? '').trim(),
+        isLeaf: Number(data.is_leaf) === 1 || choices.length === 0,
+        choices
+    };
+};
+/**
+ * 爬整张剧情图。
+ *
+ * @param params 基本信息 + 请求实现 + 预算
+ * @returns 爬到的图；连根节点都取不到时返回 null
+ */
+const crawlInteractiveGraph = async (params) => {
+    const { bvid, graphVersion, rootCid, headers, request } = params;
+    const maxNodes = params.maxNodes ?? 400;
+    const deadline = Date.now() + (params.timeoutMs ?? 30000);
+    /** 缓存的是**整张图**（和从哪一段起画无关），所以 key 里不带 rootCid */
+    const cacheKey = bvid + ':' + graphVersion;
+    const cached = GRAPH_CACHE.get(cacheKey);
+    if (cached && Date.now() - cached.at < GRAPH_TTL)
+        return cached.graph;
+    const byCid = new Map();
+    let truncated = false;
+    /** 抓失败的节点数：有失败就不写缓存，下次重新抓，不留断头的图 */
+    let failed = 0;
+    /** 单个节点最多问两次：接口抖动一次不该在图里留一个断头分支 */
+    const fetchNode = async (cid, edgeId) => {
+        let url = EDGE_INFO_URL + '?bvid=' + bvid + '&graph_version=' + graphVersion + '&cid=' + cid;
+        if (edgeId)
+            url += '&edge_id=' + edgeId;
+        for (let attempt = 1; attempt <= 2; attempt++) {
+            const payload = await request(url, headers);
+            if (payload && Number(payload.code) === 0) {
+                const node = parseNode(payload, cid);
+                if (node)
+                    return node;
+            }
+            else if (attempt === 1) {
+                node_karin_1.logger.debug('[互动视频] 剧情图节点取失败（cid=' + cid + ' edge=' + String(edgeId ?? '-') + ' code=' + String(payload?.code ?? '无响应') + '），重试一次');
+            }
+            if (attempt === 1)
+                await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        return null;
+    };
+    /** 一次进队列的「待展开」任务：从 fromCid 出发走这条选项，落点就是这条选项的 cid */
+    const queue = [];
+    /**
+     * 根节点。
+     *
+     * **不带 edge_id 地问接口会拿到整张图的根**，所以「从当前位置起画」必须带上进入那条边：
+     * 用户走到第 5 段时，我们要的是第 5 段那一段，而不是回到开场。
+     */
+    const rootEdge = params.rootEdge;
+    const rootUrl = EDGE_INFO_URL + '?bvid=' + bvid + '&graph_version=' + graphVersion
+        + '&cid=' + (rootEdge ? rootEdge.fromCid : rootCid)
+        + (rootEdge ? '&edge_id=' + rootEdge.edgeId : '');
+    const rootPayload = await request(rootUrl, headers);
+    if (!rootPayload || Number(rootPayload.code) !== 0)
+        return null;
+    const root = parseNode(rootPayload, rootCid);
+    if (!root)
+        return null;
+    byCid.set(rootCid, root);
+    for (const choice of root.choices)
+        queue.push({ fromCid: rootCid, choice });
+    /** 宽度优先：三个一波并发，节点数或时间到顶就停 */
+    while (queue.length) {
+        if (byCid.size >= maxNodes || Date.now() > deadline) {
+            truncated = true;
+            break;
+        }
+        const wave = queue.splice(0, 3);
+        const results = await Promise.all(wave.map(async (task) => ({ task, node: await fetchNode(task.fromCid, task.choice.edgeId) })));
+        for (const { task, node } of results) {
+            if (!node) {
+                failed++;
+                continue;
+            }
+            /** 落点那一段的 cid 就是选项自己带的 cid（请求用的 cid 是「从哪出发」） */
+            const landed = { ...node, cid: task.choice.cid };
+            /** 挂到卡片要的嵌套结构上：选项 → 落到的那一段 */
+            task.choice.children = [landed];
+            /**
+             * 同一个 cid 可能被多条路走到（剧情图不是纯树），只展开一次：
+             * 既省请求，也避免环把爬取变成死循环。
+             */
+            const seenBefore = byCid.has(task.choice.cid);
+            byCid.set(task.choice.cid, landed);
+            if (seenBefore || !landed.choices.length)
+                continue;
+            for (const choice of landed.choices) {
+                if (byCid.has(choice.cid))
+                    continue;
+                if (queue.some((item) => item.choice.cid === choice.cid))
+                    continue;
+                queue.push({ fromCid: task.choice.cid, choice });
+            }
+        }
+    }
+    const result = { root: byCid.get(rootCid) ?? root, nodeCount: byCid.size, truncated, cids: [...byCid.keys()] };
+    /** 有缺口（预算用尽或有节点没抓到）就不缓存：否则下次画出来还是同样缺分支 */
+    if (!truncated && !failed)
+        GRAPH_CACHE.set(cacheKey, { at: Date.now(), graph: result });
+    node_karin_1.logger.info('[互动视频] 剧情图已爬取：' + result.nodeCount + ' 个节点'
+        + (truncated ? '（预算用尽，还有分支未展开）' : '')
+        + (failed ? '（' + failed + ' 个节点没抓到，会在用户走到那里时重画）' : ''));
+    return result;
+};
+exports.crawlInteractiveGraph = crawlInteractiveGraph;
+/** 取缓存里的整张图（点「渲染流程图」时直接用它，不再请求接口） */
+const peekCachedGraph = (bvid, graphVersion) => {
+    const hit = GRAPH_CACHE.get(bvid + ':' + graphVersion);
+    if (!hit)
+        return null;
+    if (Date.now() - hit.at >= GRAPH_TTL)
+        return null;
+    return hit.graph;
+};
+exports.peekCachedGraph = peekCachedGraph;
+/** 清理剧情图缓存（测试用） */
+const clearInteractiveGraphCache = () => GRAPH_CACHE.clear();
+exports.clearInteractiveGraphCache = clearInteractiveGraphCache;

package/lib/karin/module/utils/InteractiveVideo.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatInteractivePath = exports.interactiveSessionCount = exports.clearInteractiveSession = exports.getInteractiveSession = exports.rememberInteractiveSession = exports.interactiveKey = exports.INTERACTIVE_TTL_MS = exports.parseChoiceInput = exports.fetchInteractiveNode = exports.fetchInteractiveInfo = exports.parseInteractiveNode = exports.choiceLabel = exports.isJunkChoice = exports.cleanChoiceText = exports.interactiveRequest = void 0;
+/**
+ * B站互动视频（互动视频 / stein gate）支持。
+ *
+ * ## 这类视频和普通视频差在哪
+ *
+ * 普通视频只有一个 cid，下完就发；互动视频是一张剧情图：每个节点有自己的 cid，
+ * 播完要给用户几个选项（选项文本由 B站 下发，且**自带 A/B/C 前缀**），
+ * 用户选了之后才跳到下一个节点的视频。
+ *
+ * ## 拿数据要三个接口（amagi 里没有这三个，所以自己拼 URL）
+ *
+ * 1. `x/web-interface/view?bvid=` → `data.rights.is_stein_gate === 1` 说明是互动视频；
+ * 2. `x/player/wbi/v2?bvid=&cid=` → `data.interaction.graph_version`（剧情图版本号，
+ *    必须带它才能查剧情；同一个视频改了剧情，这个号会变）；
+ * 3. `x/stein/edgeinfo_v2?bvid=&graph_version=&cid=[&edge_id=]` → 当前节点的题目与选项，
+ *    `edge_id` 是要走的那条边的 id；不给 edge_id 就是根节点。
+ *
+ * ## 选项文字为什么要洗一遍
+ *
+ * B站 下发的 option 实测长这样：`"A 向左走"`、`"B 向右挖"`、`"（1）向左走"`，
+ * 有的还会拖着 `"A.B.C"`、`"1 2 3"` 这类纯编号噪音。我们统一**去掉自带编号**、
+ * 自己按顺序发 A/B/C，这样按钮显示的文字干净，用户回 A / 1 / 选项原文都能对上。
+ */
+const node_karin_1 = require("../../../compat/node-karin.js");
+const Network_1 = require("../../module/utils/Network");
+const PLAYER_INFO_URL = 'https://api.bilibili.com/x/player/wbi/v2';
+const EDGE_INFO_URL = 'https://api.bilibili.com/x/stein/edgeinfo_v2';
+/** 默认请求实现：复用插件的网络层（它会带默认请求头、失败重试） */
+const interactiveRequest = async (url, headers) => {
+    const data = await new Network_1.Networks({ url, headers, timeout: 15000 }).getData();
+    // Networks 失败时返回 false（它自己已经打过日志），这里统一成 null
+    return data === false ? null : data;
+};
+exports.interactiveRequest = interactiveRequest;
+/**
+ * 选项文字里要去掉的「自带编号」。
+ *
+ * 必须要求编号后面跟分隔符（空格 / 点 / 顿号 / 括号 / 冒号）才认为是编号：
+ * 否则「Block 摆放」这种以字母开头的正常文字会被吃掉首字母。
+ */
+const LABEL_PREFIX = /^(?:\s*[（(]?\s*(?:[A-Za-z]|\d{1,2}|[一二三四五六七八九十]+)\s*[)）.、,，:：\-—]+\s*|[A-Za-z]\s+|\d{1,2}\s+|[一二三四五六七八九十]+[、.．]\s*)+/;
+/** 结尾的编号噪音：`向左走 A.B.C`、`向右挖 1 2 3` */
+const LABEL_SUFFIX = /[\s.、,，]*(?:[A-Za-z]|\d{1,2})(?:[\s.、,，]+(?:[A-Za-z]|\d{1,2}))+\s*$/;
+/** 只有字母序列的噪音：`A.B.C` / `A B C` */
+const JUNK_LETTERS = /^(?:[A-Za-z][\s.、,，)）(（]*){2,}$/;
+/** 只有数字/标点的噪音：`1 2 3` / `1.` */
+const JUNK_DIGITS = /^[\d\s.、,，()（）]{1,12}$/;
+/** 纯标点 */
+const JUNK_PUNCT = /^[.·•\-—_…,，、;；:：!！?？\s]+$/;
+/** 零宽字符等看不见的东西 */
+const INVISIBLE = /[\u200b-\u200f\ufeff\u2060]/g;
+/**
+ * 洗选项文字：去零宽字符、去自带编号、去结尾编号噪音、压多余空格。
+ *
+ * @param raw B站 下发的 option 原文
+ */
+const cleanChoiceText = (raw) => {
+    let text = String(raw ?? '').replace(INVISIBLE, '').trim();
+    text = text.replace(LABEL_PREFIX, '').trim();
+    text = text.replace(LABEL_SUFFIX, '').trim();
+    return text.replace(/\s{2,}/g, ' ');
+};
+exports.cleanChoiceText = cleanChoiceText;
+/**
+ * 判断一个选项是不是「只剩编号」的噪音。
+ *
+ * 用户反馈的 `A.B.C`、`1 2 3` 就是这类：留着只会让按钮上出现一堆没意义的字。
+ */
+const isJunkChoice = (text) => {
+    const value = String(text ?? '').trim();
+    if (!value)
+        return true;
+    return JUNK_LETTERS.test(value) || JUNK_DIGITS.test(value) || JUNK_PUNCT.test(value);
+};
+exports.isJunkChoice = isJunkChoice;
+/** 选项标签：A、B、…、Z，超过 26 个用数字，避免出现 `[` 这种字符 */
+const choiceLabel = (index) => index >= 0 && index < 26 ? String.fromCharCode(65 + index) : String(index + 1);
+exports.choiceLabel = choiceLabel;
+/**
+ * 把 B站 的 edgeinfo_v2 响应解析成节点。
+ *
+ * 纯函数：不联网、不改数据，方便直接拿真实响应做测试。
+ *
+ * @param payload edgeinfo_v2 的响应体
+ * @param base 本次请求用到的 bvid / 剧情图版本 / cid
+ */
+const parseInteractiveNode = (payload, base) => {
+    const data = payload?.data ?? payload;
+    if (!data || typeof data !== 'object')
+        return null;
+    const question = (data.edges?.questions ?? [])[0] ?? {};
+    const rawChoices = Array.isArray(question.choices) ? question.choices : [];
+    /** 先按「能继续对话」的硬条件过滤：边 id 和 cid 必须都是有效数字 */
+    const usable = rawChoices
+        .map((choice, order) => ({
+        order,
+        edgeId: Number(choice?.id),
+        cid: Number(choice?.cid),
+        rawText: String(choice?.option ?? ''),
+        isDefault: Boolean(choice?.is_default)
+    }))
+        .filter((item) => Number.isFinite(item.edgeId) && item.edgeId > 0 && Number.isFinite(item.cid) && item.cid > 0);
+    const cleaned = usable.map((item) => ({
+        ...item,
+        text: (0, exports.cleanChoiceText)(item.rawText),
+        /**
+         * 噪音判断要看**原始文字**。
+         *
+         * `A.B.C` 洗掉前缀之后只剩一个 `C`，光看洗过的结果它一点都不像噪音，
+         * 于是这种选项会被留下来，按钮上就出现一串没意义的字母数字。
+         */
+        junk: (0, exports.isJunkChoice)((0, exports.cleanChoiceText)(item.rawText)) || (0, exports.isJunkChoice)(item.rawText)
+    }));
+    /**
+     * 噪音选项只在「还有正经选项」时才丢：万一一整道题都是噪音，
+     * 那就原样留着 —— 有得选总比没得选好。
+     */
+    const meaningful = cleaned.filter((item) => !item.junk);
+    const kept = meaningful.length ? meaningful : cleaned;
+    const choices = kept.map((item, index) => ({
+        index,
+        label: (0, exports.choiceLabel)(index),
+        /**
+         * 洗不干净（洗完还是编号）时退回原文：`A.B.C` 这种至少让用户看得出
+         * 「这是 B站 给的一条坏选项」，而不是一个莫名其妙的 `C`。
+         */
+        text: item.junk ? item.rawText.trim() || item.text || (0, exports.choiceLabel)(index) : item.text || item.rawText.trim() || (0, exports.choiceLabel)(index),
+        rawText: item.rawText,
+        edgeId: item.edgeId,
+        cid: item.cid,
+        isDefault: item.isDefault
+    }));
+    return {
+        bvid: base.bvid,
+        graphVersion: base.graphVersion,
+        cid: base.cid,
+        title: String(data.title ?? ''),
+        question: String(question.title ?? '').trim(),
+        choices,
+        isLeaf: Number(data.is_leaf) === 1 || choices.length === 0,
+        notice: ''
+    };
+};
+exports.parseInteractiveNode = parseInteractiveNode;
+/**
+ * 查剧情图版本号（顺便带回 B站 的提示语）。
+ *
+ * 只有互动视频的播放器接口里才有 `data.interaction`，所以这个函数也是「是不是互动视频」的判断依据。
+ *
+ * @param params bvid / 当前 cid / 请求头 / 请求实现
+ */
+const fetchInteractiveInfo = async (params) => {
+    const { bvid, cid, headers, request = exports.interactiveRequest } = params;
+    if (!bvid || !cid)
+        return null;
+    const payload = await request(PLAYER_INFO_URL + '?bvid=' + bvid + '&cid=' + cid, headers);
+    const interaction = payload?.data?.interaction;
+    const graphVersion = Number(interaction?.graph_version);
+    if (!Number.isFinite(graphVersion) || graphVersion <= 0) {
+        // 普通视频本来就没有 interaction，这里只记 debug；真的要排查时再看
+        node_karin_1.logger.debug('[互动视频] 播放器接口没有剧情图版本号（code=' + String(payload?.code ?? '无响应') + '），按普通视频处理');
+        return null;
+    }
+    return { graphVersion, notice: String(interaction?.msg ?? '').trim() };
+};
+exports.fetchInteractiveInfo = fetchInteractiveInfo;
+/**
+ * 拉取一个剧情节点（不给 edgeId 就是根节点）。
+ *
+ * @param params bvid / 剧情图版本 / cid / 要走的边（可选）/ 请求头 / 请求实现
+ */
+const fetchInteractiveNode = async (params) => {
+    const { bvid, graphVersion, cid, edgeId, headers, request = exports.interactiveRequest } = params;
+    if (!bvid || !graphVersion || !cid)
+        return null;
+    let url = EDGE_INFO_URL + '?bvid=' + bvid + '&graph_version=' + graphVersion + '&cid=' + cid;
+    if (edgeId)
+        url += '&edge_id=' + edgeId;
+    /**
+     * 重试两次。
+     *
+     * 线上实测：用户在群里选完选项，偶尔会遇到一次接口抖动 —— 之前只问一次、
+     * 失败就当作「剧情图取不到下一段」把剧情结束掉，用户明明回对了却被踢出剧情。
+     * 这种一次性的失败重试一次就好了，同时把真实原因（code / message / 没响应）打进日志。
+     */
+    let lastReason = '没有响应（网络层返回 false）';
+    for (let attempt = 1; attempt <= 2; attempt++) {
+        const payload = await request(url, headers);
+        const code = Number(payload?.code);
+        if (payload && code === 0) {
+            const node = (0, exports.parseInteractiveNode)(payload, { bvid, graphVersion, cid });
+            if (node)
+                return node;
+            lastReason = '响应里没有剧情数据';
+        }
+        else {
+            lastReason = 'code=' + String(payload?.code ?? '无') + ' message=' + JSON.stringify(payload?.message ?? '');
+        }
+        if (attempt === 1)
+            await new Promise((resolve) => setTimeout(resolve, 400));
+    }
+    node_karin_1.logger.warn('[互动视频] 取剧情节点失败（' + (edgeId ? '选项 edge_id=' + edgeId : '根节点') + ' cid=' + cid + '）：' + lastReason);
+    return null;
+};
+exports.fetchInteractiveNode = fetchInteractiveNode;
+/**
+ * 把用户回的那句话解析成选项序号。
+ *
+ * 支持：`A` / `a` / 全角 `Ａ`、`1`、`选A`、`选择 2`、直接回选项原文（可只回其中几个字）。
+ *
+ * @param input 用户消息文本
+ * @param choices 当前节点可选的选项
+ * @returns 命中的序号；没命中返回 -1
+ */
+const parseChoiceInput = (input, choices) => {
+    if (!Array.isArray(choices) || !choices.length)
+        return -1;
+    /**
+     * 先剥掉消息里的元素标记。
+     *
+     * 线上实测：用户点了 @ 之后发「A」，拿到的文本是 `<at id="661867728489"/>A`，
+     * 直接被当成「不认识的内容」—— 用户明明回对了却不认。CQ 码形态（`[CQ:at,qq=…]`）同理。
+     */
+    const stripped = String(input ?? '')
+        .replace(ELEMENT_TAG, '')
+        .replace(CQ_CODE, '');
+    // 全角字母数字先归一化成半角，手机上很容易打出全角
+    const normalized = stripped
+        .replace(/[Ａ-Ｚａ-ｚ０-９]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0))
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!normalized)
+        return -1;
+    const hit = matchChoice(normalized, choices);
+    if (hit >= 0)
+        return hit;
+    /** 再来一次：这次把开头的 @某某 也去掉（有的客户端把提醒当纯文本发过来） */
+    const withoutMention = normalized.replace(LEADING_MENTION, '').trim();
+    return withoutMention && withoutMention !== normalized ? matchChoice(withoutMention, choices) : -1;
+};
+exports.parseChoiceInput = parseChoiceInput;
+/** 消息元素标记：`<at id="…"/>`、`<img …/>`、`[CQ:at,qq=…]` 都算 */
+const ELEMENT_TAG = /<\/?(?:at|img|face|mface|reply|quote|json|xml|button|markdown)\b[^>]*>/gi;
+const CQ_CODE = /\[CQ:[^\]]+\]/gi;
+/** 纯文本形态的提醒：`@麦芽糖bot A`（QQ 用的是全角空格，一并吃掉） */
+const LEADING_MENTION = /^(?:@[^\s@]{1,32}[\s\u2005\u00a0]*)+/;
+/** 从一句话里认出选项：字母 / 数字 / 选项原文（完全相等或包含） */
+const matchChoice = (text, choices) => {
+    const bare = text.replace(/^(?:请|我)?(?:选择|选|回复|回|答案|答)\s*/, '').trim();
+    if (!bare)
+        return -1;
+    const letter = /^([A-Za-z])$/.exec(bare);
+    if (letter) {
+        const index = letter[1].toUpperCase().charCodeAt(0) - 65;
+        if (index >= 0 && index < choices.length)
+            return index;
+    }
+    const digit = /^(\d{1,2})$/.exec(bare);
+    if (digit) {
+        const index = Number(digit[1]) - 1;
+        if (index >= 0 && index < choices.length)
+            return index;
+    }
+    /** 回原文：完全相等优先，其次是「用户打了一半」的模糊匹配（至少两个字） */
+    const exact = choices.findIndex((choice) => choice.text === bare);
+    if (exact >= 0)
+        return exact;
+    if (bare.length >= 2) {
+        const partial = choices.findIndex((choice) => choice.text.includes(bare) || bare.includes(choice.text));
+        if (partial >= 0)
+            return partial;
+    }
+    return -1;
+};
+/** 会话有效期：超过就当作结束了（用户隔天再回 A 不该续上昨天的剧情） */
+exports.INTERACTIVE_TTL_MS = 15 * 60 * 1000;
+const sessions = new Map();
+/** 会话 key：一个频道一份（群里谁回 A 都算继续剧情，和面板按钮的行为一致） */
+const interactiveKey = (platform, channelId) => String(platform ?? '') + ':' + String(channelId ?? '');
+exports.interactiveKey = interactiveKey;
+/** 存一份会话（同时清理过期会话，避免 Map 越攒越大） */
+const rememberInteractiveSession = (key, session) => {
+    const now = Date.now();
+    for (const [item, value] of sessions) {
+        if (now - value.updatedAt > exports.INTERACTIVE_TTL_MS)
+            sessions.delete(item);
+    }
+    sessions.set(key, { ...session, updatedAt: now });
+};
+exports.rememberInteractiveSession = rememberInteractiveSession;
+/** 取会话；过期或不存在都返回 null */
+const getInteractiveSession = (key) => {
+    const session = sessions.get(key);
+    if (!session)
+        return null;
+    if (Date.now() - session.updatedAt > exports.INTERACTIVE_TTL_MS) {
+        sessions.delete(key);
+        return null;
+    }
+    return session;
+};
+exports.getInteractiveSession = getInteractiveSession;
+/** 结束会话（走到结局、用户放弃、解析失败都调用它） */
+const clearInteractiveSession = (key) => {
+    sessions.delete(key);
+};
+exports.clearInteractiveSession = clearInteractiveSession;
+/** 当前活着的会话数量（测试与排查用） */
+const interactiveSessionCount = () => sessions.size;
+exports.interactiveSessionCount = interactiveSessionCount;
+/** 把一段剧情路径渲染成 `开场 → 向左走` 这种进度文本 */
+const formatInteractivePath = (path) => Array.isArray(path) && path.length ? path.join(' → ') : '';
+exports.formatInteractivePath = formatInteractivePath;