koishi-plugin-kkk 3.0.1 → 3.1.0

package/CHANGELOG.md

@@ -1,6 +1,26 @@
 # 更新日志
 
-## 3.0.1
+## 3.1.0
+
+### 卡片渲染：先量再定倍率，快的那个留下
+
+拿你各个平台的真实卡片在同一台机器上测的（同一份 HTML，各测两遍取平均）：
+
+| 卡片 | 1 倍渲染 | 2 倍渲染 | 现在固定用 |
+| --- | --- | --- | --- |
+| 抖音评论区 | **1.5 秒** | 4.2 秒 | 1 倍 |
+| B 站评论区 | **2.2 秒** | 6.8 秒 | 1 倍 |
+| 快手评论区 | **0.4 秒** | 1.0 秒 | 1 倍 |
+| 抖音作品卡 | **1.7 秒** | 2.8 秒 | 1 倍 |
+| B 站视频卡 | **1.5 秒** | 2.5 秒 | 1 倍 |
+| 小红书笔记卡 | 15.5 秒 | **5.2 秒** | 2 倍 |
+| 抖音图集卡 | 8.0 秒 | **3.3 秒** | 2 倍 |
+
+两处原因，都修了：
+
+- **有些卡片一直在用两倍分辨率渲染，然后被扔掉一半**：卡片是按 1440 宽排版的，长图切片时又会被压回 1440 宽再切 —— 2 倍渲染出来的 2880 宽像素一个都用不上。但**不能一刀切**：内核在不同倍率下走的路径不一样，实测上面这些卡片，评论卡 1 倍快 2.7 倍，小红书笔记卡反而 2 倍快 3 倍。所以现在每条路由**各测一次**：第一次用你配的倍率，第二次换另一档，之后固定用快的那档（每条路由只多花一次渲染）。你把「渲染精度」设成 50（就要 1 倍）时不测，直接听你的。
+- **内核在等它根本加载不了的远程图片**：shotkit 内核在 Windows 上拉不到 https 资源（卡片里的远程头像、封面本来就是空白框），但它照样会去请求、还等你等到超时 —— 实测页面里只要有一个连不上的 https 图片，截图就从 1.5 秒变成 **22 秒**。React 还会给每张图片额外补一条 `<link rel="preload">`（一张评论卡 27 条），这些也算在加载里。现在交给内核之前会把这些摘掉（只有用内核时才摘，切到 puppeteer 不受影响，那边远程图片正常）。
+- 顺带：渲染日志现在会写清**每张卡片花了多久**（页面多少毫秒 / 截图多少毫秒），慢的时候能一眼看出是慢在哪一步。
 
 ### 在线播放：声音不再等服务器
 

package/lib/karin/module/utils/Render/index.js

@@ -10,6 +10,7 @@ exports.buildPosterContext = buildPosterContext;
 exports.renderTemplateHtml = renderTemplateHtml;
 exports.downgradeNoiseLayers = downgradeNoiseLayers;
 exports.pruneMissingFontFaces = pruneMissingFontFaces;
+exports.neutralizeRemoteAssets = neutralizeRemoteAssets;
 exports.optimizeForScreenshot = optimizeForScreenshot;
 /**
  * 渲染模块（Koishi 移植版）。
@@ -469,6 +470,36 @@ function pruneMissingFontFaces(html, baseDir) {
         return resolvable ? block : '';
     });
 }
+/**
+ * 内核（shotkit）加载不了的远程资源，交给它之前先摘掉。
+ *
+ * 实测：内核在 Windows 上**加载不了 https 资源**（卡片里的 https 图片一律渲染成空白框），
+ * 但它照样会为这些地址发请求、并且等它们结束 —— 一张 1440x600 的小页面里只要有一个连不上的
+ * https 图片，截图就从 1.5 秒变成 22 秒。React 19 的 SSR 还会给每个 `<img>` 额外补一条
+ * `<link rel="preload" as="image">`（一张评论卡实测 27 条），这些 preload 同样算在页面加载里。
+ *
+ * 所以**只在 shotkit 这条路径**上做替换（puppeteer 那条路不动，它能正常加载远程图片）：
+ *   - 删掉 `<link rel="preload">`（纯预加载提示，本地渲染没有意义）
+ *   - 远程 `<img src>` 换成 1x1 透明图（反正渲染不出来），顺带删掉 srcset
+ *   - 内联样式/CSS 里的 `url(http…)` 换成 none
+ */
+function neutralizeRemoteAssets(html) {
+    let links = 0;
+    let images = 0;
+    let output = html.replace(/<link\b[^>]*\brel=["']?preload["']?[^>]*>/gi, () => {
+        links++;
+        return '';
+    });
+    output = output.replace(/(<img\b[^>]*?)\ssrc="https?:\/\/[^"]*"/gi, (_all, head) => {
+        images++;
+        return head + ' src="' + TRANSPARENT_PIXEL + '"';
+    });
+    output = output.replace(/(<img\b[^>]*?)\ssrcset="[^"]*"/gi, '$1');
+    output = output.replace(/url\(\s*(['"]?)https?:\/\/[^)'"]*\1\s*\)/gi, 'none');
+    return { html: output, links, images };
+}
+/** 顶掉远程图片用的 1x1 透明 gif（内联 data: 内核能正常解码） */
+const TRANSPARENT_PIXEL = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
 /** 截图前的统一降级：先剔无效字体，再降级噪点层 */
 function optimizeForScreenshot(html, baseDir) {
     const pruned = pruneMissingFontFaces(html, baseDir);
@@ -491,7 +522,7 @@ function optimizeForScreenshot(html, baseDir) {
  */
 /** 用了 shotkit 只提示一次（每张卡片都刷一行没意义） */
 let shotkitLogged = false;
-async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg') {
+async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg', htmlSource) {
     const koishiCtx = (0, node_karin_1.getKoishiContext)();
     /** 浏览器渲染服务（koishi-plugin-puppeteer / puppeteer-without-canvas 之类） */
     const puppeteer = koishiCtx?.get ? koishiCtx.get('puppeteer') : koishiCtx?.puppeteer;
@@ -511,7 +542,8 @@ async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg
     // 卡片是给手机看的：**低于 2x 会明显发虚**，所以下限锁 2（上限 3）。
     // 想更大更清晰就调 `app.renderScale`（100 → 2x，150 → 3x），配 100 时保持 2x 不出错。
     const requested = Number.isFinite(scale) && scale > 0 ? scale * 2 : 2;
-    let deviceScaleFactor = Math.min(3, Math.max(2, requested));
+    // 下限是 1x：模板都按 1440 CSS 像素排版，1x 出图正好 1440 宽 —— 也就是切片时会被压到的那个宽度
+    let deviceScaleFactor = Math.min(3, Math.max(1, requested));
     // 安全阀：超大页面降一档缩放，避免单次渲染吃掉几 GB 内存（曾经把实例 OOM 崩掉）
     try {
         if (node_fs_1.default.statSync(htmlPath).size > 6 * 1024 * 1024)
@@ -534,19 +566,36 @@ async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg
     if (shotkit && typeof shotkit.renderFile === 'function' && (preferShotkit || !puppeteer)) {
         try {
             const started = Date.now();
-            const buffer = await shotkit.renderFile(htmlPath, {
-                selector,
-                timeout,
-                deviceScaleFactor,
-                type: 'png',
-            });
+            /**
+             * 交给内核的 HTML 先摘掉它加载不了的远程资源（见 neutralizeRemoteAssets 的说明）。
+             * 走 `screenshot({ html })` 而不是 renderFile：磁盘上那份保持原样，
+             * 万一内核失败要回退到 puppeteer，那边还能正常加载远程图片。
+             */
+            const sanitized = htmlSource ? neutralizeRemoteAssets(htmlSource) : null;
+            if (sanitized && (sanitized.links > 0 || sanitized.images > 0)) {
+                node_karin_1.logger.debug('[Render] 内核用 HTML：摘掉 preload ' + sanitized.links + ' 条、远程图片 ' + sanitized.images + ' 张');
+            }
+            const buffer = sanitized && typeof shotkit.screenshot === 'function'
+                ? ((await shotkit.screenshot({
+                    html: sanitized.html,
+                    selector,
+                    timeout,
+                    deviceScaleFactor,
+                    type: 'png',
+                }))?.image)
+                : await shotkit.renderFile(htmlPath, {
+                    selector,
+                    timeout,
+                    deviceScaleFactor,
+                    type: 'png',
+                });
             if (buffer && buffer.length) {
                 if (!shotkitLogged) {
                     shotkitLogged = true;
                     node_karin_1.logger.info('[Render] 使用 shotkit 内核渲染卡片（静态内核，不执行页面 JS）');
                 }
                 node_karin_1.logger.debug('[Render] shotkit 渲染 ' + htmlPath.split(/[\\/]/).pop() + ' 用时 ' + (Date.now() - started) + 'ms');
-                return { base64: Buffer.from(buffer).toString('base64'), mime: 'image/png' };
+                return { base64: Buffer.from(buffer).toString('base64'), mime: 'image/png', dsf: deviceScaleFactor };
             }
         }
         catch (error) {
@@ -627,7 +676,7 @@ async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg
             type: format,
             quality: format === 'jpeg' ? 92 : undefined
         });
-        return { base64: buffer.toString('base64'), mime: 'image/' + format };
+        return { base64: buffer.toString('base64'), mime: 'image/' + format, dsf: deviceScaleFactor };
     };
     /**
      * 自己开一个页面截图，**不要走插件的 render() 包装**。
@@ -757,9 +806,50 @@ function unwrapImageProxy(html) {
         }
     });
 }
+const cardScaleTrials = new Map();
+/** 配置里的倍率（面板 renderScale：100 = 2x，150 = 3x，50 = 1x） */
+function configuredCardScale() {
+    return Math.min(2, Math.max(0.25, Number(Config_1.Config.app?.renderScale ?? 100) / 100));
+}
+/** 这张卡片这次该用多少倍渲染，以及这次是不是「试探」 */
+function resolveCardScale(route) {
+    const configured = configuredCardScale();
+    // 用户明确只要 1x：不试，直接听配置
+    if (configured <= 0.5)
+        return { scale: configured, trial: false };
+    const entry = cardScaleTrials.get(route);
+    if (!entry)
+        return { scale: configured, trial: false };
+    if (entry.pending !== undefined)
+        return { scale: entry.pending, trial: true };
+    return { scale: entry.best, trial: false };
+}
+/** 渲染完把这次的耗时喂回来，决定这条路之后固定用哪一档 */
+function recordCardScale(route, scale, ms) {
+    const configured = configuredCardScale();
+    if (configured <= 0.5)
+        return;
+    const entry = cardScaleTrials.get(route);
+    if (!entry) {
+        cardScaleTrials.set(route, { best: scale, bestMs: ms, pending: scale > 0.5 ? 0.5 : configured });
+        return;
+    }
+    if (entry.pending !== undefined && Math.abs(scale - entry.pending) < 1e-6) {
+        const better = ms < entry.bestMs;
+        const best = better ? scale : entry.best;
+        const bestMs = better ? ms : entry.bestMs;
+        node_karin_1.logger.info('[Render] ' + route + ' 倍率测完了：固定用 ' + best * 2 + 'x（' + Math.round(bestMs) + 'ms，'
+            + '本次 ' + scale * 2 + 'x=' + Math.round(ms) + 'ms / 上次 ' + entry.best * 2 + 'x=' + Math.round(entry.bestMs) + 'ms）');
+        cardScaleTrials.set(route, { best, bestMs });
+        return;
+    }
+    // 稳态：顺手刷新一下耗时，万一机器负载变化明显也能留着对比
+    entry.bestMs = ms;
+}
 const Render = async (_event, route, data) => {
+    const startedAt = Date.now();
     const dark = await (0, coverTheme_1.resolveUseDarkTheme)(route, data).catch(() => false);
-    const scale = Math.min(2, Math.max(0.5, Number(Config_1.Config.app?.renderScale ?? 100) / 100));
+    const { scale, trial } = resolveCardScale(route);
     let html = await renderTemplateHtml(route, data, dark);
     if (!html) {
         html = buildFallbackHtml(route, data, dark, scale);
@@ -775,10 +865,17 @@ const Render = async (_event, route, data) => {
         const isQrCode = /qrcode/i.test(route);
         const format = isQrCode ? 'png' : 'jpeg';
         // mime 由 screenshot 返回实际产出的格式：shotkit 走 PNG，其余路径仍是传入的 format
-        const { base64, mime } = await screenshot(htmlPath, '#container', Number(Config_1.Config.app?.RenderWaitTime ?? 10) * 1000, scale, format);
+        const htmlBuiltAt = Date.now();
+        const { base64, mime, dsf } = await screenshot(htmlPath, '#container', Number(Config_1.Config.app?.RenderWaitTime ?? 10) * 1000, scale, format, html);
+        const shotAt = Date.now();
         const buffer = Buffer.from(base64, 'base64');
         const meta = (0, exports.getImageMetadata)(buffer);
-        node_karin_1.logger.debug('[Render] ' + route + ' 渲染完成 ' + mime + ' ' + (meta.width ?? '?') + 'x' + (meta.height ?? '?') + ' ' + Math.round(buffer.length / 1024) + 'KB');
+        // 把这次的截图耗时喂回去，决定这条路之后固定用哪一档（见上面 cardScaleTrials）
+        recordCardScale(route, scale, shotAt - htmlBuiltAt);
+        node_karin_1.logger.info('[Render] ' + route + ' 渲染完成 ' + mime + ' ' + (meta.width ?? '?') + 'x' + (meta.height ?? '?')
+            + ' ' + Math.round(buffer.length / 1024) + 'KB'
+            + ' 用时 ' + (shotAt - startedAt) + 'ms（页面 ' + (htmlBuiltAt - startedAt) + 'ms / 截图 ' + (shotAt - htmlBuiltAt)
+            + 'ms，' + dsf + 'x' + (trial ? '，本次试另一档倍率' : '') + '）');
         // 用带 mime 的 data URL，适配器才知道按对应格式上传（base64:// 会被当成 PNG）
         return [node_karin_1.segment.image('data:' + mime + ';base64,' + base64)];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-kkk",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "抖音 / B站 / 快手 / 小红书 视频解析与动态推送，带 QQ 交互面板与弹幕烧录（karin-plugin-kkk 的 Koishi 移植版）",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/scripts/smoke-config.cjs

@@ -150,25 +150,25 @@ setTimeout(async () => {
      */
     console.log('\n[6] 面板保存（authoritative）：改回默认值也要能写进 config.json')
     const defaultFake = defaults.app.fakeForward
-    check('前提：app.fakeForward 的默认值就是 true（打开它 = 改回默认值）', defaultFake === true, String(defaultFake))
-    // 1) 先关掉（和默认值不同，两条路都能写回）
-    applyUpstreamOverrides({ app: { fakeForward: false } })
-    const offValue = JSON.parse(fs.readFileSync(cfgFile, 'utf8')).app.fakeForward
-    check('关掉能写回', offValue === false, String(offValue))
+    check('前提：app.fakeForward 的默认值就是 false（合并转发默认全关）', defaultFake === false, String(defaultFake))
+    // 1) 先打开（和默认值不同，两条路都能写回）
+    applyUpstreamOverrides({ app: { fakeForward: true } })
+    const onValue = JSON.parse(fs.readFileSync(cfgFile, 'utf8')).app.fakeForward
+    check('打开能写回', onValue === true, String(onValue))
     // 2) 保守模式下发「默认值」会被当成没动过（老行为，保护手改的文件）
-    const conservative = applyUpstreamOverrides({ app: { fakeForward: true } })
+    const conservative = applyUpstreamOverrides({ app: { fakeForward: false } })
     const afterConservative = JSON.parse(fs.readFileSync(cfgFile, 'utf8')).app.fakeForward
     check('保守模式：正好等于默认值时不写回（保护手改文件的老规则还在）',
-      !conservative.changed.includes('app.fakeForward') && afterConservative === false,
+      !conservative.changed.includes('app.fakeForward') && afterConservative === true,
       'changed=' + conservative.changed.join(', ') + ' / 文件里=' + String(afterConservative))
-    // 3) 面板保存（authoritative）必须写回 —— 这就是用户那条「打开了没用」
-    const panel = applyUpstreamOverrides({ app: { fakeForward: true } }, { authoritative: true })
+    // 3) 面板保存（authoritative）必须写回 —— 这就是用户那条「改了没用」
+    const panel = applyUpstreamOverrides({ app: { fakeForward: false } }, { authoritative: true })
     const afterPanel = JSON.parse(fs.readFileSync(cfgFile, 'utf8')).app.fakeForward
-    check('面板保存：值等于默认值也能写回（打开开关立刻生效）',
-      panel.changed.includes('app.fakeForward') && afterPanel === true,
+    check('面板保存：值等于默认值也能写回（关掉开关立刻生效）',
+      panel.changed.includes('app.fakeForward') && afterPanel === false,
       'changed=' + panel.changed.join(', ') + ' / 文件里=' + String(afterPanel))
     // 4) 面板保存也不会顺手把「没变」的项写坏
-    const panelNoop = applyUpstreamOverrides({ app: { fakeForward: true, renderScale: 120 } }, { authoritative: true })
+    const panelNoop = applyUpstreamOverrides({ app: { fakeForward: false, renderScale: 120 } }, { authoritative: true })
     check('面板保存：值和文件里一样的项不重复写', panelNoop.changed.length === 0, panelNoop.changed.join(', '))
     check('手改过的其它项没被顺手改掉', JSON.parse(fs.readFileSync(cfgFile, 'utf8')).app.renderScale === 120)
     applyUpstreamOverrides({ app: { fakeForward: defaultFake } }, { authoritative: true })

package/src/karin/module/utils/Render/index.ts

@@ -462,6 +462,38 @@ export function pruneMissingFontFaces (html: string, baseDir: string): string {
   })
 }
 
+/**
+ * 内核（shotkit）加载不了的远程资源，交给它之前先摘掉。
+ *
+ * 实测：内核在 Windows 上**加载不了 https 资源**（卡片里的 https 图片一律渲染成空白框），
+ * 但它照样会为这些地址发请求、并且等它们结束 —— 一张 1440x600 的小页面里只要有一个连不上的
+ * https 图片，截图就从 1.5 秒变成 22 秒。React 19 的 SSR 还会给每个 `<img>` 额外补一条
+ * `<link rel="preload" as="image">`（一张评论卡实测 27 条），这些 preload 同样算在页面加载里。
+ *
+ * 所以**只在 shotkit 这条路径**上做替换（puppeteer 那条路不动，它能正常加载远程图片）：
+ *   - 删掉 `<link rel="preload">`（纯预加载提示，本地渲染没有意义）
+ *   - 远程 `<img src>` 换成 1x1 透明图（反正渲染不出来），顺带删掉 srcset
+ *   - 内联样式/CSS 里的 `url(http…)` 换成 none
+ */
+export function neutralizeRemoteAssets (html: string): { html: string; links: number; images: number } {
+  let links = 0
+  let images = 0
+  let output = html.replace(/<link\b[^>]*\brel=["']?preload["']?[^>]*>/gi, () => {
+    links++
+    return ''
+  })
+  output = output.replace(/(<img\b[^>]*?)\ssrc="https?:\/\/[^"]*"/gi, (_all: string, head: string) => {
+    images++
+    return head + ' src="' + TRANSPARENT_PIXEL + '"'
+  })
+  output = output.replace(/(<img\b[^>]*?)\ssrcset="[^"]*"/gi, '$1')
+  output = output.replace(/url\(\s*(['"]?)https?:\/\/[^)'"]*\1\s*\)/gi, 'none')
+  return { html: output, links, images }
+}
+
+/** 顶掉远程图片用的 1x1 透明 gif（内联 data: 内核能正常解码） */
+const TRANSPARENT_PIXEL = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'
+
 /** 截图前的统一降级：先剔无效字体，再降级噪点层 */
 export function optimizeForScreenshot (html: string, baseDir: string): string {
   const pruned = pruneMissingFontFaces(html, baseDir)
@@ -487,7 +519,7 @@ export function optimizeForScreenshot (html: string, baseDir: string): string {
 /** 用了 shotkit 只提示一次（每张卡片都刷一行没意义） */
 let shotkitLogged = false
 
-async function screenshot (htmlPath: string, selector: string, timeout: number, scale = 1, format: 'png' | 'jpeg' = 'jpeg'): Promise<{ base64: string; mime: string }> {
+async function screenshot (htmlPath: string, selector: string, timeout: number, scale = 1, format: 'png' | 'jpeg' = 'jpeg', htmlSource?: string): Promise<{ base64: string; mime: string; dsf: number }> {
   const koishiCtx: any = getKoishiContext()
   /** 浏览器渲染服务（koishi-plugin-puppeteer / puppeteer-without-canvas 之类） */
   const puppeteer: any = koishiCtx?.get ? koishiCtx.get('puppeteer') : koishiCtx?.puppeteer
@@ -508,7 +540,8 @@ async function screenshot (htmlPath: string, selector: string, timeout: number,
   // 卡片是给手机看的：**低于 2x 会明显发虚**，所以下限锁 2（上限 3）。
   // 想更大更清晰就调 `app.renderScale`（100 → 2x，150 → 3x），配 100 时保持 2x 不出错。
   const requested = Number.isFinite(scale) && scale > 0 ? scale * 2 : 2
-  let deviceScaleFactor = Math.min(3, Math.max(2, requested))
+  // 下限是 1x：模板都按 1440 CSS 像素排版，1x 出图正好 1440 宽 —— 也就是切片时会被压到的那个宽度
+  let deviceScaleFactor = Math.min(3, Math.max(1, requested))
   // 安全阀：超大页面降一档缩放，避免单次渲染吃掉几 GB 内存（曾经把实例 OOM 崩掉）
   try {
     if (fs.statSync(htmlPath).size > 6 * 1024 * 1024) deviceScaleFactor = Math.max(1, deviceScaleFactor - 1)
@@ -530,19 +563,36 @@ async function screenshot (htmlPath: string, selector: string, timeout: number,
   if (shotkit && typeof shotkit.renderFile === 'function' && (preferShotkit || !puppeteer)) {
     try {
       const started = Date.now()
-      const buffer = await shotkit.renderFile(htmlPath, {
-        selector,
-        timeout,
-        deviceScaleFactor,
-        type: 'png',
-      })
+      /**
+       * 交给内核的 HTML 先摘掉它加载不了的远程资源（见 neutralizeRemoteAssets 的说明）。
+       * 走 `screenshot({ html })` 而不是 renderFile：磁盘上那份保持原样，
+       * 万一内核失败要回退到 puppeteer，那边还能正常加载远程图片。
+       */
+      const sanitized = htmlSource ? neutralizeRemoteAssets(htmlSource) : null
+      if (sanitized && (sanitized.links > 0 || sanitized.images > 0)) {
+        logger.debug('[Render] 内核用 HTML：摘掉 preload ' + sanitized.links + ' 条、远程图片 ' + sanitized.images + ' 张')
+      }
+      const buffer = sanitized && typeof shotkit.screenshot === 'function'
+        ? ((await shotkit.screenshot({
+          html: sanitized.html,
+          selector,
+          timeout,
+          deviceScaleFactor,
+          type: 'png',
+        }))?.image)
+        : await shotkit.renderFile(htmlPath, {
+          selector,
+          timeout,
+          deviceScaleFactor,
+          type: 'png',
+        })
       if (buffer && buffer.length) {
         if (!shotkitLogged) {
           shotkitLogged = true
           logger.info('[Render] 使用 shotkit 内核渲染卡片（静态内核，不执行页面 JS）')
         }
         logger.debug('[Render] shotkit 渲染 ' + htmlPath.split(/[\\/]/).pop() + ' 用时 ' + (Date.now() - started) + 'ms')
-        return { base64: Buffer.from(buffer).toString('base64'), mime: 'image/png' }
+        return { base64: Buffer.from(buffer).toString('base64'), mime: 'image/png', dsf: deviceScaleFactor }
       }
     } catch (error: any) {
       shotkitFailure = error
@@ -626,7 +676,7 @@ async function screenshot (htmlPath: string, selector: string, timeout: number,
       type: format,
       quality: format === 'jpeg' ? 92 : undefined
     } as any)
-    return { base64: buffer.toString('base64'), mime: 'image/' + format }
+    return { base64: buffer.toString('base64'), mime: 'image/' + format, dsf: deviceScaleFactor }
   }
 
   /**
@@ -745,9 +795,74 @@ function unwrapImageProxy (html: string): string {
   })
 }
 
+/**
+ * 「这张卡片该用 1x 还是 2x 渲染」——**不猜，试**。
+ *
+ * 起因：模板按 1440 CSS 像素排版，长图切片时又会被压回 1440 宽再切
+ * （见 ImageSlice 的 SLICE_WIDTH），所以长卡片用 2x 渲染出来的 2880 宽像素一个都用不上。
+ *
+ * 但不能按「高不高」一刀切：同一台机器上实测（都是 1440 宽、同样的 HTML），
+ * 内核在不同倍率下走的**光栅化路径不同**，谁快完全看内容 ——
+ *   评论卡（9489 CSS 高）：1x 1.5s vs 2x 3.9s，1x 快 2.6 倍；
+ *   B 站评论卡（17965）：1x 2.0s vs 2x 7.4s，1x 快 3.7 倍；
+ *   图集卡（2854）：1x 7.8s vs 2x 3.0s，**2x 反而快 2.6 倍**；
+ *   直播推荐卡（2593）：1x 10.1s vs 2x 4.4s，**2x 快 2.3 倍**。
+ * 按高度猜必然错一半，所以这里改成**每条路由各测一次**：第一次用配置的倍率，
+ * 第二次换另一档，之后固定用快的那档 —— 代价是每条路由多一次渲染（只在进程活着期间），
+ * 换来的是之后每次都走对路。用户把 renderScale 设成 50（只要 1x）时不试，直接听配置。
+ */
+interface CardScaleTrial {
+  /** 目前认为更快的倍率 */
+  best: number
+  bestMs: number
+  /** 还没试过的另一档，试完就清空 */
+  pending?: number
+}
+
+const cardScaleTrials = new Map<string, CardScaleTrial>()
+
+/** 配置里的倍率（面板 renderScale：100 = 2x，150 = 3x，50 = 1x） */
+function configuredCardScale (): number {
+  return Math.min(2, Math.max(0.25, Number(Config.app?.renderScale ?? 100) / 100))
+}
+
+/** 这张卡片这次该用多少倍渲染，以及这次是不是「试探」 */
+function resolveCardScale (route: string): { scale: number; trial: boolean } {
+  const configured = configuredCardScale()
+  // 用户明确只要 1x：不试，直接听配置
+  if (configured <= 0.5) return { scale: configured, trial: false }
+  const entry = cardScaleTrials.get(route)
+  if (!entry) return { scale: configured, trial: false }
+  if (entry.pending !== undefined) return { scale: entry.pending, trial: true }
+  return { scale: entry.best, trial: false }
+}
+
+/** 渲染完把这次的耗时喂回来，决定这条路之后固定用哪一档 */
+function recordCardScale (route: string, scale: number, ms: number): void {
+  const configured = configuredCardScale()
+  if (configured <= 0.5) return
+  const entry = cardScaleTrials.get(route)
+  if (!entry) {
+    cardScaleTrials.set(route, { best: scale, bestMs: ms, pending: scale > 0.5 ? 0.5 : configured })
+    return
+  }
+  if (entry.pending !== undefined && Math.abs(scale - entry.pending) < 1e-6) {
+    const better = ms < entry.bestMs
+    const best = better ? scale : entry.best
+    const bestMs = better ? ms : entry.bestMs
+    logger.info('[Render] ' + route + ' 倍率测完了：固定用 ' + best * 2 + 'x（' + Math.round(bestMs) + 'ms，'
+      + '本次 ' + scale * 2 + 'x=' + Math.round(ms) + 'ms / 上次 ' + entry.best * 2 + 'x=' + Math.round(entry.bestMs) + 'ms）')
+    cardScaleTrials.set(route, { best, bestMs })
+    return
+  }
+  // 稳态：顺手刷新一下耗时，万一机器负载变化明显也能留着对比
+  entry.bestMs = ms
+}
+
 export const Render = async (_event: any, route: string, data: any): Promise<any[]> => {
+  const startedAt = Date.now()
   const dark = await resolveUseDarkTheme(route, data).catch(() => false)
-  const scale = Math.min(2, Math.max(0.5, Number(Config.app?.renderScale ?? 100) / 100))
+  const { scale, trial } = resolveCardScale(route)
 
   let html = await renderTemplateHtml(route, data, dark)
   if (!html) {
@@ -765,10 +880,17 @@ export const Render = async (_event: any, route: string, data: any): Promise<any
     const isQrCode = /qrcode/i.test(route)
     const format: 'png' | 'jpeg' = isQrCode ? 'png' : 'jpeg'
     // mime 由 screenshot 返回实际产出的格式：shotkit 走 PNG，其余路径仍是传入的 format
-    const { base64, mime } = await screenshot(htmlPath, '#container', Number(Config.app?.RenderWaitTime ?? 10) * 1000, scale, format)
+    const htmlBuiltAt = Date.now()
+    const { base64, mime, dsf } = await screenshot(htmlPath, '#container', Number(Config.app?.RenderWaitTime ?? 10) * 1000, scale, format, html)
+    const shotAt = Date.now()
     const buffer = Buffer.from(base64, 'base64')
     const meta = getImageMetadata(buffer)
-    logger.debug('[Render] ' + route + ' 渲染完成 ' + mime + ' ' + (meta.width ?? '?') + 'x' + (meta.height ?? '?') + ' ' + Math.round(buffer.length / 1024) + 'KB')
+    // 把这次的截图耗时喂回去，决定这条路之后固定用哪一档（见上面 cardScaleTrials）
+    recordCardScale(route, scale, shotAt - htmlBuiltAt)
+    logger.info('[Render] ' + route + ' 渲染完成 ' + mime + ' ' + (meta.width ?? '?') + 'x' + (meta.height ?? '?')
+      + ' ' + Math.round(buffer.length / 1024) + 'KB'
+      + ' 用时 ' + (shotAt - startedAt) + 'ms（页面 ' + (htmlBuiltAt - startedAt) + 'ms / 截图 ' + (shotAt - htmlBuiltAt)
+      + 'ms，' + dsf + 'x' + (trial ? '，本次试另一档倍率' : '') + '）')
     // 用带 mime 的 data URL，适配器才知道按对应格式上传（base64:// 会被当成 PNG）
     return [segment.image('data:' + mime + ';base64,' + base64)]
   } catch (error: any) {

package/src/karin/types/config/app.ts

@@ -18,7 +18,13 @@ export interface appConfig {
    */
   renderer: 'shotkit' | 'puppeteer'
 
-  /** 渲染精度，可选值50~200，建议100。设置高精度会提高图片的精细度，过高可能会影响渲染与发送速度 */
+  /**
+   * 渲染精度，可选值50~200，建议100。设置高精度会提高图片的精细度，过高可能会影响渲染与发送速度。
+   *
+   * 这是**起点**，不是死值：内核在 1x / 2x 下走的渲染路径不同，谁快看内容（实测评论卡 1x 快 2.7 倍、
+   * 小红书笔记卡 2x 快 3 倍），所以每条路由会各测一次（第一次用这里的倍率，第二次换另一档），
+   * 之后固定用快的那档。设成 50（只要 1x）时不测，直接听配置。
+   */
   renderScale: number
 
   /**