// ==UserScript==
// @name         Steam 创意工坊增强
// @name:en      Steam Workshop Enhancer
// @namespace    steam-workshop-enhancer
// @version      1.8.3
// @description  为新版 Steam 创意工坊补回被改版削掉的信息与批量能力。浏览页：卡片显示订阅数/收藏数/浏览量/文件大小/更新时间、悬浮按钮（复制 ID/SteamCMD/收藏）、已订阅角标、星级筛选（≥N 星 / 仅已评分 / 最低票数，作用于当前页；0 命中时自动翻下一页继续找）、跨页看 5★（原生 toprated 排序 + 逐页隐藏非 5★）、原生排序（最受好评/最新更新/最热门，跨页生效）、每页条数 10/15/30/50（服务端白名单）+ 100/200（客户端跨页聚合，真的能看这么多条）、预览图原图升级、批量勾选订阅/退订、勾选批量导出（ID/链接/CMD/名称/JSON）。收藏夹管理器：搜索/筛选/检查更新/批量导出文件。订阅备份：翻页拉取全部订阅导出 JSON，导入还原自动批量重订。详情页：生命周期订阅数/累计收藏/浏览量/精确时间/完整标签云/复制 ID 与 SteamCMD。艺术作品页（/app/{id}/images/ 与 /screenshots/）：卡片显示浏览量/收藏/大小/更新时间、一键下载原图（去尺寸限制，实测 280KB→707KB，完全原图可达 1908×2808）、批量勾选批量下载、复制本页作品链接；截图页额外提供纯图瀑布流浮窗（全屏铺开社区截图、点图看原图、独立 DOM 不改原页面）。游戏创意工坊首页（/app/{id}/workshop/）：分区卡片同样增强。浮动按钮整合为一个贴边图标组，可拖到窗口上/下/左/右任一边缘并记住位置（不再互相遮挡）。核心数据走 Steam 免密钥公开接口 ISteamRemoteStorage/GetPublishedFileDetails（单批 200 条、CORS 直连），不依赖任何私有接口。
// @description:en Restores the information density and bulk tooling that Valve's Workshop redesign removed. Browse page: per-card subscriber/favorite/view counts, file size, update date, hover actions (copy ID / SteamCMD / bookmark), subscribed badges, advanced client-side sorting (star rating included), star-level filtering, per-page 10/15/30/50 (server whitelist) plus 100/200 via client-side cross-page aggregation that really shows that many items, full-resolution previews, multi-select batch subscribe/unsubscribe, bulk export of selected items (IDs/links/SteamCMD/names/JSON). Bookmark manager: search, filters, update checking, batch export. Subscription backup: fetch all subscriptions page by page into a JSON snapshot, restore by batch re-subscribing. Detail page: lifetime subscriptions, cumulative favorites, views, exact timestamps, full tag cloud, copy ID/SteamCMD. Artwork page: per-card stats, one-click original-image download, multi-select batch download, copy all artwork links; the screenshots page additionally gets a pure-image waterfall overlay (full-screen community screenshots, click for the original, independent DOM that leaves the original page untouched). Game workshop home (/app/{id}/workshop/): section cards are enhanced too. Floating buttons are unified into one edge-docked icon group that can be dragged to any window edge (top/bottom/left/right) and remembers its position. Data comes from Steam's keyless public endpoint ISteamRemoteStorage/GetPublishedFileDetails (200 per batch, CORS-friendly) — no private APIs.
// @author       SmallRob
// @match        https://steamcommunity.com/workshop/*
// @match        https://steamcommunity.com/sharedfiles/*
// @match        https://steamcommunity.com/my/myworkshopfiles*
// @match        https://steamcommunity.com/profiles/*/myworkshopfiles*
// @match        https://steamcommunity.com/app/*/images*
// @match        https://steamcommunity.com/app/*/screenshots*
// @match        https://steamcommunity.com/app/*/workshop*
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_deleteValue
// @grant        GM_xmlhttpRequest
// @grant        GM_addStyle
// @grant        GM_info
// @grant        GM_setClipboard
// @grant        GM_download
// @grant        unsafeWindow
// @connect      api.steampowered.com
// @connect      steamcommunity.com
// @connect      images.steamusercontent.com
// @connect      steamuserimages-a.akamaihd.net
// @run-at       document-idle
// @license      MIT
// @tag          Steam
// @tag          workshop
// @icon         data:image/svg+xml,%3Csvg%20xmlns%3D'http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg'%20viewBox%3D'0%200%20100%20100'%3E%3Cdefs%3E%3ClinearGradient%20id%3D'bg'%20x1%3D'0'%20y1%3D'0'%20x2%3D'1'%20y2%3D'1'%3E%3Cstop%20offset%3D'0'%20stop-color%3D'%2318293c'%2F%3E%3Cstop%20offset%3D'1'%20stop-color%3D'%230a131e'%2F%3E%3C%2FlinearGradient%3E%3CradialGradient%20id%3D'halo'%20cx%3D'0.5'%20cy%3D'0.44'%20r%3D'0.6'%3E%3Cstop%20offset%3D'0'%20stop-color%3D'%232f5a86'%2F%3E%3Cstop%20offset%3D'1'%20stop-color%3D'%232f5a86'%20stop-opacity%3D'0'%2F%3E%3C%2FradialGradient%3E%3ClinearGradient%20id%3D'mtnBack'%20x1%3D'0'%20y1%3D'1'%20x2%3D'1'%20y2%3D'0'%3E%3Cstop%20offset%3D'0'%20stop-color%3D'%232b5f8f'%2F%3E%3Cstop%20offset%3D'1'%20stop-color%3D'%235c50b8'%2F%3E%3C%2FlinearGradient%3E%3ClinearGradient%20id%3D'mtnMain'%20x1%3D'0'%20y1%3D'1'%20x2%3D'1'%20y2%3D'0'%3E%3Cstop%20offset%3D'0'%20stop-color%3D'%234fe0ff'%2F%3E%3Cstop%20offset%3D'0.55'%20stop-color%3D'%2366c0f4'%2F%3E%3Cstop%20offset%3D'1'%20stop-color%3D'%23a26bff'%2F%3E%3C%2FlinearGradient%3E%3ClinearGradient%20id%3D'sun'%20x1%3D'0'%20y1%3D'0'%20x2%3D'1'%20y2%3D'1'%3E%3Cstop%20offset%3D'0'%20stop-color%3D'%23ffe082'%2F%3E%3Cstop%20offset%3D'1'%20stop-color%3D'%23ff8f00'%2F%3E%3C%2FlinearGradient%3E%3ClinearGradient%20id%3D'spec'%20x1%3D'0'%20y1%3D'0'%20x2%3D'1'%20y2%3D'0'%3E%3Cstop%20offset%3D'0'%20stop-color%3D'%23ff5c8a'%2F%3E%3Cstop%20offset%3D'0.25'%20stop-color%3D'%23f5a623'%2F%3E%3Cstop%20offset%3D'0.5'%20stop-color%3D'%235cba6f'%2F%3E%3Cstop%20offset%3D'0.75'%20stop-color%3D'%234fe0ff'%2F%3E%3Cstop%20offset%3D'1'%20stop-color%3D'%23a26bff'%2F%3E%3C%2FlinearGradient%3E%3C%2Fdefs%3E%3Crect%20width%3D'100'%20height%3D'100'%20rx%3D'22'%20fill%3D'url(%23bg)'%2F%3E%3Ccircle%20cx%3D'50'%20cy%3D'46'%20r%3D'36'%20fill%3D'url(%23halo)'%2F%3E%3Cpath%20d%3D'M6%2072%20L26%2046%20L38%2061%20L47%2050%20L62%2072%20Z'%20fill%3D'url(%23mtnBack)'%20opacity%3D'0.75'%2F%3E%3Cpath%20d%3D'M16%2072%20L41%2033%20L53%2052%20L64%2039%20L88%2072%20Z'%20fill%3D'url(%23mtnMain)'%2F%3E%3Ccircle%20cx%3D'71'%20cy%3D'25'%20r%3D'11'%20fill%3D'url(%23sun)'%20opacity%3D'0.28'%2F%3E%3Ccircle%20cx%3D'71'%20cy%3D'25'%20r%3D'7'%20fill%3D'url(%23sun)'%2F%3E%3Crect%20x%3D'14'%20y%3D'79'%20width%3D'72'%20height%3D'6'%20rx%3D'3'%20fill%3D'url(%23spec)'%2F%3E%3C%2Fsvg%3E
// ==/UserScript==

/**
 * Steam 创意工坊增强 v1.8.3
 *
 * 设计依据：docs/workshop-enhancer-design.md（2026-10-27 实测逆向新版创意工坊）
 *
 * 核心事实（实测）：
 *   1. 新版浏览页 /workshop/browse/ 是 React SPA，CSS 类名哈希化（UNowfeldbNg- 之类），
 *      **绝不能靠类名定位**。本脚本只用稳定语义锚点：href 模式 / role / aria / SVG 语义类。
 *   2. 条目详情页 /sharedfiles/filedetails/ 仍是经典服务端渲染 HTML，类名稳定。
 *   3. ISteamRemoteStorage/GetPublishedFileDetails/v1 免 API Key、POST、CORS 反射 Origin，
 *      单批可取 200 条，返回订阅数/收藏数/浏览量/文件大小/时间戳/标签——远多于新版 UI 显示。
 *   4. 旧 URL 参数仍有 browsesort=toprated / lastupdated / trend、section、requiredtags[]、
 *      days、p 可用（跨页生效）；newest / mostsubscribed / mostdiscussed 会被归一成 trend。
 *      因此「原生排序」直接改 URL 实现，不碰私有接口。
 *
 * ===== 2026-10-30 实测修正：num_per_page 服务端白名单 = [10, 15, 30, 50] =====
 *   · 逐值实测（appid=570，section=readytouseitems，browsesort=toprated）：
 *       npp=10 → 10 条    npp=15 → 15 条    npp=30 → 30 条    npp=50 → 50 条
 *       npp=1/5/12/16/20/24/25/35/40/45/48/51/60/70/75/80/90/100/120/150/200/0
 *            → 一律回落成 30 条（服务端把非法值归一到默认 30）
 *   · 服务端 SSR 回显的 queryKey 同步证明这一点：请求 npp=100 时
 *     `["workshop_browse", {..., num_per_page: 30, ...}]` —— 值被改写，不是 100。
 *   · 客户端 SPA 自己也用同一套白名单：chunk C-Bheh1z.js 里
 *     `rgNumPerPageOptions ?? [10,15,30,50]`（原生「每页」下拉的可选值）。
 *   · 结论：**100/200 条每页在服务端不存在**，写进 URL 只会静默变成 30 条。
 *     所以 v1.4.0 里「每页条数 30→200」是假的——那行 toast 自己也承认「可能被服务端忽略」。
 *   · 真正的实现（v1.5.0）：10/15/30/50 走服务端 URL 参数（原生分页，正确）；
 *     100/200 走**客户端跨页聚合**——按 50 条/页抓 p、p+1…p+k 页，把多个页的
 *     结果合并渲染到同一个网格里（实测 p=1..3 @50 条 → 150 个唯一 id，零重复）。
 *
 * ===== 2026-10-30 实测修正：/app/{appid}/workshop/ 是独立路由 =====
 *   · 该地址（Dota 2 创意工坊首页）此前**根本没被 @match 覆盖**，脚本压根不运行；
 *     现在补上 @match + pageKind 分支，并复用浏览页的卡片增强（同一套哈希化卡片 DOM）。
 *   · 该页用 `workshop_query` 查询（不是 `workshop_browse`），且**没有「每页」下拉**，
 *     所以排序/筛选/分页等浏览页专属控件在该页隐藏，只保留卡片增强与批量操作。
 *
 * ===== 2026-10-31 v1.6.0：浮动图标组（dock）=====
 *   · 此前「设置」按钮（.swe-toolbar-toggle）与「瀑布流」按钮（.swe-wf-btn）是
 *     **两个各自 fixed 到窗口右下角**的元素（right/bottom 只差几像素）→ 必然叠在一起。
 *   · 现在所有浮动圆按钮统一放进一个 dock 容器，由 flex 排布 → 结构上不可能重叠；
 *     dock 还能整体拖到窗口**上/右/下/左**任一边缘，抬手自动吸附并记住位置。
 *   · 面板改为相对 dock 定位（absolute），按贴边方向决定朝哪边展开，展开时钳制在视口内。
 *   · 拖拽用 Pointer Events；位移超过 6px 才算拖拽（否则点按钮会被吃掉）。
 *
 * ===== 2026-10-31 v1.6.1：面板「−」收起按钮修复 =====
 *   · 用户反馈「设置浮窗点最小化按钮不关闭」—— 该按钮的 HTML 一直都在，
 *     但**从未绑定任何事件**，所以点了毫无反应。
 *   · v1.6.1 抽出公共函数 bindPanelCollapse(dock)，在 initDock 里统一绑定；
 *     浏览页与艺术作品页两个面板共用（艺术作品页面板原本连这个按钮都没有，一并补上，
 *     head 结构统一为 .swe-panel-head + .swe-panel-body）。
 *   · 已用真实浏览器验证：展开态点「−」→ display:none；再点 ⚙ → 回到 display:flex。
 *
 * ===== 2026-10-31 v1.6.2：修「拖得动、点不动」的回归 =====
 *   · 现象：v1.6.1 的图标组能拖，但按钮点了没反应。
 *   · 根因：pointerdown 里调了 dock.setPointerCapture() —— 一旦捕获指针，
 *     按规范后续的兼容性鼠标事件（含 click）会被 retarget 到捕获元素，
 *     用户按下的那个按钮根本收不到 click → 处理器永不执行。
 *   · 修法：**彻底不用 setPointerCapture**；pointermove / pointerup 改挂 window
 *     （capture 阶段），鼠标移出图标组也能继续跟手
 * *   · 附带修掉一个隐藏缺陷：原先 move 监听挂在图标组上，快速拖动时第一个
 *     pointermove 就已出界 → 拖拽直接断掉。挂到 window 后不再断。
 *   · 为什么之前没测出来：上一版 e2e 用 element.click()（合成事件直接派发到按钮），
 *     绕过了真实鼠标的 capture 流程。v1.6.2 起改用 CDP Input.dispatchMouseEvent
 *     走完整链路（真实按下 → 真实移动 → 真实抬起）。
 *
 * ===== 2026-10-31 v1.7.0：截图瀑布流浮窗体验优化 =====
 *   · 「加载更多」加载不出来 —— 实测根因是 numperpage：
 *     hidden 里原值是 10（页面自己的每页条数），该值下**第 2 页只回 2 张** → 翻两页就空。
 *     实测 npp=30 → 每页 30 张；npp=100 → 每页 100 张；页码 p2..p5 正常推进、id 互不重复。
 *     现改为显式请求 numperpage=50，并按 id 去重。
 *     另：browsefilter（trend/newest/空）对结果**完全无影响**（返回 id 一模一样），不动它。
 *   · wfLoadMore 补并发保护 —— 滚动到底会连续触发 scroll，之前会同时发出多个请求、
 *     页码与计数互相踩；现在 loading 期间直接忽略重复触发。
 *   · 空页自动续抓：某一页全是已加载过的（与首屏重叠）时自动再往后试几页。
 *   · 加载失败不再置为「已加载完」，保留重试机会（状态区提示，可再点）。
 *   · 标题显示游戏名（实测锚点 .apphub_AppName → "Dota 2"）。
 *   · 新增：骨架屏、加载状态文案、打开即后台补一批、窗口缩放重排列数、
 *     全屏看图支持左右方向键翻页与「第 N / 共 M 张」定位。
 *
 * ===== 2026-11-01 v1.8.0：星级筛选 0 命中自动翻页（星级猎取）+ 刷新循环保险 =====
 *   · 用户反馈「点仅 5 星什么都没有 / 有时整页灰掉未响应」：
 *     星级筛选只作用于当前页，本页一张 5★ 都没有时全部卡片被打上 swe-card-hidden
 *     （display:none）——新版工坊页面只剩背景大图，看起来「整个灰掉」。
 *     且筛选设置持久化，换页/换游戏仍生效 → 空白灰页反复出现。
 *   · 新增「星级猎取」：筛选生效且本页 0 命中时，自动把 URL 的 p 推进到下一服务端页
 *     （其余参数原样保留），整页加载后重新筛，直到找到命中页或触发停止条件。
 *     仅 rated / ≥3 / ≥4 / 5★ 档位参与；纯最低票数不参与（票数快照可能过期，依据不可靠）。
 *   · 防失控三保险：
 *       ① 页码推进受 SSR total_pages 约束（读不到时靠跳页次数上限兜底，默认 20 页）；
 *       ② 「远征」状态（档位签名 + 结果集 + 已跳页数）存 sessionStorage——
 *          整页刷新不丢（跳页是整页加载）、换筛选/换结果集自动重置、新标签页不继承；
 *       ③ sessionStorage 不可用或写入回读校验失败 → 本会话禁用猎取。
 *          绝不在无状态下盲跳，否则每页都从 hops=0 重新计数 = 无限重定向循环。
 *   · applyPerPageDefault 的整页刷新加同 URL 3 秒去重保险：若 SPA 剥掉/改写 num_per_page
 *     参数，旧逻辑会无限 location.replace（页面永远在加载、始终灰着点不动）——
 *     这是「灰色未响应」最可能的死循环成因模式，现在同一目标 URL 3 秒内只自动重定向一次。
 *   · readSsrStarData / readSsrStarDataFromHtml 通用遍历加访问节点数硬上限（2 万），
 *     防御异常大的 SSR 快照拖慢主线程。
 *   · 状态行与 toast 全程可见：「本页 0 条，自动跳第 N 页继续筛选…」/「连续 N 页无匹配，
 *     已停止自动翻页」——随时把星级改回「全部」即可退出。
 *
 * ===== 2026-11-01 v1.8.1：筛选后仅剩卡片被纵向拉成长条的布局修复 =====
 *   · 用户截图：星级筛选后整页只剩一两张卡，卡片被拉成约一屏高的细长条、悬在页面中部。
 *   · 根因在 Steam 网格自身：新版工坊网格的内容区带 min-height（或被父级撑高），
 *     CSS Grid 默认 `align-content: stretch` —— 内容只剩一行时，富余高度会被分给
 *     **唯一的行轨道**；卡片默认 `align-self: stretch` 跟着行一起被纵向撑满。
 *     卡片水平居中则与其部分行居中（justify-content: center）一致 —— 都是原生行为，
 *     只是「只剩一张卡」这个场景把两者同时暴露了。display:none 的隐藏方式没有问题。
 *   · 修复：applyStarFilter 给网格容器打 `data-swe-grid-filtered="1"` 标记（幂等），
 *     CSS 侧把该网格改为 `align-content: start`（多余空间留在网格下方）+
 *     `grid-auto-rows: min-content`（中和可能的 1fr 行高）+ 直接子项 `align-self: start`。
 *     标记只在筛选激活时为 1，关闭筛选恢复原生布局。
 *   · gridFromCards 从 findGridContainer 抽出（复用已扫描的 cards，避免每轮筛选二次扫描）；
 *     单卡页面退回卡片直接父节点打标。
 *
 * ===== 2026-11-01 v1.8.1b：以 app/4348910 真机 e2e 修出的两个猎取链路缺陷 =====
 *   · ①URL 归一化竞速：Steam 的 React Router 会在 hydration 前后 replaceState 归一化 URL，
 *     触发 checkUrlChange；旧版在此**取消**挂着的猎取确认定时器 → 跳页与否取决于
 *     「归一化 vs 1.2s 延迟」的竞速。修复：切页只重置导航锁与状态文案，不取消定时器
 *     （confirm 触发时重读当前 URL/DOM，对 URL 变化天然免疫）。
 *   · ②假导航：assign 后「URL 已改、文档未重载」——旧文档带着新 URL 继续存活，一切看似
 *     死掉（很可能就是用户「整页灰掉未响应」的机制之一）。修复：navigateTo 发起跳转后
 *     挂一个 3 秒哨兵，正常导航会销毁文档（定时器永不执行）；3 秒后文档还活着 →
 *     强制 location.replace 完成跳转。对原生排序 / 每页条数切换同样生效。
 *   · ③远征状态 sessionStorage → localStorage：e2e 实测假导航环境下 sessionStorage 写入
 *     **跨文档全部丢失**（每个新文档读到 null → hops 永远从 0 重计 → 无限假导航循环），
 *     localStorage 无此问题。applyPerPageDefault 的循环保险一并迁移。
 *   · ④排程看门狗：确认定时器排程 15s 仍未触发（后台节流等）→ 重新排程，
 *     confirm 触发时重读全部状态，重复排程无副作用。
 *   · 测试：test/e2e-4348910-starhunt.mjs（apphub 布局 + 浏览页猎取全链路，含深页码
 *     强制 0 命中场景）与 test/probe-hunt-churn.mjs（文档切换/状态存续观察）。
 *
 * ===== 2026-11-01 v1.8.2：瀑布流看图浮窗「显示的是上一次的图」修复 =====
 *   · 用户反馈：点开的看图浮窗与实际点击的缩略图不是同一张 —— 总是显示上一次
 *     看过的（缓存的）图；即"未加载成功之前使用了上次的缓存图片"。
 *   · 根因（旧版 wfRenderViewer）：换图只做 `img.src = item.full`（原图）——
 *     原图要几秒才下载解码完，期间 `<img>` 一直显示上一次的图；
 *     且定位用 `images.indexOf(item)`（对象身份），一旦失效返回 -1 时渲染函数
 *     直接 return —— 查看器**保留上一次的图片与标题**（陈旧渲染，极具迷惑性）。
 *   · 修复三件套：
 *       ①预览图先行 —— 先 `img.src = item.preview`（所点条目自己的缩略图，浏览器
 *         已缓存、秒出、必然是同一张），原图后台解码就绪后凭令牌静默升级；
 *       ②换图令牌（wfState.viewToken）—— 每次渲染自增，慢原图的迟到 onload 与
 *         令牌不符 → 直接丢弃，绝不用旧解码结果覆盖后点的图；
 *       ③条目定位兜底 wfFindImageIndex —— 对象身份 → id → full/preview/url →
 *         title 逐级匹配；仍找不到则**清空查看器**（移除 src + 提示文案），
 *         绝不保留上一次的渲染。
 *
 * ===== 2026-11-01 v1.8.3：移除页内客户端排序（布局损坏，收益不敌代价） =====
 *   · 用户实测：物品页用面板排序后卡片挤成两列窄条；回到游戏工坊主页，
 *     「物品 · 过去 1 周」分区直接空白，原始页面报废、只能整页刷新。
 *   · 根因：新版工坊是 React SPA，网格子节点由 React 拥有。客户端排序用
 *     appendChild 把卡片在真实 DOM 里重排 → React 虚拟树与真实 DOM 顺序失配；
 *     此后**任何一次** React 更新（切页/刷新/筛选联动）做 reconciliation 都会
 *     按自己记住的顺序增删节点 → 错位、丢失、重复。这不是偶发 bug，是方案级冲突。
 *   · 利弊分析：排序收益本来就小 —— 只能排「当前页已加载的几十条」而非全量，
 *     且服务端「原生排序」（最受好评/最新更新/最热门，跨页生效）已覆盖真实需求。
 *     结论：移除，零损失。
 *   · 处置：删除 applyClientSort 与面板「排序/方向」两行；排序统一走「原生排序」。
 *     保留且不受影响：星级筛选 / 最低票数（display:none 方式，不碰 React 子节点
 *     结构，安全）、原生排序、看 5★、跨页聚合、星级猎取。
 *   · 遗留 sortKey/sortDesc 设置字段不再被读取；老用户旧设置无需迁移即自动失效。
 *
 * 纯逻辑（parse / sort / format / query 构造）与 DOM 增强严格分离，
 * 纯逻辑通过 window.__SWE_TEST_HOOKS__ 暴露给单测。
 */

(function (global) {
    'use strict';

    const VERSION = '1.8.3';
    const PREFIX = 'swe';
    const API_URL = 'https://api.steampowered.com/ISteamRemoteStorage/GetPublishedFileDetails/v1/';

    // 批量上限实测 200 稳定，再大未验证，故取 200
    const API_BATCH_MAX = 200;
    // 卡片数据增强的合并窗口：攒够 8 张或等 200ms 就发一次，避免每张卡一个请求
    const CARD_BATCH_SIZE = 8;
    const CARD_BATCH_WAIT_MS = 200;
    // 详情缓存 TTL
    const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
    // 「最近更新」高亮阈值（天）
    const RECENT_DAYS = 7;

    // ============================================================
    // 第 1 层：纯逻辑（可单测，不触碰 DOM / GM API）
    // ============================================================

    /**
     * 从 filedetails 链接里取条目 id。
     * 兼容 ?id=123 与 /filedetails/?id=123&... 两种形态。
     */
    function parseFileIdFromHref(href) {
        if (!href || typeof href !== 'string') return '';
        const m = href.match(/[?&]id=(\d+)/);
        return m ? m[1] : '';
    }

    /**
     * 从条目链接里取 appid。
     * 形如 /sharedfiles/filedetails/?id=123 本身不含 appid，
     * 但 /myworkshopfiles/?appid=440 这类创作者链接含，故一并支持。
     */
    function parseAppIdFromHref(href) {
        if (!href || typeof href !== 'string') return '';
        const m = href.match(/[?&]appid=(\d+)/);
        return m ? m[1] : '';
    }

    /**
     * 解析卡片里的星级评分。
     * 新版 UI 用 5 个 SVG 表示：SVGIcon_Star_Filled（实心）/ SVGIcon_Star_Unfilled（空心）。
     * 半星用含 Half 的类名（若 Valve 后续启用）。
     * @returns {{filled:number, half:boolean, max:number, score:number}} score 为 0..max
     */
    function parseStarRating(cardEl) {
        const res = { filled: 0, half: false, max: 0, score: 0 };
        if (!cardEl || typeof cardEl.querySelectorAll !== 'function') return res;
        const svgs = cardEl.querySelectorAll('svg[class*="Star"]');
        if (!svgs.length) return res;
        let filled = 0, half = false;
        for (const svg of svgs) {
            const cls = (svg.getAttribute('class') || '');
            if (/Star_Half/i.test(cls)) half = true;
            else if (/Star_Filled/i.test(cls)) filled++;
        }
        res.filled = filled;
        res.half = half;
        res.max = svgs.length;
        res.score = filled + (half ? 0.5 : 0);
        return res;
    }

    /** 星级筛选候选（'all' 为关闭；'rated' 隐藏「评分不足」） */
    const STAR_FILTER_OPTIONS = [
        { key: 'all', label: '全部' },
        { key: 'rated', label: '仅已评分' },
        { key: '3', label: '≥3 星' },
        { key: '4', label: '≥4 星' },
        { key: '5', label: '仅 5 星' }
    ];

    /**
     * 读取浏览页内嵌数据里的星级 / 票数。
     *
     * 每条 `workshop_browse` 结果带 `star_rating`（0–5，**-1 = 评分不足**）与
     * `total_votes` —— 这两个字段 GetPublishedFileDetails 拿不到（`includevotes` 不生效），
     * 只能从页面自身的 React Query 数据里读。
     *
     * 2026-10-30 实测两个来源（按可靠性排序）：
     *   1. `window.SSR.renderContext.queryData`（JSON 字符串）→ `queries` →
     *      `queryKey[0] === 'workshop_browse'` → `state.data.results`。
     *      **hydrate 之后只有这份**：`<script id="valve-ssr-data">` 已被框架消费并移除
     *      （实测 `document.querySelectorAll('script[type=application/json]')` 为空）。
     *   2. `<script type="application/json" id="valve-ssr-data">`（原始 HTML / 未 hydrate）。
     *
     * 结构是「JSON 里套 JSON 字符串」，所以按通用递归找
     * 「同时含 publishedfileid 与 star_rating 的对象」，不绑定具体路径。
     *
     * @param {Document} doc
     * @param {Window} [win] 页面 window（油猴沙箱下传 unsafeWindow）
     * @returns {Map<string, {star:number, totalVotes:number|null}>}
     */
    function readSsrStarData(doc, win) {
        const map = new Map();
        const roots = [];
        // 来源 1：hydrate 后的 React Query 快照（window.SSR.renderContext.queryData）
        const w = win || (doc && doc.defaultView) || null;
        try {
            const qd = w && w.SSR && w.SSR.renderContext && w.SSR.renderContext.queryData;
            if (qd) roots.push(qd);
        } catch (_) {}
        // 来源 2：未被消费的 SSR script 标签
        let el = null;
        try { el = doc && doc.querySelector ? doc.querySelector('script#valve-ssr-data') : null; } catch (_) {}
        if (el) {
            try { roots.push(JSON.parse(el.textContent || '{}')); } catch (_) {}
        }
        if (!roots.length) return map;
        const seen = new Set();   // 同一段 JSON 字符串只解析一次，防重复/环路
        // v1.8.0：异常大的 SSR 快照也不许拖死主线程 —— 访问节点数硬上限
        const MAX_SSR_NODES = 20000;
        let visits = 0;
        const stack = roots.map(node => ({ node, depth: 0 }));
        while (stack.length) {
            if (++visits > MAX_SSR_NODES) break;
            const cur = stack.pop();
            const node = cur.node;
            if (node === null || typeof node === 'undefined') continue;
            if (typeof node === 'string') {
                if (cur.depth > 12 || node.length < 3) continue;
                const ch = node.charAt(0);
                if ((ch !== '{' && ch !== '[') || seen.has(node)) continue;
                seen.add(node);
                try { stack.push({ node: JSON.parse(node), depth: cur.depth + 1 }); } catch (_) {}
                continue;
            }
            if (typeof node !== 'object') continue;
            // 对象/数组同样限深：真实结构 ≤10 层，防御异常深嵌套拖垮遍历
            // （JSON.parse 产物无环，这里只防「深」，不防「环」）
            if (cur.depth > 24) continue;
            if (Array.isArray(node)) {
                for (const x of node) stack.push({ node: x, depth: cur.depth + 1 });
                continue;
            }
            if (typeof node.publishedfileid !== 'undefined' && typeof node.star_rating !== 'undefined') {
                map.set(String(node.publishedfileid), {
                    star: toNum(node.star_rating),
                    totalVotes: (typeof node.total_votes === 'undefined' || node.total_votes === null)
                        ? null : toNum(node.total_votes)
                });
            }
            for (const k in node) stack.push({ node: node[k], depth: cur.depth + 1 });
        }
        return map;
    }

    /**
     * 汇总一张卡片的评分信息。
     * 星级以 DOM 为准（SPA 内翻页后 SSR 数据会过期），票数只能从 SSR 数据取；
     * SSR 里同时有 star_rating 时用它判「评分不足（-1）」，因为 DOM 里
     * 「评分不足」与「0 星」都表现为 5 颗空心星，分不开。
     * 例外：DOM 已画出实心星（score>0）时，Valve 对 -1 项不画星（实测），
     * 所以此时快照的 -1/0 只能是过期数据，不得推翻 DOM 的「已评分」。
     *
     * @param {{id:string, rating?:{score:number,max:number}}} card
     * @param {Map<string, {star:number, totalVotes:number|null}>} [ssrMap]
     * @returns {{score:number, max:number, votes:number|null, rated:boolean}}
     */
    function ratingInfo(card, ssrMap) {
        const r = (card && card.rating) || { score: 0, max: 0 };
        const max = toNum(r.max);
        let score = toNum(r.score);
        let rec = null;
        if (ssrMap && card && typeof card.id !== 'undefined') rec = ssrMap.get(String(card.id)) || null;
        if (!score && rec && rec.star > 0) score = rec.star;   // DOM 还没渲染时用 SSR 兜底
        let rated;
        if (rec) rated = rec.star > 0 || score > 0;   // DOM 实心星优先于过期快照的 -1/0
        else rated = max > 0 && score > 0;
        const votes = rec && rec.totalVotes !== null && typeof rec.totalVotes !== 'undefined'
            ? toNum(rec.totalVotes) : null;
        return { score, max, votes, rated };
    }

    /**
     * 星级筛选判定（纯函数）。
     * @param {{score:number,max:number,rated:boolean,votes:number|null}} item
     * @param {{starFilter?:string, minVotes?:number}} opts
     * @returns {boolean} true = 保留
     */
    function passStarFilter(item, opts) {
        const o = opts || {};
        const it = item || {};
        const filter = o.starFilter || 'all';
        const minVotes = toNum(o.minVotes);
        // 没有星级控件（如合集页卡片）→ 评分未知，一律保留，别把整页误清空
        if (!toNum(it.max)) return true;
        // 票数未知（SSR 数据过期 / 客户端翻页后的新卡片）→ 不参与票数筛选
        if (minVotes > 0 && it.votes !== null && typeof it.votes !== 'undefined' && toNum(it.votes) < minVotes) {
            return false;
        }
        if (filter === 'all') return true;
        if (filter === 'rated') return !!it.rated;
        const min = toNum(filter);
        if (!min) return true;
        return !!it.rated && toNum(it.score) >= min;
    }

    /**
     * 构造 GetPublishedFileDetails 的 POST body。
     * @param {string[]} ids
     */
    function buildDetailQuery(ids) {
        const list = (ids || []).filter(Boolean).map(String);
        if (!list.length) return '';
        const parts = ['itemcount=' + list.length];
        list.forEach((id, i) => parts.push('publishedfileids[' + i + ']=' + encodeURIComponent(id)));
        return parts.join('&');
    }

    /**
     * 解析 GetPublishedFileDetails 响应，取出精简条目对象。
     * @returns {Object<string, object>} 以 id 为键
     */
    function parseDetailsResponse(json) {
        const out = {};
        if (!json || typeof json !== 'object') return out;
        const root = json.response || json;
        const list = root.publishedfiledetails || root.publishedfiledetails || [];
        if (!Array.isArray(list)) return out;
        for (const d of list) {
            if (!d || !d.publishedfileid) continue;
            out[String(d.publishedfileid)] = {
                id: String(d.publishedfileid),
                title: d.title || '',
                description: d.description || '',
                creator: d.creator || '',
                appid: String(d.consumer_app_id || d.creator_app_id || ''),
                fileSize: toNum(d.file_size),
                previewUrl: d.preview_url || '',
                timeCreated: toNum(d.time_created),
                timeUpdated: toNum(d.time_updated),
                subscriptions: toNum(d.subscriptions),
                favorited: toNum(d.favorited),
                lifetimeSubscriptions: toNum(d.lifetime_subscriptions),
                lifetimeFavorited: toNum(d.lifetime_favorited),
                views: toNum(d.views),
                banned: toNum(d.banned),
                tags: Array.isArray(d.tags)
                    ? d.tags.map(t => (typeof t === 'string' ? t : t && t.tag)).filter(Boolean)
                    : []
            };
        }
        return out;
    }

    function toNum(v) {
        const n = Number(v);
        return Number.isFinite(n) ? n : 0;
    }

    /**
     * 合并缓存与新拉取的数据：新数据优先，但保留缓存里的额外字段。
     */
    function mergeDetails(cached, fresh) {
        const out = Object.assign({}, cached || {});
        for (const k of Object.keys(fresh || {})) {
            out[k] = Object.assign({}, out[k] || {}, fresh[k]);
        }
        return out;
    }

    /**
     * 找出缓存中已过期的 id。
     * @param {Object} cache  {id: {..., fetchedAt:number}}
     * @param {number} now
     * @param {number} ttl
     */
    function pickStaleIds(cache, now, ttl) {
        const stale = [];
        for (const id of Object.keys(cache || {})) {
            const rec = cache[id];
            if (!rec) { stale.push(id); continue; }
            const at = toNum(rec.fetchedAt);
            if (!at || (now - at) > ttl) stale.push(id);
        }
        return stale;
    }

    /**
     * 高级排序。对当前页内的条目按指定指标重排。
     * @param {Array<{id:string, detail:object|null, rating?:number, votes?:number|null}>} entries
     * @param {string} key subs|fav|size|updated|views|title|rating
     * @param {boolean} desc
     */
    function sortEntries(entries, key, desc) {
        const arr = (entries || []).slice();
        const dir = desc === false ? 1 : -1;
        // 星级排序：主键星级，同星按票数（票数少的高星不可信，需排在后面），最后按 id 稳定
        if (key === 'rating') {
            arr.sort((a, b) => {
                const ra = toNum(a && a.rating), rb = toNum(b && b.rating);
                if (ra !== rb) return (ra > rb ? 1 : -1) * dir;
                const va = toNum(a && a.votes), vb = toNum(b && b.votes);
                if (va !== vb) return (va > vb ? 1 : -1) * dir;
                return String(a && a.id).localeCompare(String(b && b.id));
            });
            return arr;
        }
        const val = (e) => {
            const d = e.detail || {};
            switch (key) {
                case 'subs': return toNum(d.subscriptions) + toNum(d.lifetimeSubscriptions);
                case 'size': return toNum(d.fileSize);
                case 'updated': return toNum(d.timeUpdated);
                case 'views': return toNum(d.views);
                case 'fav': return toNum(d.favorited) + toNum(d.lifetimeFavorited);
                case 'title': return String(d.title || e.title || '');
                default: return 0;
            }
        };
        arr.sort((a, b) => {
            const va = val(a), vb = val(b);
            if (va === vb) return String(a.id).localeCompare(String(b.id));
            return (va > vb ? 1 : -1) * dir;
        });
        return arr;
    }

    /** 字节数人类可读 */
    function formatBytes(n) {
        const v = toNum(n);
        if (v <= 0) return '—';
        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
        let i = 0, x = v;
        while (x >= 1024 && i < units.length - 1) { x /= 1024; i++; }
        return (i === 0 ? String(Math.round(x)) : x.toFixed(x < 10 ? 2 : 1)) + ' ' + units[i];
    }

    /** 大数字缩写：1234 → 1.2k */
    function formatCount(n) {
        const v = toNum(n);
        if (v < 1000) return String(Math.round(v));
        if (v < 1000000) return (v / 1000).toFixed(v < 10000 ? 1 : 0).replace(/\.0$/, '') + 'k';
        return (v / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
    }

    /** 时间戳 → YYYY-MM-DD HH:mm（本地时区） */
    function formatDateTime(ts) {
        const v = toNum(ts);
        if (!v) return '—';
        const d = new Date(v * 1000);
        const p = (n) => String(n).padStart(2, '0');
        return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) +
            ' ' + p(d.getHours()) + ':' + p(d.getMinutes());
    }

    /** 相对时间：3 天前 / 2 个月前 */
    function formatRelative(ts, now) {
        const v = toNum(ts);
        if (!v) return '—';
        const cur = toNum(now) || Math.floor(Date.now() / 1000);
        let diff = cur - v;
        if (diff < 0) diff = 0;
        const day = 86400;
        if (diff < 3600) return Math.max(1, Math.round(diff / 60)) + ' 分钟前';
        if (diff < day) return Math.round(diff / 3600) + ' 小时前';
        if (diff < 30 * day) return Math.round(diff / day) + ' 天前';
        if (diff < 365 * day) return Math.round(diff / (30 * day)) + ' 个月前';
        return Math.round(diff / (365 * day)) + ' 年前';
    }

    /** 是否在最近 N 天内更新过 */
    function isRecentlyUpdated(ts, now, days) {
        const v = toNum(ts);
        if (!v) return false;
        const cur = toNum(now) || Math.floor(Date.now() / 1000);
        return (cur - v) <= (days || RECENT_DAYS) * 86400;
    }

    /**
     * 把 Steam 预览图 URL 换成更高分辨率版本。
     *
     * 只去掉尺寸限制参数 imw / imh，保留 ima / impolicy / imcolor / letterbox 的
     * 裁剪策略（保留裁剪策略可避免方图容器里出现变形或留白差异）。
     *
     * ⚠️ 必须用 URL 解析，不能用正则硬删参数：
     *   正则删 `?ima=fit` 会把 `?` 一起吃掉，剩余的 `&imcolor=...` 就粘进了 pathname，
     *   变成 `.../HASH/&imcolor=%23000000` → 实测 **404** → 浏览器显示破图占位。
     *   （2026-10-28 实测：原 322px 缩略 35KB → 去尺寸后 156KB；错误形态 404）
     */
    function upgradePreviewUrl(url) {
        if (!url || typeof url !== 'string') return '';
        const q = url.indexOf('?');
        if (q === -1) return url;
        const base = url.slice(0, q);
        const query = url.slice(q + 1);
        const kept = query.split('&').filter((pair) => {
            if (!pair) return false;
            const key = pair.split('=')[0].toLowerCase();
            return key !== 'imw' && key !== 'imh';
        });
        return kept.length ? base + '?' + kept.join('&') : base;
    }

    /**
     * 构造带标签筛选的浏览页 URL。
     */
    function buildBrowseUrl(base, appid, tag) {
        const u = new URL(base);
        if (appid) u.searchParams.set('appid', String(appid));
        if (tag) {
            u.searchParams.delete('requiredtags[]');
            u.searchParams.append('requiredtags[]', String(tag));
        }
        return u.toString();
    }

    /** 解析 URL 上的分页 / 排序参数 */
    function readBrowseParams(url) {
        const out = { appid: '', p: 1, numPerPage: 30, browsesort: '', section: '', days: '', searchtext: '' };
        try {
            const u = new URL(url, 'https://steamcommunity.com');
            out.appid = u.searchParams.get('appid') || '';
            out.p = toNum(u.searchParams.get('p')) || 1;
            out.numPerPage = toNum(u.searchParams.get('num_per_page')) || 30;
            out.browsesort = u.searchParams.get('browsesort') || '';
            out.section = u.searchParams.get('section') || '';
            out.days = u.searchParams.get('days') || '';
            out.searchtext = u.searchParams.get('searchtext') || '';
        } catch (_) {}
        return out;
    }

    /**
     * 构造「原生排序」跳转 URL：服务端排序，**跨页生效**。
     *
     * 2026-10-30 实测（TF2）：
     *   · `toprated`   → 有效，p1/p2 全 5★，p10 起夹杂 4★（≈5★ 优先，不保证纯净）
     *   · `lastupdated`→ 有效，按更新时间倒序
     *   · `trend`      → 默认排序（不带 browsesort 时也是它）
     *   · `newest` / `mostsubscribed` / `mostdiscussed` → **服务端归一成 trend**（失效，故不提供）
     *
     * 只改 `browsesort`、清掉 `p`（回第 1 页），其余参数（appid / section / days /
     * searchtext / requiredtags[] / browsefilter…）原样保留。
     *
     * @param {string} base 当前 URL
     * @param {string} sortKey toprated | lastupdated | trend
     * @returns {string} 新 URL；参数非法时返回 ''
     */
    function buildNativeSortUrl(base, sortKey) {
        if (!base || !sortKey) return '';
        let u;
        try { u = new URL(base, 'https://steamcommunity.com'); } catch (_) { return ''; }
        u.searchParams.set('browsesort', String(sortKey));
        u.searchParams.delete('p');
        return u.toString();
    }

    /**
     * 服务端真正支持的每页条数白名单。
     *
     * 2026-10-30 实测：服务端只认 10 / 15 / 30 / 50，其余值（100、200、40、25…）
     * 一律被归一成默认的 30。客户端 SPA 用的也是同一份白名单
     * （chunk C-Bheh1z.js：`rgNumPerPageOptions ?? [10,15,30,50]`）。
     *
     * 所以「每页 100 条」**不能**靠 URL 参数实现，只能客户端聚合（见 buildAggregatePlan）。
     */
    const SERVER_PAGE_SIZES = [10, 15, 30, 50];

    /** 分页条数候选（UI 可选值） */
    const PAGE_SIZES = [10, 15, 30, 50, 100, 200];

    /** 聚合时服务端每页拉多少条（= 白名单最大值，一次请求尽量多拿） */
    const AGGREGATE_FETCH_SIZE = 50;

    /**
     * 计算「每页 N 条」的实现方案。
     *
     * N ≤ 50：服务端原生支持，直接写 URL 参数 `num_per_page=N`，
     *          由 Steam 自己分页（页码、总数、筛选联动全都正确）。
     *
     * N > 50 ：服务端不接受，必须客户端聚合 —— 把连续的多个服务端页
     *          （每页 50 条）拉下来合并渲染。
     *          例：N=100 → 抓 p、p+1 两页共 100 条；N=200 → 抓 p、p+1、p+2、p+3 四页。
     *
     * @param {number} desired 期望每页显示多少条
     * @returns {{mode:'server'|'aggregate', serverSize:number, pages:number, total:number}}
     */
    function buildAggregatePlan(desired) {
        const n = toNum(desired) || 0;
        if (n <= 0) {
            return { mode: 'server', serverSize: 30, pages: 1, total: 0 };
        }
        if (n <= AGGREGATE_FETCH_SIZE) {
            // 白名单内的值走服务端原生分页
            const size = SERVER_PAGE_SIZES.indexOf(n) >= 0 ? n : 30;
            return { mode: 'server', serverSize: size, pages: 1, total: size };
        }
        // 超过服务端上限：按 50 条/页抓多页
        const pages = Math.ceil(n / AGGREGATE_FETCH_SIZE);
        return {
            mode: 'aggregate',
            serverSize: AGGREGATE_FETCH_SIZE,
            pages: pages,
            total: pages * AGGREGATE_FETCH_SIZE
        };
    }

    /**
     * 构造聚合模式下第 idx 页（0 基）的抓取 URL。
     * 继承当前 URL 的全部查询参数，只改 p 与 num_per_page。
     *
     * @param {string} base 当前 URL
     * @param {number} idx 0 基页序（0 = 起始页）
     * @param {number} startPage 当前 URL 的 p（1 基）
     * @param {number} fetchSize 每次抓取的条数（=50）
     * @returns {string}
     */
    function buildAggregatePageUrl(base, idx, startPage, fetchSize) {
        let u;
        try { u = new URL(base, 'https://steamcommunity.com'); } catch (_) { return ''; }
        u.searchParams.set('num_per_page', String(fetchSize || AGGREGATE_FETCH_SIZE));
        u.searchParams.set('p', String((toNum(startPage) || 1) + (toNum(idx) || 0)));
        return u.toString();
    }

    /**
     * 从浏览页 HTML 中提取条目 id 列表。
     *
     * 聚合模式要抓多个服务端页，每一页都是 SSR 的完整 HTML，
     * 其中的 filedetails 链接即该页的条目（顺序 = 服务端排序顺序）。
     *
     * @param {string} html
     * @returns {string[]} 顺序去重后的条目 id
     */
    function parseBrowseIdsFromHtml(html) {
        const out = [];
        const seen = new Set();
        if (!html) return out;
        const re = /sharedfiles\/filedetails\/\?id=(\d+)/g;
        let m;
        while ((m = re.exec(html)) !== null) {
            const id = m[1];
            if (seen.has(id)) continue;
            seen.add(id);
            out.push(id);
        }
        return out;
    }

    /**
     * 解析 SSR 内嵌数据里的 workshop_browse 结果集，取出条目 id（顺序 = 服务端顺序）。
     *
     * 比 parseBrowseIdsFromHtml 更精确：SSR 里 `results` 数组就是真正的本页条目，
     * 而 HTML 里还混着导航栏「您的项目」等其它区域的链接。
     *
     * @param {string} html 页面 HTML
     * @returns {string[]}
     */
    function parseSsrBrowseIds(html) {
        const m = /<script[^>]*id="valve-ssr-data"[^>]*>([\s\S]*?)<\/script>/.exec(html || '');
        if (!m) return [];
        let data;
        try { data = JSON.parse(m[1]); } catch (_) { return []; }
        const queries = (data && data.renderContext && data.renderContext.queryData) || null;
        let list = queries;
        if (typeof list === 'string') {
            try { list = JSON.parse(list); } catch (_) { return []; }
        }
        if (!list || !Array.isArray(list.queries)) return [];
        for (const q of list.queries) {
            if (!q || !q.queryKey || q.queryKey[0] !== 'workshop_browse') continue;
            const results = q.state && q.state.data && q.state.data.results;
            if (!Array.isArray(results)) continue;
            const out = [];
            const seen = new Set();
            for (const r of results) {
                const id = r && r.publishedfileid ? String(r.publishedfileid) : '';
                if (!id || seen.has(id)) continue;
                seen.add(id);
                out.push(id);
            }
            if (out.length) return out;
        }
        return [];
    }

    /**
     * 从 SSR 数据里取出 workshop_browse 的分页元信息。
     *
     * @param {string} html
     * @returns {{totalCount:number, totalPages:number, currentPage:number, ids:string[]}}
     */
    function parseSsrBrowseMeta(html) {
        const out = { totalCount: 0, totalPages: 0, currentPage: 0, ids: [] };
        const m = /<script[^>]*id="valve-ssr-data"[^>]*>([\s\S]*?)<\/script>/.exec(html || '');
        if (!m) return out;
        let data;
        try { data = JSON.parse(m[1]); } catch (_) { return out; }
        let qd = data && data.renderContext && data.renderContext.queryData;
        if (typeof qd === 'string') {
            try { qd = JSON.parse(qd); } catch (_) { return out; }
        }
        if (!qd || !Array.isArray(qd.queries)) return out;
        for (const q of qd.queries) {
            if (!q || !q.queryKey || q.queryKey[0] !== 'workshop_browse') continue;
            const d = (q.state && q.state.data) || {};
            out.totalCount = toNum(d.total_count) || 0;
            out.totalPages = toNum(d.total_pages) || 0;
            out.currentPage = toNum(d.current_page) || 0;
            const seen = new Set();
            for (const r of (d.results || [])) {
                const id = r && r.publishedfileid ? String(r.publishedfileid) : '';
                if (!id || seen.has(id)) continue;
                seen.add(id);
                out.ids.push(id);
            }
            break;
        }
        return out;
    }

    /**
     * 抓取一个服务端分页，返回该页的条目 id、分页元信息与星级快照。
     *
     * 用同源 fetch（带 cookie），直接拿服务端渲染的完整 HTML，
     * 从 SSR 脚本里读出 results —— 与浏览器渲染该页得到的数据完全一致。
     *
     * @param {string} url
     * @returns {Promise<{ok:boolean, ids:string[], meta:object, starMap?:Map, html?:string, error?:string}>}
     */
    async function fetchBrowsePage(url) {
        try {
            const res = await global.fetch(url, { credentials: 'include', cache: 'no-store' });
            if (!res.ok) return { ok: false, ids: [], meta: {}, error: 'HTTP ' + res.status };
            const html = await res.text();
            const meta = parseSsrBrowseMeta(html);
            return {
                ok: true,
                ids: meta.ids,
                meta: meta,
                starMap: readSsrStarDataFromHtml(html),
                html: html
            };
        } catch (e) {
            return { ok: false, ids: [], meta: {}, error: (e && e.message) || '网络错误' };
        }
    }

    /**
     * 从一段 HTML 里提取 workshop_browse 结果的星级/票数。
     *
     * 复用 readSsrStarData 的通用遍历逻辑，只是把根换成「这段 HTML 的 SSR 数据」。
     *
     * @param {string} html
     * @returns {Map<string, {star:number, totalVotes:number|null}>}
     */
    function readSsrStarDataFromHtml(html) {
        const map = new Map();
        const m = /<script[^>]*id="valve-ssr-data"[^>]*>([\s\S]*?)<\/script>/.exec(html || '');
        if (!m) return map;
        let data;
        try { data = JSON.parse(m[1]); } catch (_) { return map; }
        const stack = [{ node: data, depth: 0 }];
        const seen = new Set();
        // v1.8.0：与 readSsrStarData 相同的节点数硬上限
        const MAX_SSR_NODES = 20000;
        let visits = 0;
        while (stack.length) {
            if (++visits > MAX_SSR_NODES) break;
            const cur = stack.pop();
            const node = cur.node;
            if (node === null || typeof node === 'undefined') continue;
            if (typeof node === 'string') {
                if (cur.depth > 12 || node.length < 3) continue;
                const ch = node.charAt(0);
                if ((ch !== '{' && ch !== '[') || seen.has(node)) continue;
                seen.add(node);
                try { stack.push({ node: JSON.parse(node), depth: cur.depth + 1 }); } catch (_) {}
                continue;
            }
            if (typeof node !== 'object') continue;
            if (cur.depth > 24) continue;
            if (Array.isArray(node)) {
                for (const x of node) stack.push({ node: x, depth: cur.depth + 1 });
                continue;
            }
            if (typeof node.publishedfileid !== 'undefined' && typeof node.star_rating !== 'undefined') {
                map.set(String(node.publishedfileid), {
                    star: toNum(node.star_rating),
                    totalVotes: (typeof node.total_votes === 'undefined' || node.total_votes === null)
                        ? null : toNum(node.total_votes)
                });
            }
            for (const k in node) stack.push({ node: node[k], depth: cur.depth + 1 });
        }
        return map;
    }


    /**
     * 原生排序候选（只收录 2026-10-30 实测有效的键）。
     * '' = 保持当前 URL 的排序，不跳转。
     */
    const NATIVE_SORT_OPTIONS = [
        { key: '', label: '保持当前' },
        { key: 'toprated', label: '最受好评（≈5★ 优先）' },
        { key: 'lastupdated', label: '最新更新' },
        { key: 'trend', label: '最热门（默认）' }
    ];

    /** 高级排序选项 */
    const SORT_OPTIONS = [
        { key: 'native', label: 'Steam 默认' },
        { key: 'rating', label: '星级（高→低）' },
        { key: 'subs', label: '订阅数' },
        { key: 'fav', label: '收藏数' },
        { key: 'views', label: '浏览量' },
        { key: 'size', label: '文件大小' },
        { key: 'updated', label: '最近更新' }
    ];

    // ============================================================
    // 第 1.5 层：收藏夹 / 导出 / 备份 的纯逻辑
    // （参考 aggs/Steam Workshop Mod Tool.js 的 SteamCMD 与列表管理思路，
    //   以及 aggs/Steam-Workshop-optimization.js 的订阅备份思路，按本插件
    //   「零依赖 / 公开接口 / 稳定锚点」的约定重新实现）
    // ============================================================

    /** 导出格式候选 */
    const EXPORT_MODES = [
        { key: 'ids', label: 'ID 列表' },
        { key: 'links', label: '详情页链接' },
        { key: 'cmds', label: 'SteamCMD 命令' },
        { key: 'names', label: '名称列表' },
        { key: 'json', label: 'JSON（含元数据）' }
    ];

    /**
     * 构造单条 SteamCMD 下载命令。
     * appid 缺失时用 <APPID> 占位（沿用 aggs/Steam Workshop Mod Tool.js 的约定，
     * 提示用户手动替换——SteamCMD 的 workshop_download_item 必须带 appid）。
     */
    function buildSteamCmdCommand(appid, id) {
        if (!id) return '';
        return 'workshop_download_item ' + (appid || '<APPID>') + ' ' + id;
    }

    /** 批量构造 SteamCMD 命令（每行一条） */
    function buildSteamCmdBatch(appid, ids) {
        const list = (ids || []).filter(Boolean).map(String);
        if (!list.length) return '';
        const app = appid || '<APPID>';
        return list.map(id => 'workshop_download_item ' + app + ' ' + id).join('\n');
    }

    /**
     * 合并收藏条目：existing 的 timeAdded（首次收藏时间）必须保留，
     * 其余字段以 incoming 为准刷新（标题/更新时间会随详情数据变化）。
     */
    function mergeFavEntry(existing, incoming) {
        const base = Object.assign({}, existing || {}, incoming || {});
        base.timeAdded = toNum(existing && existing.timeAdded) || toNum(incoming && incoming.timeAdded) ||
            Math.floor(Date.now() / 1000);
        base.id = String(base.id || (existing && existing.id) || (incoming && incoming.id) || '');
        return base;
    }

    /**
     * 判断收藏条目是否有更新。
     * 基线是收藏/上次检查时的 time_updated 快照（timeUpdatedAt）；
     * 没有基线（老数据、快照为 0）时无法判定，返回 false —— 宁可漏报不可误报。
     */
    function hasUpdate(record, detail) {
        if (!record || !detail) return false;
        const snap = toNum(record.timeUpdatedAt);
        if (!snap) return false;
        return toNum(detail.timeUpdated) > snap;
    }

    /**
     * 从「我的订阅」页 HTML 里提取全部条目 id。
     * 无论页面走经典渲染还是新 SPA 的 SSR 输出，filedetails 链接形态不变。
     * ⚠️ 必须容忍 ?id=123&l=english 这种带后续参数的形态（\?id= 已含锚点）。
     */
    function parseWorkshopItemIdsFromHtml(html) {
        const out = [];
        const seen = new Set();
        const re = /\/sharedfiles\/filedetails\/\?id=(\d+)/g;
        const s = String(html || '');
        let m;
        while ((m = re.exec(s))) {
            if (!seen.has(m[1])) { seen.add(m[1]); out.push(m[1]); }
        }
        return out;
    }

    /** 构造条目详情页链接 */
    function buildItemLink(id) {
        return 'https://steamcommunity.com/sharedfiles/filedetails/?id=' + id;
    }

    /**
     * 订阅备份的 JSON 文本（与通用导出的 type 不同，便于导入时识别来源）。
     */
    function buildSubscriptionBackupJson(entries) {
        const list = (entries || []).filter(e => e && e.id);
        return JSON.stringify({
            type: 'swe-subscriptions',
            version: 1,
            exportedAt: new Date().toISOString(),
            count: list.length,
            items: list
        }, null, 2);
    }

    /**
     * 把条目列表导出为文本。
     * @param {'ids'|'links'|'cmds'|'names'|'json'} mode
     * @param {Array<{id, title?, appid?, timeUpdated?}>} entries
     * @param {string} fallbackAppid 缺省 appid（cmds 用）
     */
    function buildExportText(mode, entries, fallbackAppid) {
        const list = (entries || []).filter(e => e && e.id);
        if (mode === 'json') {
            return JSON.stringify({
                type: 'swe-export',
                version: 1,
                exportedAt: new Date().toISOString(),
                count: list.length,
                items: list
            }, null, 2);
        }
        const ids = list.map(e => e.id);
        switch (mode) {
            case 'ids': return ids.join('\n');
            case 'links': return ids.map(buildItemLink).join('\n');
            case 'cmds': return buildSteamCmdBatch(fallbackAppid, ids);
            case 'names': return list.map(e => e.title || e.id).join('\n');
            default: return '';
        }
    }

    /**
     * 解析订阅备份导入文本。
     * 兼容两种格式：
     *   1. 本插件导出的 JSON（{type:'swe-export', items:[...]}）—— 含元数据
     *   2. 纯 id 列表（每行/逗号分隔一个数字 id）—— 兼容其他工具的导出
     * @returns {{ok:boolean, type?:string, items?:Array, error?:string}}
     */
    function parseSubscriptionImport(text) {
        const s = String(text == null ? '' : text).trim();
        if (!s) return { ok: false, error: 'empty' };
        if (s[0] === '{' || s[0] === '[') {
            let j;
            try { j = JSON.parse(s); }
            catch (_) { return { ok: false, error: 'bad-json' }; }
            const raw = Array.isArray(j) ? j : (j && j.items);
            if (!Array.isArray(raw)) return { ok: false, error: 'no-items' };
            const items = [];
            for (const x of raw) {
                const id = x && typeof x === 'object' ? x.id : x;
                if (id && /^\d+$/.test(String(id))) {
                    items.push(typeof x === 'object' ? Object.assign({}, x, { id: String(id) }) : { id: String(id) });
                }
            }
            if (!items.length) return { ok: false, error: 'no-items' };
            return { ok: true, type: 'json', items };
        }
        const ids = s.split(/[\s,;]+/).filter(x => /^\d+$/.test(x));
        if (!ids.length) return { ok: false, error: 'no-ids' };
        return { ok: true, type: 'ids', items: ids.map(id => ({ id })) };
    }

    // ============================================================
    // 第 2 层：GM 存储封装（可降级到 localStorage）
    // ============================================================

    const gmGet = (typeof GM_getValue === 'function') ? GM_getValue : null;
    const gmSet = (typeof GM_setValue === 'function') ? GM_setValue : null;
    const gmDel = (typeof GM_deleteValue === 'function') ? GM_deleteValue : null;

    function storeGet(key, fallback) {
        try {
            if (gmGet) return gmGet(key, fallback);
        } catch (_) {}
        try {
            const raw = global.localStorage && global.localStorage.getItem(key);
            return raw == null ? fallback : JSON.parse(raw);
        } catch (_) {}
        return fallback;
    }

    function storeSet(key, value) {
        try {
            if (gmSet) { gmSet(key, value); return true; }
        } catch (_) {}
        try {
            if (global.localStorage) global.localStorage.setItem(key, JSON.stringify(value));
            return true;
        } catch (_) {}
        return false;
    }

    function storeDel(key) {
        try { if (gmDel) { gmDel(key); return true; } } catch (_) {}
        try { if (global.localStorage) global.localStorage.removeItem(key); return true; } catch (_) {}
        return false;
    }

    // ============================================================
    // 第 3 层：详情缓存
    // ============================================================

    const CACHE_KEY = PREFIX + ':details';
    const SUBS_KEY = PREFIX + ':subscribed';
    const FAV_KEY = PREFIX + ':favorites';
    const SETTINGS_KEY = PREFIX + ':settings';
    const FAVLIST_KEY = PREFIX + ':favlist';   // 本地收藏夹（书签，非 Steam 收藏）

    let detailCache = null;      // { id: {...fields, fetchedAt} }
    let subscribedSet = null;    // { id: true }
    let favoritedSet = null;     // { id: true }
    let favList = null;          // { id: {id, appid, title, timeAdded, timeUpdatedAt, hasUpdate} }
    const failedIds = new Set(); // 负缓存：本次会话内不再重试

    function loadCache() {
        if (detailCache) return detailCache;
        detailCache = storeGet(CACHE_KEY, {}) || {};
        return detailCache;
    }

    function saveCache() {
        storeSet(CACHE_KEY, detailCache || {});
    }

    function loadSubscribed() {
        if (subscribedSet) return subscribedSet;
        subscribedSet = storeGet(SUBS_KEY, {}) || {};
        return subscribedSet;
    }

    function loadFavorited() {
        if (favoritedSet) return favoritedSet;
        favoritedSet = storeGet(FAV_KEY, {}) || {};
        return favoritedSet;
    }

    function loadFavList() {
        if (favList) return favList;
        favList = storeGet(FAVLIST_KEY, {}) || {};
        return favList;
    }

    function saveFavList() {
        storeSet(FAVLIST_KEY, favList || {});
    }

    const DEFAULT_SETTINGS = {
        showCardStats: true,
        showSubscribedBadge: true,
        showRecentBadge: true,
        upgradePreview: true,
        perPage: 0,          // 0 = 沿用 Steam 默认
        sortKey: 'native',
        sortDesc: true,
        starFilter: 'all',   // 星级筛选：all / rated / 3 / 4 / 5
        minVotes: 0,         // 最低票数（0 = 不限；票数未知的条目不受影响）
        batchMode: false,
        artBatchMode: false  // 艺术作品页批量下载模式
    };

    function loadSettings() {
        return Object.assign({}, DEFAULT_SETTINGS, storeGet(SETTINGS_KEY, {}) || {});
    }

    function saveSettings(patch) {
        const s = Object.assign(loadSettings(), patch || {});
        storeSet(SETTINGS_KEY, s);
        return s;
    }

    // ============================================================
    // 第 4 层：网络层
    // ============================================================

    /**
     * 用 fetch 直连 Steam 公开接口。
     * CORS 已验证：Origin: https://steamcommunity.com → access-control-allow-origin 反射。
     *
     * 抛出的错误带 status，便于区分「限流/临时故障」与「条目确实不存在」。
     */
    async function fetchDetailsRaw(ids) {
        const body = buildDetailQuery(ids);
        if (!body) return {};
        const res = await global.fetch(API_URL, {
            method: 'POST',
            headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' },
            body,
            credentials: 'omit',
            cache: 'no-store'
        });
        if (!res.ok) {
            const err = new Error('HTTP ' + res.status);
            err.status = res.status;
            // 429 / 5xx 是限流或临时故障 —— 属「可重试」，不该把 id 拉黑
            err.transient = res.status === 429 || res.status >= 500;
            throw err;
        }
        const json = await res.json();
        return parseDetailsResponse(json);
    }

    /** GM_xmlhttpRequest 兜底（万一某天 CORS 收紧） */
    function fetchDetailsViaGm(ids) {
        return new Promise((resolve, reject) => {
            if (typeof GM_xmlhttpRequest !== 'function') { reject(new Error('no gm')); return; }
            GM_xmlhttpRequest({
                method: 'POST',
                url: API_URL,
                headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' },
                data: buildDetailQuery(ids),
                onload: (r) => {
                    try { resolve(parseDetailsResponse(JSON.parse(r.responseText))); }
                    catch (e) { reject(e); }
                },
                onerror: (e) => reject(e || new Error('gm xhr failed'))
            });
        });
    }

    /**
     * 批量取详情：先吃缓存，只对过期/缺失的 id 发请求。
     * @param {string[]} ids
     * @param {{force?:boolean}} opts
     */
    async function fetchDetails(ids, opts) {
        const cache = loadCache();
        const now = Date.now();
        const unique = [];
        const seen = new Set();
        for (const raw of ids || []) {
            const id = String(raw || '');
            if (!id || seen.has(id)) continue;
            seen.add(id);
            unique.push(id);
        }
        if (!unique.length) return {};

        const force = !!(opts && opts.force);
        const need = [];
        const out = {};
        for (const id of unique) {
            if (failedIds.has(id)) continue;
            const rec = cache[id];
            const fresh = rec && (now - toNum(rec.fetchedAt)) < CACHE_TTL_MS;
            if (!force && fresh) { out[id] = rec; continue; }
            need.push(id);
        }
        if (!need.length) return out;

        // 分批（每批 ≤200）
        const batches = [];
        for (let i = 0; i < need.length; i += API_BATCH_MAX) {
            batches.push(need.slice(i, i + API_BATCH_MAX));
        }

        for (const batch of batches) {
            let fresh = null;
            let transient = false;
            try {
                fresh = await fetchDetailsRaw(batch);
            } catch (e) {
                transient = !!(e && e.transient);
                try { fresh = await fetchDetailsViaGm(batch); }
                catch (e2) {
                    if (transient) {
                        // 限流 / 5xx：临时故障，不拉黑 id —— 留待下次访问重试
                        // （实测 Steam 接口密集访问会返回 502，若拉黑会导致整页永远无数据）
                        continue;
                    }
                    // 确定性失败：记负缓存，避免死循环重试
                    for (const id of batch) failedIds.add(id);
                    continue;
                }
            }
            const merged = mergeDetails({}, fresh);
            for (const id of Object.keys(merged)) {
                merged[id].fetchedAt = now;
                cache[id] = merged[id];
                out[id] = merged[id];
            }
            // 该批里 API 没返回的 id 视为失效（条目不存在）
            for (const id of batch) {
                if (!merged[id]) { failedIds.add(id); delete cache[id]; }
            }
        }
        saveCache();
        return out;
    }

    // ============================================================
    // 第 5 层：DOM 定位（只认稳定语义锚点）
    // ============================================================

    const SEL_FILE_LINK = 'a[href*="/sharedfiles/filedetails/?id="]';
    const SEL_STAR = 'svg[class*="Star"]';
    const SEL_MAG = 'svg.SVGIcon_MagnifyingGlass';
    const SEL_CREATOR = 'a[href*="/myworkshopfiles/"]';

    /** 找到条目卡片容器：同时包含 filedetails 链接 + 放大镜 SVG 的最近祖先 */
    function findCardContainer(anchor) {
        let node = anchor;
        for (let i = 0; i < 8 && node && node.parentElement; i++) {
            node = node.parentElement;
            if (!node || !node.querySelector) break;
            // 真正的卡片容器同时具备：缩略图（/ugc/）+ 放大镜按钮
            // 只含放大镜的祖先是「信息区」，不是卡片本身 —— 必须排除，
            // 否则数据条与角标会挂到信息区里而不是整张卡片上。
            if (node.querySelector(SEL_MAG) && node.querySelector('img[src*="/ugc/"]')) return node;
        }
        // 退化：只含缩略图的最近祖先
        node = anchor;
        for (let i = 0; i < 8 && node && node.parentElement; i++) {
            node = node.parentElement;
            if (!node || !node.querySelector) break;
            if (node.querySelector('img[src*="/ugc/"]')) return node;
        }
        return anchor.closest ? (anchor.closest('div') || anchor) : anchor;
    }

    /**
     * 扫描页面上的所有工坊卡片。
     * @returns {Map<string, {id, container, titleLink, imgLink, creatorLink, rating}>}
     */
    function scanCards(root) {
        const scope = root || global.document;
        const map = new Map();
        if (!scope || !scope.querySelectorAll) return map;
        const anchors = scope.querySelectorAll(SEL_FILE_LINK);
        for (const a of anchors) {
            const href = a.getAttribute('href') || '';
            const id = parseFileIdFromHref(href);
            if (!id || map.has(id)) continue;
            const container = findCardContainer(a);
            if (!container) continue;
            // 标题链接 = 卡片内不含 <img> 的 filedetails 链接；图片链接 = 含 <img> 的那个
            let titleLink = null, imgLink = null;
            container.querySelectorAll(SEL_FILE_LINK).forEach((l) => {
                if (l.querySelector('img')) { if (!imgLink) imgLink = l; }
                else if (!titleLink) titleLink = l;
            });
            if (!titleLink) titleLink = a;
            if (!imgLink) imgLink = a;
            const creatorLink = container.querySelector(SEL_CREATOR);
            const img = container.querySelector('img[src*="/ugc/"]');
            map.set(id, {
                id,
                container,
                titleLink,
                imgLink,
                creatorLink,
                img,
                rating: parseStarRating(container),
                title: (titleLink && titleLink.textContent || '').trim()
            });
        }
        return map;
    }

    /** 收集页面上所有条目 id */
    function collectIds(root) {
        const ids = [];
        for (const id of scanCards(root).keys()) ids.push(id);
        return ids;
    }

    // ============================================================
    // 第 5.5 层：跨页聚合（把服务端白名单之外的「每页 N 条」真正做出来）
    //
    // 背景（2026-10-30 实测）：Steam 服务端只接受 num_per_page ∈ {10,15,30,50}，
    // 其余值一律静默回落成 30（客户端 SPA 自己用的也是这四个，见 chunk
    // C-Bheh1z.js：`rgNumPerPageOptions ?? [10,15,30,50]`）。
    // 所以「每页 100 条」**不可能**靠 URL 参数实现 —— v1.4.0 那行 toast 自己也承认。
    //
    // 本层的做法：把「每页 N 条」拆成
    //   · N ≤ 50  → 走服务端原生分页（URL 参数），翻页行为与 Steam 完全一致；
    //   · N > 50  → 服务端仍按 50 条一页取数，脚本把后续几页**抓下来合并**进同一个网格，
    //                并把原生分页器接管成「按 N 条为一页」的翻页。
    // 实测 p=1..3 @50 条 → 150 个唯一 id，零重复（见 docs）。
    // ============================================================

    /** 聚合模式的状态（每次 URL 变化后重置） */
    const aggState = {
        active: false,     // 是否处于聚合模式（N > 50）
        loading: false,    // 防止并发重复抓取
        pages: 0,          // 已合并的服务端页数
        total: 0,          // 服务端总条数
        totalPages: 0,     // 服务端总页数（按 50/页）
        ids: [],           // 已合并的条目 id（有序、去重）
        desired: 0,        // 用户选择的每页条数
        stars: new Map()   // 聚合条目的星级/票数（{star, totalVotes}）
    };

    /**
     * 找到浏览页的网格容器（装卡片的那个盒子）。
     *
     * 网格本身是哈希类名（JnRpQcV2qgY-），不能靠类名定位；但「装卡片最多的父节点」
     * 是稳定的结构关系 —— 网格就是卡片最多的那个容器。
     *
     * ⚠️ 不能取「第一张卡的父节点」：页面上有 filedetails 链接在网格之外
     * （导航/侧栏），第一张卡未必属于网格。
     *
     * @param {Document} doc
     * @returns {Element|null}
     */
    /**
     * 从已扫描的卡片集合里找「装卡片最多的父节点」（= 网格容器）。
     * 网格类名是哈希的，只能靠这个稳定的结构关系定位。
     * 抽出来供 findGridContainer 与 applyStarFilter（复用已扫描的 cards，避免二次扫描）共用。
     */
    function gridFromCards(cards) {
        if (!cards || !cards.size) return null;
        const tally = new Map();
        for (const c of cards.values()) {
            const p = c.container && c.container.parentElement;
            if (!p) continue;
            tally.set(p, (tally.get(p) || 0) + 1);
        }
        let best = null;
        let bestN = 0;
        for (const [p, n] of tally) {
            if (n > bestN) { bestN = n; best = p; }
        }
        return bestN > 1 ? best : null;
    }

    function findGridContainer(doc) {
        return gridFromCards(scanCards(doc));
    }

    /**
     * 找出原生分页条容器（含「Per page」下拉 + 页码按钮 + 前后翻页箭头）。
     *
     * 锚点用「页码按钮（div[role=button] 且文本是纯数字）」这一稳定语义特征，
     * 而不是哈希类名。实测（2026-10-31）：
     *   页码按钮 = 1 / 2 / 3 / … / 266；
     *   它们向上到同时含 [role=combobox]（Per page 下拉）的那一层 = 整个分页条。
     * 只取到「页码区」会漏掉下拉与箭头，所以必须以 combobox 为准。
     *
     * @param {Document} doc
     * @returns {Element|null}
     */
    function findNativePager(doc) {
        const nums = [];
        doc.querySelectorAll('div[role="button"]').forEach(el => {
            const t = (el.textContent || '').trim();
            if (t && /^\d{1,4}$/.test(t)) nums.push(el);
        });
        if (nums.length < 2) return null;
        // 向上找：同时包含全部页码按钮 **且** 含 Per page 下拉的那一层
        let node = nums[0];
        while (node && node !== doc.body) {
            let inside = 0;
            for (const n of nums) if (node.contains(n)) inside++;
            if (inside === nums.length && node.querySelector('[role="combobox"]')) return node;
            node = node.parentElement;
        }
        return null;
    }

    /**
     * 把原生分页器上的「每页条数」下拉改写成我们的取值。
     *
     * 原生下拉是 div[role=combobox]，展开后是 listbox；直接操作 React 受控组件
     * 很脆。**不写原生下拉**，改为：
     *   · 隐藏原生分页条（聚合模式下我们自己接管翻页）；
     *   · 在插件面板里提供「每页条数」选择器 + 上一页/下一页。
     * 这样不与 React 抢同一个 state，行为稳定。
     */
    function hideNativePager(doc) {
        const pager = findNativePager(doc);
        if (pager) {
            pager.setAttribute('data-swe-native-pager', '1');
        }
        return pager;
    }

    /**
     * 聚合模式下原生分页器由插件接管：
     * 隐藏原生分页条，并在插件面板里显示「第 N 组 / 共 M 组」。
     */
    function updateAggregatePager() {
        const plan = buildAggregatePlan(aggState.desired);
        const info = toolbarEl && toolbarEl.querySelector('.swe-agg-info');
        const row = toolbarEl && toolbarEl.querySelector('.swe-agg-row');
        if (!info || !row) return;
        if (plan.mode !== 'aggregate') { row.style.display = 'none'; return; }
        row.style.display = 'flex';
        // 每组 = plan.pages 个服务端页；总组数由服务端总条数推算
        const perGroup = plan.pages * plan.serverSize;
        const totalGroups = aggState.total ? Math.max(1, Math.ceil(aggState.total / perGroup)) : 0;
        const curGroup = Math.floor((readBrowseParams(global.location.href).p - 1) / plan.pages) + 1;
        info.textContent = totalGroups ? (curGroup + ' / ' + totalGroups + ' 组') : (aggState.ids.length + ' 条');
    }

    /**
     * 聚合模式翻页：按「组」前进/后退（1 组 = plan.pages 个服务端页）。
     */
    async function navigateAggregate(dir) {
        const plan = buildAggregatePlan(aggState.desired);
        if (plan.mode !== 'aggregate') return;
        const cur = readBrowseParams(global.location.href).p || 1;
        const curGroup = Math.floor((cur - 1) / plan.pages);
        const nextGroup = curGroup + dir;
        if (nextGroup < 0) return;
        const nextP = nextGroup * plan.pages + 1;
        const u = new URL(global.location.href);
        u.searchParams.set('p', String(nextP));
        u.searchParams.set('num_per_page', String(plan.serverSize));
        await navigateTo(u.toString());
        const r = await runAggregate(aggState.desired);
        if (r.ok) { updateAggregatePager(); hideNativePager(global.document); }
        else toast('聚合失败：' + (r.error || '未知原因'), 3600);
    }

    /**
     * 聚合模式：把服务端第 startPage 起连续 pages 页的条目合并进页面网格。
     *
     * 流程：
     *   1. 抓第 2..n 页的**服务端渲染 HTML**（同源 fetch，带 cookie）；
     *   2. 用 DOMParser 解析，从里面取出该页**已渲染好的卡片 DOM**
     *      （图片、标题、创作者、星级全都对 —— 不需要我们重建）；
     *   3. 把这些卡片放进**插件自己的容器**，紧贴在原生网格后面。
     *
     * 为什么用「抓 HTML 取卡片」而不是「拿 JSON 自己画卡片」：
     *   卡片外观完全由哈希类名决定（UNowfeldbNg- / Sw3NXcvOA4Y- …），
     *   自己拼 DOM 等于复制一份随时会失效的类名表。
     *   而同一份构建产出的 HTML 里，卡片类名与当前页**完全一致**，
     *   直接搬运 DOM 节点，样式自然对得上。
     *
     * 关于 React —— 为什么**不**直接往原生网格里插：
     *   原生网格的子节点全部由 React 拥有。插外来节点后再触发 React 更新，
     *   React 会按自己的虚拟树增删子节点，把外来节点挤掉/错位
     *   （实测表现为卡片数回落到 30、且报 React #418）。
     *   所以聚合的卡片放进**插件自有的容器**（.swe-agg-grid），
     *   原生网格一个字节都不动 —— 与「不改原始页面」的原则一致。
     *
     * @param {number} desired 期望每页条数
     * @returns {Promise<{ok:boolean, added:number, error?:string}>}
     */
    async function runAggregate(desired) {
        const doc = global.document;
        const plan = buildAggregatePlan(desired);
        if (plan.mode !== 'aggregate') return { ok: false, added: 0 };
        if (aggState.loading) return { ok: false, added: 0 };
        aggState.loading = true;
        aggState.desired = desired;
        // 聚合模式下由插件接管翻页 → 立刻隐藏原生分页条（不必等抓取完成）
        hideNativePager(doc);
        try {
            const grid = findGridContainer(doc);
            if (!grid) return { ok: false, added: 0, error: '未找到网格' };

            const startPage = readBrowseParams(global.location.href).p || 1;
            const serverSize = plan.serverSize;
            const wanted = plan.pages;      // 需要的服务端页数
            const seen = new Set();         // 已收录的条目 id（去重）
            const rendered = new Set();      // 已渲染的条目 id（防止同一 id 渲染两次）
            const ordered = [];

            // 第 1 页（当前页）：直接读页面自身的 SSR 数据
            const firstIds = parseSsrBrowseIds(doc.documentElement.outerHTML);
            for (const id of firstIds) { if (!seen.has(id)) { seen.add(id); ordered.push(id); } }

            // 第 2..n 页：抓服务端渲染的 HTML，取其中的卡片 DOM
            const extraNodes = [];
            for (let i = 1; i < wanted; i++) {
                const url = buildAggregatePageUrl(global.location.href, i, startPage, serverSize);
                if (!url) break;
                const res = await fetchBrowsePage(url);
                if (!res.ok) break;
                aggState.total = res.meta.totalCount || aggState.total;
                aggState.totalPages = res.meta.totalPages || aggState.totalPages;
                // 记下这些条目的星级/票数，让星级筛选与最低票数对聚合条目同样生效
                for (const id of res.ids) {
                    if (!seen.has(id)) { seen.add(id); ordered.push(id); }
                }
                if (res.starMap) {
                    for (const [id, v] of res.starMap) aggState.stars.set(id, v);
                }
                const nodes = extractCardNodes(res.html, doc);
                for (const n of nodes) {
                    const link = n.querySelector('a[href*="/sharedfiles/filedetails/?id="]');
                    const id = link ? parseFileIdFromHref(link.getAttribute('href') || '') : '';
                    // 注意：此处用 rendered（已渲染）判定，不能用 seen（已收录）——
                    // seen 里已含本页所有 id，用它会把刚抽出来的卡片全部误判为重复。
                    if (!id || rendered.has(id)) continue;
                    rendered.add(id);
                    extraNodes.push(n);
                }
            }

            // 追加渲染：放进插件自有容器，**不碰 React 管理的原生网格**
            let added = 0;
            if (extraNodes.length) {
                const host = ensureAggregateHost(grid);
                for (const node of extraNodes) {
                    host.appendChild(node);
                    added++;
                }
            }

            aggState.pages = wanted;
            aggState.ids = ordered;
            aggState.active = true;
            // 聚合页的星级快照是后到的 → 让 SSR 星级缓存失效，下一次筛选重新合并
            ssrStarCache.map = null;
            if (added) {
                // 让新卡片也走一遍增强（数据条/角标/悬浮按钮/勾选框）
                // 聚合只在浏览页发生（/app/{id}/workshop/ 无分页控件）→ kind 固定 'browse'
                enhanceBrowsePage('browse');
            }
            return { ok: true, added: added };
        } catch (e) {
            return { ok: false, added: 0, error: (e && e.message) || '聚合失败' };
        } finally {
            aggState.loading = false;
        }
    }

    /**
     * 取得（或创建）聚合卡片容器：紧贴在原生网格之后，class 与原生网格一致 → 视觉连续。
     *
     * 为什么不直接插进原生网格：原生网格的子节点由 React 拥有，
     * 插外来节点会让 React 的虚拟树与真实 DOM 不一致（实测卡片数被冲回 30 并报 #418）。
     * 独立容器则完全不碰 React 的树。
     *
     * @param {Element} grid 原生网格容器
     * @returns {Element} 聚合容器
     */
    function ensureAggregateHost(grid) {
        const doc = global.document;
        let host = doc.querySelector('.swe-agg-grid');
        if (host && host.parentElement) return host;
        host = doc.createElement('div');
        host.className = 'swe-agg-grid';
        // 继承原生网格的类名 → 同样的布局（列数/间距/宽度规则）
        const nativeCls = String(grid.className || '').trim();
        if (nativeCls) host.className = 'swe-agg-grid ' + nativeCls;
        if (grid.parentElement) grid.parentElement.insertBefore(host, grid.nextSibling);
        else doc.body.appendChild(host);
        return host;
    }

    /** 清掉聚合容器（换页 / 退出聚合模式时） */
    function clearAggregateHost() {
        const doc = global.document;
        const host = doc.querySelector('.swe-agg-grid');
        if (host && host.parentElement) host.parentElement.removeChild(host);
    }

    /**
     * 从服务端渲染的 HTML 里取出卡片 DOM 节点（已 import 到当前文档）。
     *
     * @param {string} html 服务端页面 HTML
     * @param {Document} doc 当前文档（importNode 的目标）
     * @returns {Element[]} 卡片容器节点
     */
    function extractCardNodes(html, doc) {
        const out = [];
        if (!html) return out;
        let parsed;
        try { parsed = new global.DOMParser().parseFromString(html, 'text/html'); }
        catch (e) { return out; }
        const grid = findGridContainer(parsed);
        if (!grid) return out;
        const cards = scanCards(parsed);
        for (const c of cards.values()) {
            if (!c.container || c.container.parentElement !== grid) continue;
            try { out.push(doc.importNode(c.container, true)); } catch (e) {}
        }
        return out;
    }

    // ============================================================
    // 第 5.6 层：截图瀑布流浮窗（纯图浏览，不改原始页面）
    //
    // 目标页：/app/{appid}/screenshots/（社区截图页，经典服务端渲染 apphub 卡片）
    // 目标形态：点一个按钮 → 全屏浮窗里用瀑布流铺开社区截图；原始页面**完全不动**。
    //
    // 与 steam-activity-modern 的「纯图模式」的对应关系：
    //   · 那边是从好友动态里收集 .blotter_screenshot_image 的图片；
    //   · 这边是从社区截图页收集 .apphub_CardContentPreviewImage 的图片，
    //     并且要能**跨页**取（社区截图远多于首屏 10 条）。
    //
    // 数据来源（2026-10-31 实测 /app/570/screenshots/）：
    //   · 首屏：页面自带 10 张（.apphub_Card + data-publishedfileid + img.apphub_CardContentPreviewImage）
    //   · 翻页：MoreContentForm1（GET /app/{appid}/homecontent/，带 screenshotspage=N 等参数）
    //     返回的是**卡片 HTML 片段**（不是整页），可直接解析出 .apphub_Card。
    //
    // 关键约束：浮窗是**独立 DOM**（不搬动原页面的卡片），所以关掉浮窗后
    // 原始页面一个字节都不用还原 —— 天然满足「不改原始页面」。
    // ============================================================

    const WF_MIN_COL_WIDTH = 260;   // 瀑布流单列最小宽度
    const WF_MAX_COLS = 8;          // 最多列数
    const WF_BATCH = 24;             // 每批渲染张数
    const WF_HD_CONCURRENCY = 3;     // 原图后台加载并发数
    // 每次向服务端要的条数。
    // 2026-10-31 实测（appid=570，/app/570/screenshots/）：
    //   numperpage=10  → 第 2 页只返回 **2 张**（hidden 原值就是 10）
    //   numperpage=30  → 第 2/3/4/5 页各返回 **30 张**，id 互不相同 → 分页正常
    //   numperpage=100 → 每页 **100 张**
    // 结论：numperpage 才是"加载更多加载不出来"的真正原因（沿用 10 → 翻两页就空），
    // 而 browsefilter（trend/newest/空）对结果**完全没有影响**（id 一模一样），不必动它。
    const WF_PAGE_FETCH = 50;
    const WF_MAX_PAGE_ATTEMPTS = 3;  // 某一页全是重复时，最多再往后试几页

    /** 瀑布流浮窗状态 */
    const wfState = {
        open: false,
        images: [],      // {id, preview, full, title, author, page}
        loaded: 0,
        page: 1,
        pagesFetched: 0,
        allLoaded: false,
        loading: false,   // 并发保护：滚动到底会连续触发 scroll，必须挡住
        error: '',        // 加载失败信息（显示后可重试）
        gameName: '',
        viewIndex: -1,    // 全屏看图时当前图片下标（支持左右键切换）
        viewerOpen: false,
        viewToken: 0,     // v1.8.2：看图换图令牌（慢原图解码完成不得覆盖后点的图）
        cols: [],
        hdQueue: [],
        hdActive: 0,
        hdEpoch: 0,
        observer: null,
        resizeBound: false
    };

    /**
     * 取当前页面的游戏名（2026-10-31 实测锚点）。
     *
     * · `.apphub_AppName` → "Dota 2"（最稳）
     * · 兜底：document.title = "Steam 社区 :: Dota 2" → 剥掉前缀
     */
    function wfGameName(doc) {
        const d = doc || global.document;
        if (!d) return '';
        const el = d.querySelector('.apphub_AppName');
        if (el) {
            const t = (el.textContent || '').trim();
            if (t) return t;
        }
        const t = (d.title || '').replace(/^\s*Steam\s*社区\s*::\s*/i, '').trim();
        return t;
    }

    /**
     * 把 Steam 截图 URL 升到「中尺寸」用于瀑布流快速首屏。
     * 去掉 imw 即原图；这里改成 640 宽的压缩图（列表用），原图交给后台队列。
     */
    function wfMidSrc(src, width) {
        try {
            const u = new URL(src, global.location.href);
            u.searchParams.set('imw', String(width || 640));
            u.searchParams.set('ima', 'fit');
            u.searchParams.set('letterbox', 'false');
            return u.href;
        } catch (e) { return src; }
    }

    /**
     * 收集当前页面上的社区截图（首屏）。
     * @param {Document} doc
     * @returns {Array}
     */
    function wfCollectFromDom(doc) {
        const out = [];
        const seen = new Set();
        for (const card of doc.querySelectorAll(SEL_APPHUB_CARD)) {
            const img = card.querySelector('img.apphub_CardContentPreviewImage');
            if (!img) continue;
            const raw = img.getAttribute('src') || '';
            if (!raw || raw.indexOf('/ugc/') < 0) continue;
            const id = card.getAttribute('data-publishedfileid') || '';
            if (id && seen.has(id)) continue;
            if (id) seen.add(id);
            out.push({
                id: id,
                preview: wfMidSrc(raw, 640),
                full: artworkOriginalUrl(img) || raw,
                title: (card.querySelector('.apphub_CardContentTitle') || {}).textContent || '',
                author: (card.querySelector('.apphub_CardContentAuthorName') || {}).textContent || '',
                url: card.getAttribute('data-modal-content-url') || ''
            });
        }
        return out;
    }

    /**
     * 抓下一页社区截图（服务端返回卡片 HTML 片段）。
     *
     * 2026-10-31 实测：GET /app/{appid}/homecontent/?...&screenshotspage=N
     * 返回的是 .apphub_Card 的 HTML 片段（外层无 html/body），
     * 用 DOMParser 解析后按 .apphub_Card 过滤即可。
     *
     * 关键：**numperpage 必须显式给一个够大的值**。
     * hidden 里原值是 10（页面自己的每页条数），实测该值下第 2 页只返回 2 张 → 翻两页就空，
     * 表现为「加载更多加载不出来」。改成 50 后每页稳定 50 张（实测 30/50/100 均生效）。
     *
     * @param {number} page 页码（2 起）
     * @param {number} [npp] 每页条数
     * @returns {Promise<Array>}
     */
    async function wfFetchPage(page, npp) {
        const doc = global.document;
        const form = doc.querySelector('#MoreContentForm1');
        if (!form) throw new Error('页面缺少 MoreContentForm1，无法翻页');
        const params = new URLSearchParams();
        for (const input of form.querySelectorAll('input[type="hidden"]')) {
            const name = input.getAttribute('name');
            if (!name) continue;
            let value = input.getAttribute('value') || '';
            // 把各分页计数器一起推进，保持与服务端「MoreContentForm」语义一致
            if (/page$/i.test(name)) value = String(page);
            params.set(name, value);
        }
        params.set('p', String(page));
        params.set('numperpage', String(npp || WF_PAGE_FETCH));
        const appid = ((global.location && global.location.pathname) || '').match(/\/app\/(\d+)/);
        const fallback = '/app/' + (appid ? appid[1] : currentAppId()) + '/homecontent/';
        const action = form.getAttribute('action') || fallback;
        const url = new URL(action, global.location.href);
        url.search = params.toString();
        const res = await global.fetch(url.toString(), { credentials: 'include', cache: 'no-store' });
        if (!res.ok) throw new Error('服务端返回 ' + res.status);
        const html = await res.text();
        let parsed;
        try { parsed = new global.DOMParser().parseFromString(html, 'text/html'); } catch (e) { throw new Error('内容解析失败'); }
        return wfCollectFromDom(parsed);
    }

    /**
     * 瀑布流分栏：按视口宽度算列数，逐张放进当前最矮的一列。
     */
    function wfCreateColumns() {
        const grid = global.document.querySelector('#swe-wf-grid');
        if (!grid) return;
        grid.innerHTML = '';
        wfState.cols = [];
        const bodyWidth = global.innerWidth || global.document.documentElement.clientWidth;
        const gap = 12;
        const cols = Math.max(1, Math.min(WF_MAX_COLS, Math.floor((bodyWidth - 48 - gap) / (WF_MIN_COL_WIDTH + gap))));
        for (let i = 0; i < cols; i++) {
            const col = global.document.createElement('div');
            col.className = 'swe-wf-col';
            grid.appendChild(col);
            wfState.cols.push(col);
        }
    }

    /** 找当前最矮的一列（瀑布流核心） */
    function wfShortestCol() {
        let best = wfState.cols[0];
        let minH = Infinity;
        for (const c of wfState.cols) {
            const h = c.offsetHeight || 0;
            if (h < minH) { minH = h; best = c; }
        }
        return best;
    }

    /**
     * 渲染下一批图片卡片。
     *
     * v1.7.0 修正 —— 这里以前有个**致命的语义混用**：
     *   旧代码在「当前已知图片都渲染完了」时把 `allLoaded = true`，
     *   而 `allLoaded` 的语义其实是「服务端已经没有更多页了」→
     *   首屏 10 张渲染完的瞬间，「加载更多」按钮就被隐藏了 →
     *   用户根本**点不到**加载更多（这是"加载不出来"最致命的一环）。
     *
     * 现在两者彻底分开：
     *   · `loaded`   —— 已渲染张数（这里管）
     *   · `allLoaded` —— 服务端没有更多页了（只由 wfLoadMore 管）
     * 并且一次进来几十张时，用分帧继续渲染剩余部分，避免一次性插入几十张卡顿。
     */
    function wfAppendBatch() {
        if (!wfState.open) return;                 // 浮窗已关 → 别再往里塞卡片
        if (!wfState.cols.length) return;
        if (wfState.loaded >= wfState.images.length) {
            wfUpdateCount();
            return;                       // 渲染完了，但**不代表**服务端没有更多页
        }
        const start = wfState.loaded;
        const end = Math.min(start + WF_BATCH, wfState.images.length);
        for (let i = start; i < end; i++) {
            const item = wfState.images[i];
            const card = global.document.createElement('figure');
            card.className = 'swe-wf-card';
            const img = global.document.createElement('img');
            img.loading = 'lazy';
            img.alt = item.title || '社区截图';
            img.src = item.preview;
            if (item.full && item.full !== item.preview) img.setAttribute('data-swe-full', item.full);
            img.addEventListener('load', () => {
                if (img.naturalWidth && img.naturalHeight) {
                    img.style.aspectRatio = img.naturalWidth + ' / ' + img.naturalHeight;
                }
            });
            img.addEventListener('click', (e) => {
                e.preventDefault();
                e.stopPropagation();
                wfOpenViewer(item);
            });
            card.appendChild(img);
            const cap = global.document.createElement('figcaption');
            cap.className = 'swe-wf-cap';
            const t = global.document.createElement('span');
            t.className = 'swe-wf-title';
            t.textContent = item.title || '';
            cap.appendChild(t);
            card.appendChild(cap);
            wfShortestCol().appendChild(card);
            if (img.getAttribute('data-swe-full')) wfObserveHd(img);
        }
        wfState.loaded = end;
        wfUpdateCount();
        if (end < wfState.images.length) {
            // 还有剩余（一次进来几十张时）→ 分帧继续渲染，避免一次性插几十张卡顿
            raf(() => wfAppendBatch());
        }
    }

    /**
     * 刷新浮窗顶部的计数、按钮与状态文案。
     *
     * 三种状态互斥：加载中 / 出错（可重试） / 已加载完。
     */
    function wfUpdateCount() {
        const doc = global.document;
        const el = doc.querySelector('#swe-wf-count');
        if (el) el.textContent = wfState.loaded + ' / ' + wfState.images.length + ' 张';
        const more = doc.querySelector('#swe-wf-more');
        const btn = doc.querySelector('#swe-wf-more-btn');
        const status = doc.querySelector('#swe-wf-status');
        if (more) more.style.display = (wfState.allLoaded && !wfState.loading) ? 'none' : 'flex';
        if (btn) {
            if (wfState.loading) {
                btn.disabled = true;
                btn.textContent = '加载中…';
            } else {
                btn.disabled = false;
                btn.textContent = wfState.allLoaded ? '已加载全部' : '加载更多截图';
            }
        }
        if (status) {
            const text = wfState.loading ? '正在加载更多截图…'
                : (wfState.error || (wfState.allLoaded ? '已加载全部社区截图' : ''));
            status.textContent = text;
            status.style.display = text ? 'block' : 'none';
            status.classList.toggle('swe-wf-status-err', !!wfState.error);
        }
        // 空状态：一张都没拿到才显示（区别于"已加载完"）
        const empty = doc.querySelector('#swe-wf-empty');
        if (empty) {
            empty.style.display = (wfState.loaded === 0 && wfState.allLoaded) ? 'block' : 'none';
        }
    }

    /** 加载中的骨架屏（几张 shimmer 占位，避免"点了没反应"的空窗期） */
    function wfSetLoading(on) {
        const doc = global.document;
        const skel = doc.querySelector('#swe-wf-skeleton');
        if (!skel) return;
        skel.classList.toggle('on', !!on);
        if (on && !skel.children.length) {
            const n = Math.max(2, Math.min(6, wfState.cols.length || 3));
            for (let i = 0; i < n; i++) {
                const s = doc.createElement('div');
                s.className = 'swe-wf-skel';
                skel.appendChild(s);
            }
        }
    }

    // ---------- 原图后台加载（IntersectionObserver + 限流并发） ----------

    function wfEnsureHdObserver() {
        if (wfState.observer) return wfState.observer;
        if (typeof global.IntersectionObserver !== 'function') return null;
        const obs = new global.IntersectionObserver((entries) => {
            for (const en of entries) {
                if (!en.isIntersecting) continue;
                const img = en.target;
                obs.unobserve(img);
                wfQueueHd(img);
            }
        }, { rootMargin: '600px' });
        wfState.observer = obs;
        return obs;
    }

    function wfObserveHd(img) {
        const obs = wfEnsureHdObserver();
        if (obs) obs.observe(img);
        else wfQueueHd(img);
    }

    function wfQueueHd(img) {
        wfState.hdQueue.push(img);
        wfPumpHd();
    }

    function wfPumpHd() {
        while (wfState.hdActive < WF_HD_CONCURRENCY && wfState.hdQueue.length) {
            const img = wfState.hdQueue.shift();
            const epoch = wfState.hdEpoch;
            wfState.hdActive++;
            const full = img.getAttribute('data-swe-full');
            if (!full) { wfState.hdActive--; continue; }
            const probe = new global.Image();
            probe.onload = () => {
                if (epoch !== wfState.hdEpoch) { wfState.hdActive--; return; }
                img.classList.add('swe-wf-hd');
                img.src = full;
                img.removeAttribute('data-swe-full');
                wfState.hdActive--;
                wfPumpHd();
            };
            probe.onerror = () => { wfState.hdActive--; wfPumpHd(); };
            probe.src = full;
        }
    }

    function wfTeardownHd() {
        wfState.hdEpoch++;
        if (wfState.observer) { try { wfState.observer.disconnect(); } catch (e) {} wfState.observer = null; }
        wfState.hdQueue = [];
        wfState.hdActive = 0;
    }

    // ---------- 全屏看图 ----------

    /**
     * 定位条目下标：对象身份优先，失效后按 id → full/preview/url → title 逐级兜底。
     *
     * v1.8.2：此前只靠 `images.indexOf(item)`（对象身份）。任何导致数组重建/条目
     * 重建的路径都会让老卡片闭包里的 item 找不到 → indexOf 返回 -1 → 渲染函数
     * 直接 return → 查看器**保留上一次的图片与标题**（用户看到的"始终是上一张"）。
     * @param {object} item 卡片闭包里的条目
     * @returns {number} 下标；找不到返回 -1
     */
    function wfFindImageIndex(item) {
        const imgs = wfState.images || [];
        if (!item) return -1;
        for (let i = 0; i < imgs.length; i++) {
            if (imgs[i] === item) return i;
        }
        if (item.id) {
            for (let i = 0; i < imgs.length; i++) {
                if (imgs[i].id === item.id) return i;
            }
        }
        const keys = [item.full, item.preview, item.url];
        for (const key of keys) {
            if (!key) continue;
            for (let i = 0; i < imgs.length; i++) {
                if (imgs[i].full === key || imgs[i].preview === key) return i;
            }
        }
        if (item.title) {
            for (let i = 0; i < imgs.length; i++) {
                if (imgs[i].title === item.title) return i;
            }
        }
        return -1;
    }

    function wfOpenViewer(item) {
        const doc = global.document;
        let v = doc.querySelector('#swe-wf-viewer');
        if (!v) {
            v = doc.createElement('div');
            v.id = 'swe-wf-viewer';
            v.className = 'swe-wf-viewer';
            v.innerHTML =
                '<img class="swe-wf-viewer-img" alt="">' +
                '<button class="swe-wf-viewer-close" title="关闭（Esc）">✕</button>' +
                '<div class="swe-wf-viewer-cap"></div>';
            doc.body.appendChild(v);
            v.querySelector('.swe-wf-viewer-close').addEventListener('click', () => wfCloseViewer());
            v.addEventListener('click', (e) => {
                if (e.target === v || e.target.classList.contains('swe-wf-viewer-img')) wfCloseViewer();
            });
            doc.addEventListener('keydown', (e) => {
                if (e.key === 'Escape') { wfCloseViewer(); return; }
                // 左右方向键切换上一张 / 下一张
                if (!wfState.viewerOpen) return;
                if (e.key === 'ArrowRight') { wfStepViewer(1); e.preventDefault(); }
                else if (e.key === 'ArrowLeft') { wfStepViewer(-1); e.preventDefault(); }
            });
        }
        wfState.viewIndex = wfFindImageIndex(item);
        wfState.viewerOpen = true;
        wfRenderViewer();
        v.classList.add('swe-wf-viewer-open');
    }

    /**
     * 渲染全屏看图的当前图片（标题带「第 N / 共 M 张」）。
     *
     * v1.8.2 修复「看图浮窗和实际点击的图片不是同一张 / 始终显示上一次的缓存图」：
     *   1. **先立即显示所点条目自己的预览图** —— 缩略图本来就在浏览器缓存里，秒出且
     *      必然是所点的那张。旧版直接 `img.src = item.full`（原图，几秒才下载完），
     *      解码完成前 `<img>` 一直显示上一次的图 → 看起来"永远慢一张"。
     *   2. 原图后台解码，就绪后凭**令牌**静默升级；令牌不匹配（用户已翻到别的图）
     *      → 直接丢弃，慢图的迟到回调不得覆盖后点的图。
     *   3. 条目定位失败（下标 -1）时**清空查看器**并提示，绝不保留上一次的渲染
     *      （旧版 early-return，图片+标题全是旧的，极具迷惑性）。
     */
    function wfRenderViewer() {
        const v = global.document.querySelector('#swe-wf-viewer');
        if (!v) return;
        const item = wfState.images[wfState.viewIndex];
        const img = v.querySelector('.swe-wf-viewer-img');
        const cap = v.querySelector('.swe-wf-viewer-cap');
        if (!item) {
            // 条目不存在 → 清空（旧版直接 return，留下上一次的图与标题）
            wfState.viewToken = (wfState.viewToken || 0) + 1;
            if (img) img.removeAttribute('src');
            if (cap) cap.textContent = '图片不存在或尚未加载';
            return;
        }
        // 1) 预览图先行：这就是用户点的那张（同一条目的缩略图，缓存秒出）
        if (item.preview) img.src = item.preview;
        else if (item.full) img.src = item.full;
        else img.removeAttribute('src');
        // 2) 标题同步更新（点击反馈的另一半）
        const total = wfState.images.length;
        const pos = (wfState.viewIndex >= 0 && total) ? (wfState.viewIndex + 1) + ' / ' + total + '　' : '';
        cap.textContent =
            pos + (item.title ? item.title : '') + (item.author ? ' — ' + item.author : '');
        // 3) 原图后台解码 → 令牌校验 → 静默升级
        const full = item.full || '';
        if (!full || full === item.preview) return;
        const token = (wfState.viewToken = (wfState.viewToken || 0) + 1);
        const probe = new global.Image();
        probe.onload = () => {
            // 令牌不匹配 = 用户已翻到其它图 → 这次解码结果作废
            if (wfState.viewToken !== token) return;
            img.src = full;
        };
        probe.src = full;
    }

    /** 全屏看图翻页（左右键） */
    function wfStepViewer(delta) {
        if (!wfState.viewerOpen) return;
        const i = wfState.viewIndex + delta;
        if (i < 0 || i >= wfState.images.length) return;
        wfState.viewIndex = i;
        wfRenderViewer();
    }

    function wfCloseViewer() {
        const v = global.document.querySelector('#swe-wf-viewer');
        if (v) v.classList.remove('swe-wf-viewer-open');
        wfState.viewerOpen = false;
    }

    // ---------- 浮窗开合 ----------

    /**
     * 打开瀑布流浮窗。
     * 原始页面不做任何改动：浮窗是独立 DOM，关掉即消失。
     */
    async function wfOpen() {
        const doc = global.document;
        let overlay = doc.querySelector('#swe-wf-overlay');
        if (!overlay) {
            overlay = doc.createElement('div');
            overlay.id = 'swe-wf-overlay';
            overlay.className = 'swe-wf-overlay';
            overlay.innerHTML =
                '<div class="swe-wf-head">' +
                '  <span class="swe-wf-title" id="swe-wf-title">社区截图 · 瀑布流</span>' +
                '  <span class="swe-wf-count" id="swe-wf-count">0 / 0 张</span>' +
                '  <button class="swe-wf-close" title="关闭（Esc）">✕</button>' +
                '</div>' +
                '<div class="swe-wf-body"><div class="swe-wf-grid" id="swe-wf-grid"></div>' +
                '  <div class="swe-wf-skeleton" id="swe-wf-skeleton"></div>' +
                '  <div class="swe-wf-more" id="swe-wf-more">' +
                '    <button class="swe-wf-more-btn" id="swe-wf-more-btn">加载更多截图</button></div>' +
                '  <div class="swe-wf-status" id="swe-wf-status"></div>' +
                '  <div class="swe-wf-empty" id="swe-wf-empty">没有找到截图</div>' +
                '</div>';
            doc.body.appendChild(overlay);
            overlay.querySelector('.swe-wf-close').addEventListener('click', () => wfClose());
            overlay.querySelector('.swe-wf-more-btn').addEventListener('click', () => wfLoadMore());
            doc.addEventListener('keydown', (e) => {
                if (e.key === 'Escape' && wfState.open) wfClose();
            });
            // 滚动到底部自动加载（wfLoadMore 内有并发保护，这里不会重复发请求）
            overlay.querySelector('.swe-wf-body').addEventListener('scroll', () => {
                const b = overlay.querySelector('.swe-wf-body');
                if (b.scrollTop + b.clientHeight > b.scrollHeight - 400) wfLoadMore();
            });
        }
        wfState.open = true;
        overlay.classList.add('swe-wf-open');
        wfState.images = [];
        wfState.loaded = 0;
        wfState.page = 1;
        wfState.pagesFetched = 0;
        wfState.allLoaded = false;
        wfState.loading = false;
        wfState.error = '';
        // 标题显示游戏名（实测锚点 .apphub_AppName → "Dota 2"）
        wfState.gameName = wfGameName(doc);
        const titleEl = overlay.querySelector('#swe-wf-title');
        if (titleEl) {
            titleEl.textContent = wfState.gameName
                ? wfState.gameName + ' · 社区截图瀑布流'
                : '社区截图 · 瀑布流';
        }
        wfTeardownHd();
        wfCreateColumns();
        if (!wfState.resizeBound) {
            wfState.resizeBound = true;
            global.addEventListener('resize', wfRelayout);
        }
        // 首屏：直接用页面已有的截图（秒开，不用等网络）
        const first = wfCollectFromDom(doc);
        for (const f of first) wfState.images.push(f);
        wfAppendBatch();
        if (!wfState.images.length) {
            // 页面本身没有（可能截图不在首屏）→ 直接抓第 2 页
            await wfLoadMore();
        } else {
            // 后台再补一批：用户一打开就能看到更多，不必先滚到底
            wfLoadMore();
        }
    }

    /** 窗口尺寸变化 → 重排瀑布流列数（把已有卡片按新的最矮列重新分配） */
    function wfRelayout() {
        if (!wfState.open) return;
        const grid = global.document.querySelector('#swe-wf-grid');
        if (!grid) return;
        const cards = [];
        for (const col of wfState.cols) {
            for (const card of Array.from(col.children)) cards.push(card);
        }
        if (!cards.length) return;
        wfCreateColumns();
        for (const card of cards) wfShortestCol().appendChild(card);
    }

    /**
     * 加载更多一页。
     *
     * v1.7.0 三处修正：
     *   1. **并发保护** —— 滚动到底会连续触发 scroll 事件，之前没有 loading 标志，
     *      会同时发出多个请求，页码与计数互相踩（这是"点了没反应"的另一半原因）；
     *   2. **空页自动续抓** —— 某一页可能全是已加载过的（与首屏重叠），自动再往后试几页，
     *      免得用户点了却"没有新图"；
     *   3. **失败不置为"已加载完"** —— 网络失败要保留重试机会。
     */
    async function wfLoadMore() {
        if (!wfState.open || wfState.allLoaded || wfState.loading) return;
        wfState.loading = true;
        wfState.error = '';
        wfSetLoading(true);
        wfUpdateCount();
        let added = 0;
        try {
            for (let attempt = 0; attempt < WF_MAX_PAGE_ATTEMPTS; attempt++) {
                const next = wfState.page + 1;
                const more = await wfFetchPage(next);
                if (!more.length) { wfState.allLoaded = true; break; }
                wfState.page = next;
                wfState.pagesFetched++;
                const seen = new Set(wfState.images.map(x => x.id));
                for (const m of more) {
                    if (m.id && seen.has(m.id)) continue;
                    if (m.id) seen.add(m.id);
                    wfState.images.push(m);
                    added++;
                }
                if (added > 0) break;            // 这一页有新东西 → 够了
                // 全是重复 → 继续试下一页
            }
            if (added) wfAppendBatch();
            else {
                // 连续试了 WF_MAX_PAGE_ATTEMPTS 页都没有新内容 → 确实到头了
                wfState.allLoaded = true;
                wfState.error = '';
            }
        } catch (e) {
            wfState.error = '加载失败：' + ((e && e.message) || '未知原因');
        } finally {
            wfState.loading = false;
            wfSetLoading(false);
            wfUpdateCount();
        }
    }

    function wfClose() {
        const overlay = global.document.querySelector('#swe-wf-overlay');
        if (overlay) overlay.classList.remove('swe-wf-open');
        wfState.open = false;
        wfTeardownHd();
        wfCloseViewer();
    }

    /**
     * 在截图页挂一个「瀑布流」入口按钮。
     *
     * v1.6.0：不再自己 fixed 到窗口右下角 —— 那样会和「设置」按钮
     * （.swe-toolbar-toggle，属于 .swe-toolbar）叠在一起（right/bottom 只差几像素）。
     * 现在放进统一的浮动图标组（dock），由 flex 排布 → 结构上不可能重叠。
     */
    function injectWaterfallButton() {
        const doc = global.document;
        if (doc.querySelector('.swe-wf-btn')) return;
        const dock = ensureDock();
        const btn = doc.createElement('button');
        btn.className = 'swe-wf-btn';
        btn.type = 'button';
        btn.title = '以瀑布流全屏浏览社区截图（不改原页面）';
        btn.innerHTML =
            '<svg viewBox="0 0 24 24" width="22" height="22" aria-hidden="true">' +
            '<rect x="3" y="3" width="7" height="10" rx="1" fill="none" stroke="currentColor" stroke-width="2"/>' +
            '<rect x="14" y="3" width="7" height="6" rx="1" fill="none" stroke="currentColor" stroke-width="2"/>' +
            '<rect x="14" y="12" width="7" height="9" rx="1" fill="none" stroke="currentColor" stroke-width="2"/>' +
            '</svg>';
        btn.addEventListener('click', () => wfOpen());
        dock.appendChild(btn);
        // 组里多了一个按钮 → dock 尺寸变了 → 重新摆一次位置（否则贴边会留出空隙）
        const p = loadDockPos();
        applyDockPos(dock, p ? p.edge : DOCK_DEFAULT_EDGE, p ? p.off : DOCK_DEFAULT_OFF);
    }

    // ============================================================
    // 第 5.7 层：浮动图标组（dock）—— 可拖到窗口四边
    // ============================================================

    /**
     * 浮动图标组（dock）。
     *
     * 为什么要做这个（2026-10-31 用户反馈「浮窗按钮和设置按钮覆盖了」）：
     *   「设置」按钮（.swe-toolbar-toggle，挂在 .swe-toolbar 里）与「瀑布流」按钮（.swe-wf-btn）
     *   此前是**两个各自 fixed 到窗口右下角**的元素 —— right/bottom 只差几像素 → 必然叠在一起。
     *
     * 现在的做法：
     *   · 所有浮动圆按钮都放进同一个 dock 容器，由 flex 排布 → 结构上不可能重叠；
     *   · dock 整体可拖到窗口的上 / 右 / 下 / 左任一边缘，抬手自动吸附，位置记进本地存储；
     *   · 面板改为相对 dock 定位（absolute），按 data-edge 决定朝哪边展开 → 跟着组走，不会错位；
     *   · 左右边缘时按钮竖排、上下边缘时横排，符合「贴边图标组」的直觉；
     *   · 贴边时展开的面板做一次视口钳制，保证完整落在屏幕内。
     */
    const DOCK_KEY = 'swe.dock.v1';
    const DOCK_MARGIN = 16;
    const DOCK_EDGES = ['top', 'right', 'bottom', 'left'];
    const DOCK_DEFAULT_EDGE = 'right';
    const DOCK_DEFAULT_OFF = 0.78;   // 默认靠右侧、偏下方一点
    let dockResizeBound = false;

    function clampNum(v, lo, hi) {
        const n = Number(v);
        if (!isFinite(n)) return lo;
        return n < lo ? lo : (n > hi ? hi : n);
    }

    /** 视口尺寸（测试环境里 innerWidth 可能缺失 → 兜底） */
    function viewSize() {
        const de = global.document && global.document.documentElement;
        const w = Number(global.innerWidth) || (de && de.clientWidth) || 1280;
        const h = Number(global.innerHeight) || (de && de.clientHeight) || 800;
        return { w: w, h: h };
    }

    function raf(fn) {
        if (typeof global.requestAnimationFrame === 'function') global.requestAnimationFrame(fn);
        else global.setTimeout(fn, 16);
    }

    /**
     * 纯计算：给定视口尺寸、dock 尺寸，算出贴到某条边后的 left/top。
     *
     * · 左右边缘 → 沿垂直方向滑动（top 由 off 决定），dock 贴住左/右；
     * · 上下边缘 → 沿水平方向滑动（left 由 off 决定），dock 贴住上/下。
     */
    function computeDockPos(edge, off, vw, vh, dw, dh) {
        const o = clampNum(off, 0, 1);
        if (edge === 'left' || edge === 'right') {
            return {
                left: (edge === 'left') ? DOCK_MARGIN : vw - dw - DOCK_MARGIN,
                top: o * vh - dh / 2
            };
        }
        return {
            left: o * vw - dw / 2,
            top: (edge === 'top') ? DOCK_MARGIN : vh - dh - DOCK_MARGIN
        };
    }

    /**
     * 纯计算：dock 矩形中心离哪条边最近 → 吸附到哪条边。
     *
     * @param {object} rect    dock 的矩形
     * @param {number} vw      视口宽
     * @param {number} vh      视口高
     * @param {string} [prefer] 平局时优先采用的边（拖拽时沿用原方向 → 不会来回抖）
     */
    function pickEdgeFromRect(rect, vw, vh, prefer) {
        const cx = rect.left + rect.width / 2, cy = rect.top + rect.height / 2;
        const d = { right: vw - cx, left: cx, top: cy, bottom: vh - cy };
        let edge = 'right', best = d.right;
        for (const k of ['left', 'top', 'bottom']) {
            if (d[k] < best - 0.5) { best = d[k]; edge = k; }
        }
        // 两条边几乎等距（差 < 1px）→ 沿用原来的方向，避免拖拽时在两边之间来回跳
        if (prefer && DOCK_EDGES.indexOf(prefer) >= 0 && Math.abs(d[prefer] - best) < 1) edge = prefer;
        return edge;
    }

    /** 读回上次记住的图标组位置 */
    function loadDockPos() {
        const o = storeGet(DOCK_KEY, null);
        if (!o || typeof o !== 'object') return null;
        if (DOCK_EDGES.indexOf(o.edge) < 0) return null;
        return { edge: o.edge, off: clampNum(o.off, 0.02, 0.98) };
    }

    function saveDockPos(edge, off) {
        storeSet(DOCK_KEY, { edge: edge, off: clampNum(off, 0.02, 0.98) });
    }

    /**
     * 把 dock 摆到指定边缘。
     * @param {HTMLElement} dock
     * @param {string} edge  top / right / bottom / left
     * @param {number} off   沿该边的位置比例（0~1）
     */
    function applyDockPos(dock, edge, off) {
        if (!dock) return;
        dock.dataset.edge = edge;
        // 先定方向（横排/竖排）再量尺寸 —— 顺序反了会拿到上一方向的旧尺寸
        void dock.offsetWidth;
        const vs = viewSize();
        const dw = dock.offsetWidth || 40, dh = dock.offsetHeight || 40;
        const p = computeDockPos(edge, off, vs.w, vs.h, dw, dh);
        dock.style.left = Math.round(p.left) + 'px';
        dock.style.top = Math.round(p.top) + 'px';
        dock.style.right = '';
        dock.style.bottom = '';
    }

    /** dock 展开的面板必须完整落在视口内（贴边时尤其容易溢出） */
    function fitDockPanel(dock) {
        if (!dock) return;
        const panel = dock.querySelector('.swe-panel');
        if (!panel || panel.style.display === 'none') return;
        panel.style.setProperty('--swe-pan-x', '0px');
        panel.style.setProperty('--swe-pan-y', '0px');
        const r = panel.getBoundingClientRect();
        const vs = viewSize();
        const m = 10;
        let dx = 0, dy = 0;
        if (r.right > vs.w - m) dx = vs.w - m - r.right;
        else if (r.left < m) dx = m - r.left;
        if (r.bottom > vs.h - m) dy = vs.h - m - r.bottom;
        else if (r.top < m) dy = m - r.top;
        if (dx) panel.style.setProperty('--swe-pan-x', dx + 'px');
        if (dy) panel.style.setProperty('--swe-pan-y', dy + 'px');
    }

    /** dock 中心离哪条边最近 → 就吸附到哪条边 */
    function pickDockEdge(rect, prefer) {
        const vs = viewSize();
        return pickEdgeFromRect(rect, vs.w, vs.h, prefer);
    }

    function ensureDockHint() {
        const doc = global.document;
        let el = doc.querySelector('.swe-dock-hint');
        if (el) return el;
        el = doc.createElement('div');
        el.className = 'swe-dock-hint';
        doc.body.appendChild(el);
        return el;
    }

    /** 拖动时高亮将要吸附的那条边 */
    function showDockHint(edge) {
        const hint = ensureDockHint();
        if (!hint) return;
        const vs = viewSize();
        if (edge === 'left') hint.style.cssText = 'left:0;top:0;width:5px;height:' + vs.h + 'px';
        else if (edge === 'right') hint.style.cssText = 'right:0;top:0;width:5px;height:' + vs.h + 'px';
        else if (edge === 'top') hint.style.cssText = 'left:0;top:0;width:' + vs.w + 'px;height:5px';
        else hint.style.cssText = 'left:0;bottom:0;width:' + vs.w + 'px;height:5px';
        hint.classList.add('on');
    }

    function hideDockHint() {
        const el = global.document.querySelector('.swe-dock-hint');
        if (el) el.classList.remove('on');
    }

    /**
     * 给 dock 装上拖拽能力。
     *
     * 关键点：
     *   · Pointer Events 一套代码覆盖鼠标 / 触摸 / 笔；
     *   · 位移超过阈值才算拖拽，否则算点击 —— 否则点按钮会被拖拽吃掉，按钮就点不动；
     *   · **pointermove / pointerup 挂在 window（capture 阶段），不挂在图标组上**。
     *     挂在组上的话，鼠标一旦移出组边界，后续 move 就不再派发到组 → 拖拽断掉
     *     （快速拖动时第一个 move 就出界，必然断）。
     *   · **因此完全不用 setPointerCapture**。这不是"忘了写"，而是刻意不用：
     *     一旦捕获指针，按规范后续的兼容性鼠标事件（含 click）会被 retarget 到捕获元素，
     *     按下的那个按钮根本收不到 click → 拖得动却点不动（v1.6.1 的实测回归）。
     *   · 抬手后吸附到最近的边，并把位置记进本地存储；
     *   · 拖拽结束后紧随的那次 click 必须吞掉，否则会误触发被拖动的那个按钮。
     */
    function initDockDrag(dock) {
        if (!dock || dock.__sweDragInit) return;
        dock.__sweDragInit = true;

        let dragging = false, moved = false, suppressClick = false;
        let startX = 0, startY = 0, startLeft = 0, startTop = 0, startEdge = '';

        const onMove = (e) => {
            if (!dragging) return;
            const dx = e.clientX - startX, dy = e.clientY - startY;
            if (!moved && Math.abs(dx) + Math.abs(dy) < 6) return;   // 还没过阈值 → 仍算点击
            if (!moved) {
                moved = true;
                dock.classList.add('dragging', 'no-anim');
                dock.style.right = '';
                dock.style.bottom = '';
            }
            dock.style.left = Math.round(startLeft + dx) + 'px';
            dock.style.top = Math.round(startTop + dy) + 'px';
            showDockHint(pickDockEdge(dock.getBoundingClientRect(), startEdge));
        };

        const onUp = () => {
            if (!dragging) return;
            dragging = false;
            global.removeEventListener('pointermove', onMove, true);
            global.removeEventListener('pointerup', onUp, true);
            global.removeEventListener('pointercancel', onUp, true);
            hideDockHint();
            if (!moved) return;                 // 只是点了一下 → 交还给 click
            suppressClick = true;
            global.setTimeout(() => { suppressClick = false; }, 350);
            dock.classList.remove('dragging');
            const rect = dock.getBoundingClientRect();
            const vs = viewSize();
            const edge = pickDockEdge(rect, startEdge);
            const cx = rect.left + rect.width / 2, cy = rect.top + rect.height / 2;
            const off = (edge === 'left' || edge === 'right')
                ? clampNum(cy / vs.h, 0.02, 0.98)
                : clampNum(cx / vs.w, 0.02, 0.98);
            applyDockPos(dock, edge, off);
            saveDockPos(edge, off);
            raf(() => dock.classList.remove('no-anim'));
            fitDockPanel(dock);
        };

        dock.addEventListener('pointerdown', (e) => {
            if (e.button !== undefined && e.button !== 0) return;
            // 面板内部的控件不触发拖拽
            if (e.target && e.target.closest && e.target.closest('.swe-panel')) return;
            const r = dock.getBoundingClientRect();
            dragging = true; moved = false;
            startX = e.clientX; startY = e.clientY;
            startLeft = r.left; startTop = r.top;
            startEdge = dock.dataset.edge || DOCK_DEFAULT_EDGE;
            // move/up 挂 window → 鼠标移出图标组也能继续跟手
            global.addEventListener('pointermove', onMove, true);
            global.addEventListener('pointerup', onUp, true);
            global.addEventListener('pointercancel', onUp, true);
        });

        // 吞掉拖拽结束后紧随的那次 click
        dock.addEventListener('click', (e) => {
            if (!suppressClick) return;
            e.preventDefault();
            e.stopPropagation();
        }, true);

        // 双击图标组 → 复位到默认位置（按钮被拖到角落找不到时的逃生口）
        dock.addEventListener('dblclick', (e) => {
            if (e.target && e.target.closest && e.target.closest('.swe-panel')) return;
            const d = global.document.querySelector('.swe-toolbar');
            if (!d) return;
            applyDockPos(d, DOCK_DEFAULT_EDGE, DOCK_DEFAULT_OFF);
            saveDockPos(DOCK_DEFAULT_EDGE, DOCK_DEFAULT_OFF);
            fitDockPanel(d);
            toast('浮动按钮已复位到右下角');
        });
    }

    /**
     * 绑定面板标题栏的「−」收起按钮（浏览页与艺术作品页共用）。
     *
     * v1.6.0 之前这个按钮**从未绑定事件** → 点了没反应（用户 2026-10-31 反馈）。
     * 收起后点 dock 上的 ⚙ 可再次展开。
     */
    function bindPanelCollapse(dock) {
        if (!dock) return;
        const panel = dock.querySelector('.swe-panel');
        const btn = dock.querySelector('.swe-panel-collapse');
        if (!panel || !btn) return;
        btn.addEventListener('click', (e) => {
            e.stopPropagation();
            panel.style.display = 'none';
        });
    }

    /** 初始化 dock：恢复上次位置 + 装拖拽 + 跟随窗口尺寸 */
    function initDock(dock) {
        if (!dock) return;
        initDockDrag(dock);
        bindPanelCollapse(dock);
        dock.classList.add('no-anim');
        const saved = loadDockPos();
        applyDockPos(dock, saved ? saved.edge : DOCK_DEFAULT_EDGE, saved ? saved.off : DOCK_DEFAULT_OFF);
        raf(() => dock.classList.remove('no-anim'));
        if (!dockResizeBound) {
            dockResizeBound = true;
            global.addEventListener('resize', () => {
                const d = global.document.querySelector('.swe-toolbar');
                if (!d) return;
                const p = loadDockPos();
                if (p) applyDockPos(d, p.edge, p.off);
                fitDockPanel(d);
            });
        }
    }

    /** 取（或建）浮动图标组容器 */
    function ensureDock() {
        const doc = global.document;
        let dock = doc.querySelector('.swe-toolbar');
        if (!dock) {
            dock = doc.createElement('div');
            dock.className = 'swe-toolbar';
            doc.body.appendChild(dock);
            initDock(dock);
        }
        return dock;
    }

    // ============================================================
    // 第 6 层：UI 样式
    // ============================================================

    const CSS = `
.swe-card-stats{display:flex;flex-wrap:wrap;gap:6px;align-items:center;margin-top:6px;
  font-size:11px;line-height:16px;color:#8f98a0;font-weight:400}
.swe-card-stats .swe-stat{white-space:nowrap;display:inline-flex;align-items:center;gap:3px}
.swe-card-stats .swe-stat b{color:#c7d5e0;font-weight:600}
.swe-card-stats .swe-stat.swe-hot b{color:#f5a623}
.swe-card-stats .swe-stat.swe-fresh b{color:#5cba6f}
.swe-card-stats .swe-loading{color:#4a5a68;font-style:italic}
.swe-badge-subscribed{position:absolute;top:6px;right:6px;z-index:5;
  background:rgba(28,185,120,.92);color:#04240f;font-size:10px;font-weight:700;
  padding:2px 6px;border-radius:3px;letter-spacing:.3px;pointer-events:none;
  box-shadow:0 1px 4px rgba(0,0,0,.4)}
.swe-badge-recent{position:absolute;top:6px;left:6px;z-index:5;
  background:rgba(245,166,35,.92);color:#3a2500;font-size:10px;font-weight:700;
  padding:2px 6px;border-radius:3px;pointer-events:none;box-shadow:0 1px 4px rgba(0,0,0,.4)}
.swe-pick{position:absolute;top:6px;left:6px;z-index:6;width:20px;height:20px;
  display:none;align-items:center;justify-content:center;cursor:pointer;
  background:rgba(10,16,24,.82);border:1px solid #66c0f4;border-radius:3px}
.swe-batch-on .swe-pick{display:flex}
.swe-pick input{width:14px;height:14px;margin:0;cursor:pointer;accent-color:#66c0f4}
.swe-pick.on{background:rgba(102,192,244,.9)}
.swe-pick.on input{accent-color:#04202e}
/* ---------- 浮动图标组（dock）----------
   结构：所有浮动圆按钮都放进 .swe-toolbar 这个 dock 里，由 flex 排布 → 不会互相重叠。
   位置：dock 的 left/top 由 JS 按「贴哪条边」算（applyDockPos），CSS 不写死位置。
   左右边缘 → 按钮竖排；上下边缘 → 按钮横排（贴边图标组的直觉）。 */
.swe-toolbar{position:fixed;z-index:2147483050;
  display:flex;flex-direction:column;gap:6px;align-items:center;
  padding:5px;border-radius:26px;border:1px solid #3d5a73;
  background:rgba(27,40,56,.94);box-shadow:0 6px 20px rgba(0,0,0,.5);
  font-family:'Motiva Sans','Noto Sans SC',Arial,sans-serif;
  transition:left .18s ease,top .18s ease}
.swe-toolbar.no-anim{transition:none}
.swe-toolbar.dragging{border-color:#66c0f4;box-shadow:0 10px 28px rgba(0,0,0,.65)}
.swe-toolbar[data-edge="top"],.swe-toolbar[data-edge="bottom"]{flex-direction:row}
/* 面板脱离文档流，贴着图标组展开；朝哪边展开由 data-edge 决定 → 跟着组走，不会错位 */
.swe-toolbar .swe-panel{position:absolute;z-index:2147483060}
.swe-toolbar[data-edge="right"] .swe-panel{right:calc(100% + 10px);top:50%;
  transform:translate(var(--swe-pan-x,0px),calc(-50% + var(--swe-pan-y,0px)))}
.swe-toolbar[data-edge="left"] .swe-panel{left:calc(100% + 10px);top:50%;
  transform:translate(var(--swe-pan-x,0px),calc(-50% + var(--swe-pan-y,0px)))}
.swe-toolbar[data-edge="top"] .swe-panel{top:calc(100% + 10px);left:50%;
  transform:translate(calc(-50% + var(--swe-pan-x,0px)),var(--swe-pan-y,0px))}
.swe-toolbar[data-edge="bottom"] .swe-panel{bottom:calc(100% + 10px);left:50%;
  transform:translate(calc(-50% + var(--swe-pan-x,0px)),var(--swe-pan-y,0px))}
/* 拖动时高亮将要吸附的那条边 */
.swe-dock-hint{position:fixed;z-index:2147483040;background:rgba(102,192,244,.25);
  border:1px solid rgba(102,192,244,.65);border-radius:3px;pointer-events:none;opacity:0;
  transition:opacity .14s ease}
.swe-dock-hint.on{opacity:1}
/* 面板宽度必须显式约束：
   面板是 flex 列容器，其宽度默认取子项 max-content —— 而 .swe-hint 那段 75 字的中文
   提示在 max-content 下是**一行 800+px**，会把整个面板撑到屏幕那么宽（2026-10-30 实测）。
   固定宽度 + 允许换行 + 内容区可滚动，才是能长期用的窄面板。 */
.swe-panel{background:rgba(27,40,56,.96);border:1px solid #3d5a73;border-radius:8px;
  box-shadow:0 10px 34px rgba(0,0,0,.55);color:#c7d5e0;font-size:12px;
  display:flex;flex-direction:column;width:268px;max-width:calc(100vw - 32px);
  max-height:calc(100vh - 96px);overflow:hidden}
.swe-panel-head{display:flex;align-items:center;gap:8px;padding:8px 10px;
  border-bottom:1px solid #2a4257;flex:0 0 auto}
.swe-panel-title{flex:1;font-size:12px;color:#66c0f4;font-weight:600;letter-spacing:.4px}
.swe-panel-collapse{flex:0 0 auto;width:20px;height:20px;line-height:1;padding:0;
  background:none;border:1px solid #3d5a73;border-radius:3px;color:#8f98a0;
  cursor:pointer;font-size:13px}
.swe-panel-collapse:hover{border-color:#66c0f4;color:#fff}
.swe-panel-body{overflow-y:auto;padding:8px 10px;display:flex;flex-direction:column;gap:8px}
.swe-sec{display:flex;flex-direction:column;gap:5px}
.swe-sec-t{font-size:10px;color:#6f8090;letter-spacing:.6px;text-transform:uppercase;
  padding-bottom:2px;border-bottom:1px solid rgba(61,90,115,.5)}
.swe-row{display:flex;gap:6px;align-items:center;justify-content:space-between}
.swe-row>span:first-child{flex:0 0 auto;white-space:nowrap}
.swe-row>select{flex:1 1 auto;min-width:0}
.swe-row>button{flex:1 1 auto;min-width:0}
.swe-row.swe-row-2>button{flex:1 1 0}
.swe-panel select,.swe-panel button{background:#1b2838;color:#c7d5e0;border:1px solid #3d5a73;
  border-radius:3px;padding:4px 8px;font-size:12px;cursor:pointer;font-family:inherit}
.swe-panel button:hover{border-color:#66c0f4;color:#fff}
.swe-panel button.swe-primary{background:linear-gradient(to bottom,#799905 5%,#536904 95%);
  color:#fff;border-color:#6a8b04;font-weight:600}
.swe-panel button.swe-danger{background:linear-gradient(to bottom,#a44141 5%,#803030 95%);
  color:#fff;border-color:#803030;font-weight:600}
.swe-panel button:disabled{opacity:.45;cursor:not-allowed}
.swe-panel input[type="number"]{width:64px;background:#1b2838;color:#c7d5e0;border:1px solid #3d5a73;
  border-radius:3px;padding:3px 6px;font-size:12px;font-family:inherit}
.swe-filter-status{color:#7b8b9a;font-size:11px}
.swe-filter-note{color:#7b8b9a;font-size:11px;line-height:1.5}
.swe-card-hidden{display:none!important}
/* v1.8.1：星级筛选隐藏大部分卡片后，网格内容只剩一两行，而 Steam 内容区带
   min-height —— 网格默认 align-content:stretch 会把富余高度分给唯一的行轨道，
   仅剩的卡片被纵向拉成一根长条（用户截图实测）。
   筛选激活时（applyStarFilter 打的 data-swe-grid-filtered 标记）改为顶对齐 +
   行高取内容高度（中和可能的 grid-auto-rows:1fr），多余空间留在网格下方。 */
[data-swe-grid-filtered="1"]{align-content:start!important;grid-auto-rows:min-content!important}
[data-swe-grid-filtered="1"]>*{align-self:start!important}
.swe-panel .swe-hint{color:#7b8b9a;font-size:11px;line-height:1.5;word-break:break-word}
.swe-panel .swe-hint b{color:#9fd0f0;font-weight:600}
.swe-agg-info{font-size:11px;color:#9fd0f0;white-space:nowrap}
/* 聚合模式下隐藏原生分页条（由插件接管翻页） */
[data-swe-native-pager="1"]{display:none!important}
/* 聚合容器：继承原生网格的类名（布局一致），但独立于 React 的虚拟树 */
.swe-agg-grid{margin-top:8px}

/* ---------- 截图瀑布流浮窗 ---------- */
/* 浮窗是独立 DOM，不搬动原页面卡片 → 关掉后原页面无需还原 */
.swe-wf-btn{width:38px;height:38px;border-radius:50%;border:1px solid transparent;
  background:transparent;color:#66c0f4;cursor:pointer;flex:0 0 auto;
  display:flex;align-items:center;justify-content:center;
  transition:transform .18s ease,border-color .18s ease,background .18s ease}
.swe-wf-btn:hover{transform:scale(1.1);border-color:#66c0f4;background:rgba(102,192,244,.12)}
.swe-wf-overlay{position:fixed;inset:0;z-index:2147483200;
  background:linear-gradient(180deg,#1b2838 0%,#171a21 100%);
  opacity:0;visibility:hidden;transition:opacity .28s ease,visibility .28s ease;
  display:flex;flex-direction:column;font-family:'Motiva Sans','Noto Sans SC',Arial,sans-serif}
.swe-wf-overlay.swe-wf-open{opacity:1;visibility:visible}
.swe-wf-head{flex:0 0 auto;display:flex;align-items:center;gap:12px;
  padding:12px 18px;background:rgba(23,26,33,.97);border-bottom:1px solid rgba(255,255,255,.08)}
.swe-wf-title{font-size:15px;font-weight:700;color:#fff;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.swe-wf-count{font-size:12px;color:#8f98a0;flex:0 0 auto}
.swe-wf-close{margin-left:auto;width:32px;height:32px;border-radius:50%;
  background:rgba(255,255,255,.08);border:1px solid rgba(255,255,255,.12);
  color:#c7d5e0;cursor:pointer;font-size:15px;line-height:1}
.swe-wf-close:hover{background:rgba(244,63,94,.28);color:#fff}
.swe-wf-body{flex:1 1 auto;overflow-y:auto;padding:14px 18px 28px}
.swe-wf-grid{display:flex;gap:12px;align-items:flex-start}
.swe-wf-col{flex:1 1 0;min-width:0;display:flex;flex-direction:column;gap:12px}
.swe-wf-card{margin:0;background:rgba(16,26,36,.72);border:1px solid rgba(61,90,115,.6);
  border-radius:6px;overflow:hidden;cursor:zoom-in;
  transition:transform .18s ease,border-color .18s ease,box-shadow .18s ease}
.swe-wf-card:hover{transform:translateY(-3px);border-color:rgba(102,192,244,.5);
  box-shadow:0 8px 22px rgba(0,0,0,.42)}
.swe-wf-card img{display:block;width:100%;height:auto;background:#0d141c;transition:opacity .3s ease}
.swe-wf-cap{padding:6px 9px;font-size:11px;color:#8f98a0;line-height:1.4;
  overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.swe-wf-more{display:flex;justify-content:center;padding:20px 0 4px}
.swe-wf-more-btn{padding:9px 26px;border-radius:6px;border:none;cursor:pointer;
  background:linear-gradient(135deg,#4a9bc7,#3b6ea5);color:#fff;font-size:13px;font-weight:600}
.swe-wf-more-btn:hover{filter:brightness(1.12)}
.swe-wf-more-btn:disabled{opacity:.6;cursor:not-allowed}
/* 加载状态：骨架屏 + 状态文案（区分"加载中 / 出错可重试 / 已加载完"） */
.swe-wf-skeleton{display:none;gap:12px;padding-top:12px}
.swe-wf-skeleton.on{display:flex}
.swe-wf-skel{flex:1 1 0;border-radius:6px;height:220px;
  background:linear-gradient(100deg,rgba(61,90,115,.16) 28%,rgba(102,192,244,.16) 50%,rgba(61,90,115,.16) 72%);
  background-size:220% 100%;animation:swe-wf-shimmer 1.25s linear infinite}
@keyframes swe-wf-shimmer{from{background-position:150% 0}to{background-position:-50% 0}}
.swe-wf-status{display:none;text-align:center;padding:10px 0 2px;color:#8f98a0;font-size:12px}
.swe-wf-status-err{color:#f5a623}
.swe-wf-empty{display:none;text-align:center;padding:60px 20px;color:#8f98a0;font-size:14px}
/* 全屏看图 */
.swe-wf-viewer{position:fixed;inset:0;z-index:2147483300;background:rgba(6,10,16,.94);
  display:flex;align-items:center;justify-content:center;flex-direction:column;gap:12px;
  opacity:0;visibility:hidden;transition:opacity .22s ease,visibility .22s ease}
.swe-wf-viewer.swe-wf-viewer-open{opacity:1;visibility:visible}
.swe-wf-viewer-img{max-width:94vw;max-height:86vh;object-fit:contain;
  box-shadow:0 12px 40px rgba(0,0,0,.6);border-radius:4px}
.swe-wf-viewer-close{position:absolute;top:18px;right:22px;width:38px;height:38px;
  border-radius:50%;background:rgba(255,255,255,.1);border:1px solid rgba(255,255,255,.18);
  color:#fff;font-size:17px;cursor:pointer}
.swe-wf-viewer-close:hover{background:rgba(244,63,94,.32)}
.swe-wf-viewer-cap{color:#c7d5e0;font-size:13px;max-width:80vw;text-align:center;
  overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.swe-toolbar-toggle{width:38px;height:38px;border-radius:50%;border:1px solid transparent;
  background:transparent;color:#66c0f4;font-size:18px;cursor:pointer;flex:0 0 auto;
  display:flex;align-items:center;justify-content:center;
  transition:border-color .18s ease,background .18s ease}
.swe-toolbar-toggle:hover{border-color:#66c0f4;background:rgba(102,192,244,.12)}
.swe-detail-panel{background:rgba(27,40,56,.96);border:1px solid #3d5a73;border-radius:6px;
  padding:12px 14px;margin:10px 0;color:#c7d5e0;font-size:13px;
  font-family:'Motiva Sans','Noto Sans SC',Arial,sans-serif}
.swe-detail-panel h4{margin:0 0 8px;color:#66c0f4;font-size:13px}
.swe-detail-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(118px,1fr));gap:8px 14px}
.swe-detail-grid div{display:flex;flex-direction:column}
.swe-detail-grid .k{color:#7b8b9a;font-size:11px}
.swe-detail-grid .v{color:#e6f0f7;font-size:14px;font-weight:600}
.swe-tags{display:flex;flex-wrap:wrap;gap:6px;margin-top:10px}
.swe-tag{background:#22384c;border:1px solid #3d5a73;color:#9fd0f0;border-radius:3px;
  padding:2px 8px;font-size:11px;cursor:pointer;text-decoration:none}
.swe-tag:hover{background:#2c4a63;color:#fff}
.swe-detail-links{display:flex;gap:10px;margin-top:10px;flex-wrap:wrap}
.swe-detail-links a{color:#66c0f4;font-size:12px;text-decoration:none}
.swe-detail-links a:hover{text-decoration:underline}
.swe-toast{position:fixed;left:50%;transform:translateX(-50%);bottom:22px;z-index:2147483100;
  background:rgba(16,26,36,.96);border:1px solid #66c0f4;color:#e6f0f7;
  padding:9px 18px;border-radius:5px;font-size:13px;box-shadow:0 6px 22px rgba(0,0,0,.55);
  font-family:'Motiva Sans','Noto Sans SC',Arial,sans-serif}
.swe-status{color:#7b8b9a;font-size:11px}

/* ---------- 艺术作品页 ---------- */
/* 数据条：绝对定位到图片区底部、原生 meta 行上方（位置由 JS 实测几何算出） */
.swe-art-stats{position:absolute;left:8px;max-width:calc(100% - 16px);
  margin:0;padding:2px 6px;border-radius:3px;
  background:rgba(12,20,28,.72);backdrop-filter:blur(2px);
  z-index:4;pointer-events:none}
/* 操作按钮放在图片**右上角**——右下角是原生点赞/评分行，左上角空着 */
.swe-art-actions{position:absolute;top:8px;right:8px;z-index:6;
  display:flex;gap:6px;opacity:0;transition:opacity .15s ease}
.apphub_Card:hover .swe-art-actions{opacity:1}
.swe-art-actions button{background:rgba(16,26,36,.88);border:1px solid #66c0f4;color:#c7d5e0;
  border-radius:3px;padding:3px 8px;font-size:11px;cursor:pointer;
  font-family:'Motiva Sans','Noto Sans SC',Arial,sans-serif}
.swe-art-actions button:hover{background:#66c0f4;color:#04202e}
/* 批量复选框放在图片左上角（与右上角的操作按钮互不干扰） */
.swe-art-pick{position:absolute;top:8px;left:8px;z-index:7;width:20px;height:20px;
  display:none;align-items:center;justify-content:center;cursor:pointer;
  background:rgba(10,16,24,.82);border:1px solid #66c0f4;border-radius:3px}
.swe-art-batch-on .swe-art-pick{display:flex}
.swe-art-pick input{width:14px;height:14px;margin:0;cursor:pointer;accent-color:#66c0f4}
.swe-art-pick.on{background:rgba(102,192,244,.9)}
.swe-art-pick.on input{accent-color:#04202e}

/* ---------- 浏览页卡片悬浮操作 ---------- */
/* .swe-card-host 由脚本注入（容器类名哈希化，hover 选择器必须挂自己的标记类） */
.swe-card-actions{position:absolute;top:6px;right:6px;z-index:6;
  display:flex;gap:6px;opacity:0;transition:opacity .15s ease}
.swe-card-host:hover .swe-card-actions{opacity:1}
/* 悬浮按钮与「已订阅」角标同在右上角：hover 时角标淡出让位 */
.swe-card-host:hover .swe-badge-subscribed{opacity:.12}
.swe-badge-subscribed{transition:opacity .15s ease}
.swe-card-actions button{background:rgba(16,26,36,.88);border:1px solid #66c0f4;color:#c7d5e0;
  border-radius:3px;padding:3px 8px;font-size:11px;cursor:pointer;
  font-family:'Motiva Sans','Noto Sans SC',Arial,sans-serif}
.swe-card-actions button:hover{background:#66c0f4;color:#04202e}
.swe-card-actions button.swe-act-faved{border-color:#5cba6f;color:#5cba6f}
.swe-card-actions button.swe-act-faved:hover{background:#5cba6f;color:#04240f}

/* ---------- 模态（收藏夹管理器 / 订阅备份） ---------- */
.swe-modal-backdrop{position:fixed;inset:0;z-index:2147483200;background:rgba(6,10,16,.78);
  display:flex;align-items:center;justify-content:center;
  font-family:'Motiva Sans','Noto Sans SC',Arial,sans-serif}
.swe-modal{background:#1b2838;border:1px solid #3d5a73;border-radius:8px;color:#c7d5e0;
  width:min(860px,94vw);max-height:88vh;display:flex;flex-direction:column;
  box-shadow:0 12px 48px rgba(0,0,0,.7)}
.swe-modal-head{display:flex;align-items:center;justify-content:space-between;
  padding:12px 16px;border-bottom:1px solid #2a3f55}
.swe-modal-head h3{margin:0;font-size:14px;color:#66c0f4;font-weight:600}
.swe-modal-close{background:none;border:none;color:#8f98a0;font-size:20px;cursor:pointer;
  line-height:1;padding:2px 6px}
.swe-modal-close:hover{color:#fff}
.swe-modal-tools{display:flex;flex-wrap:wrap;gap:6px;align-items:center;padding:10px 16px;
  border-bottom:1px solid #2a3f55;font-size:12px}
.swe-modal-tools select,.swe-modal-tools input[type="text"],.swe-modal button,
.swe-modal textarea{background:#14202d;color:#c7d5e0;border:1px solid #3d5a73;
  border-radius:3px;padding:5px 8px;font-size:12px;font-family:inherit}
.swe-modal-tools input[type="text"]{min-width:170px}
.swe-modal button{cursor:pointer}
.swe-modal button:hover{border-color:#66c0f4;color:#fff}
.swe-modal button.swe-primary{background:linear-gradient(to bottom,#799905 5%,#536904 95%);
  color:#fff;border-color:#6a8b04;font-weight:600}
.swe-modal button.swe-danger{background:linear-gradient(to bottom,#a44141 5%,#803030 95%);
  color:#fff;border-color:#803030;font-weight:600}
.swe-modal button:disabled{opacity:.45;cursor:not-allowed}
.swe-modal-list{overflow-y:auto;padding:6px 16px;flex:1;min-height:120px}
.swe-modal-row{display:flex;gap:10px;align-items:center;padding:7px 4px;
  border-bottom:1px solid #22384c;font-size:12px}
.swe-modal-row:hover{background:rgba(102,192,244,.06)}
.swe-modal-row input[type="checkbox"]{accent-color:#66c0f4;cursor:pointer}
.swe-modal-row .swe-m-title{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;
  white-space:nowrap;color:#e6f0f7;text-decoration:none}
.swe-modal-row .swe-m-title:hover{color:#66c0f4}
.swe-modal-row .swe-m-meta{color:#7b8b9a;white-space:nowrap;font-size:11px}
.swe-modal-row .swe-m-upd{color:#f5a623;font-weight:700}
.swe-modal-empty{padding:28px 16px;text-align:center;color:#7b8b9a;font-size:13px}
.swe-modal-foot{padding:10px 16px;border-top:1px solid #2a3f55;display:flex;gap:8px;
  align-items:center;flex-wrap:wrap;font-size:12px}
.swe-modal .swe-hint{color:#7b8b9a;font-size:11px;line-height:1.5}
.swe-modal textarea{width:100%;min-height:120px;resize:vertical;box-sizing:border-box;
  font-family:Consolas,monospace;color:#e6f0f7}
.swe-modal-status{color:#7b8b9a;font-size:11px;flex:1;min-width:140px}
`;

    function injectCss() {
        try {
            if (typeof GM_addStyle === 'function') { GM_addStyle(CSS); return; }
        } catch (_) {}
        try {
            const st = global.document.createElement('style');
            st.id = 'swe-style';
            st.textContent = CSS;
            (global.document.head || global.document.documentElement).appendChild(st);
        } catch (_) {}
    }

    // ============================================================
    // 第 7 层：浏览页增强
    // ============================================================

    let toolbarEl = null;
    let toastTimer = null;

    function toast(msg, ms) {
        try {
            const doc = global.document;
            let t = doc.querySelector('.swe-toast');
            if (!t) {
                t = doc.createElement('div');
                t.className = 'swe-toast';
                doc.body.appendChild(t);
            }
            t.textContent = msg;
            t.style.display = 'block';
            clearTimeout(toastTimer);
            toastTimer = setTimeout(() => { t.style.display = 'none'; }, ms || 2600);
        } catch (_) {}
    }

    function ensurePositioned(container) {
        if (!container) return;
        const pos = getComputedStyle(container).position;
        if (pos === 'static' || pos === '') container.style.position = 'relative';
    }

    /**
     * 给一张卡片挂数据增强条。
     */
    function renderCardStats(card, detail, settings) {
        const c = card.container;
        if (!c || !c.querySelector) return;
        ensurePositioned(c);

        let bar = c.querySelector('.swe-card-stats');
        if (!bar) {
            bar = global.document.createElement('div');
            bar.className = 'swe-card-stats';
            c.appendChild(bar);
        }
        if (!detail) {
            bar.innerHTML = '<span class="swe-stat swe-loading">无数据</span>';
            // 关键：无论是否取到数据都要标记已处理，否则失败卡片会被无限重新入队、反复请求
            c.setAttribute('data-swe-processed', '1');
            return;
        }
        const now = Math.floor(Date.now() / 1000);
        const parts = [];
        parts.push('<span class="swe-stat">⬇ <b>' + formatCount(detail.subscriptions) + '</b> 订阅</span>');
        if (detail.favorited) parts.push('<span class="swe-stat">★ <b>' + formatCount(detail.favorited) + '</b> 收藏</span>');
        if (detail.views) parts.push('<span class="swe-stat">👁 <b>' + formatCount(detail.views) + '</b> 浏览</span>');
        if (detail.fileSize) parts.push('<span class="swe-stat">💾 <b>' + formatBytes(detail.fileSize) + '</b></span>');
        if (detail.timeUpdated) {
            const fresh = isRecentlyUpdated(detail.timeUpdated, now, RECENT_DAYS);
            parts.push('<span class="swe-stat' + (fresh ? ' swe-fresh' : '') + '">🕘 <b>' +
                formatRelative(detail.timeUpdated, now) + '</b>更新</span>');
        }
        bar.innerHTML = parts.join('');
        c.setAttribute('data-swe-processed', '1');
    }

    /** 已订阅 / 最近更新 角标 */
    function renderBadges(card, settings) {
        const c = card.container;
        if (!c || !c.querySelector) return;

        const d = loadCache()[card.id];
        const wantSub = settings.showSubscribedBadge && !!loadSubscribed()[card.id];
        const wantRecent = settings.showRecentBadge && d &&
            isRecentlyUpdated(d.timeUpdated, Math.floor(Date.now() / 1000), RECENT_DAYS);

        // 幂等：只有状态变化时才动 DOM，避免每次扫描都拆装节点
        const hasSub = !!c.querySelector('.swe-badge-subscribed');
        const hasRecent = !!c.querySelector('.swe-badge-recent');
        if (hasSub !== wantSub) {
            const old = c.querySelector('.swe-badge-subscribed');
            if (old) old.remove();
            if (wantSub) {
                const b = global.document.createElement('div');
                b.className = 'swe-badge-subscribed';
                b.textContent = '已订阅';
                c.appendChild(b);
            }
        }
        if (hasRecent !== wantRecent) {
            const old = c.querySelector('.swe-badge-recent');
            if (old) old.remove();
            if (wantRecent) {
                const b = global.document.createElement('div');
                b.className = 'swe-badge-recent';
                b.textContent = '刚更新';
                c.appendChild(b);
            }
        }
    }

    /** 预览图原图升级 */
    function upgradeCardImage(card, settings) {
        if (!settings.upgradePreview || !card.img) return;
        const src = card.img.getAttribute('src') || '';
        if (!src || src.indexOf('imw=') === -1) return;
        const up = upgradePreviewUrl(src);
        if (up && up !== src) {
            card.img.setAttribute('src', up);
            card.img.setAttribute('data-swe-orig', up);
        }
    }

    /** 复选框（批量模式） */
    function injectPicker(card, onToggle) {
        const c = card.container;
        if (!c || !c.querySelector) return;
        if (c.querySelector('.swe-pick')) return;
        ensurePositioned(c);
        const box = global.document.createElement('label');
        box.className = 'swe-pick';
        box.innerHTML = '<input type="checkbox">';
        c.appendChild(box);
        box.querySelector('input').addEventListener('change', (e) => {
            box.classList.toggle('on', e.target.checked);
            onToggle(card.id, e.target.checked);
        });
    }

    // ---------- 卡片悬浮操作（复制 ID / SteamCMD / 收藏） ----------
    // 参考自 aggs/Steam Workshop Mod Tool.js 的悬浮海报按钮，按本插件的锚点约定重写。

    /** 卡片所属 appid：优先创作者链接（/myworkshopfiles/?appid=），退回当前页 URL */
    function cardAppId(card) {
        if (card && card.creatorLink) {
            const appid = parseAppIdFromHref(card.creatorLink.getAttribute('href') || '');
            if (appid) return appid;
        }
        return currentAppId();
    }

    function updateFavButton(btn, faved) {
        if (!btn) return;
        btn.textContent = faved ? '✭ 已藏' : '⭐ 收藏';
        btn.classList.toggle('swe-act-faved', !!faved);
        btn.title = faved ? '从收藏夹移除' : '加入收藏夹';
    }

    /** 收藏 / 取消收藏一个条目（收藏时补拉详情写入元数据与更新基线快照） */
    async function favoriteEntry(id, appid, title, btn) {
        const list = loadFavList();
        if (list[id]) {
            delete list[id];
            saveFavList();
            updateFavButton(btn, false);
            toast('已从收藏夹移除');
            return false;
        }
        let detail = loadCache()[id];
        if (!detail || !toNum(detail.timeUpdated)) {
            try { detail = (await fetchDetails([id]))[id] || detail; } catch (_) {}
        }
        list[id] = mergeFavEntry(null, {
            id,
            appid: (detail && detail.appid) || appid || '',
            title: (detail && detail.title) || title || ('条目 ' + id),
            timeUpdatedAt: (detail && detail.timeUpdated) || 0,
            hasUpdate: false
        });
        saveFavList();
        updateFavButton(btn, true);
        toast('已加入收藏夹（共 ' + Object.keys(list).length + ' 项）');
        return true;
    }

    /** 给浏览页卡片注入右上角悬浮按钮组 */
    function injectCardActions(card) {
        const c = card.container;
        if (!c || !c.querySelector || !c.classList) return;
        if (c.querySelector('.swe-card-actions')) return;
        ensurePositioned(c);
        c.classList.add('swe-card-host');
        const box = global.document.createElement('div');
        box.className = 'swe-card-actions';
        box.innerHTML =
            '<button type="button" class="swe-act-cmd" title="复制 SteamCMD 命令">⚙ CMD</button>' +
            '<button type="button" class="swe-act-id" title="复制条目 ID"># ID</button>' +
            '<button type="button" class="swe-act-fav"></button>';
        c.appendChild(box);
        const appId = cardAppId(card);
        box.querySelector('.swe-act-cmd').addEventListener('click', (e) => {
            e.preventDefault(); e.stopPropagation();
            const cmd = buildSteamCmdCommand(appId, card.id);
            copyText(cmd);
            toast('已复制：' + cmd);
        });
        box.querySelector('.swe-act-id').addEventListener('click', (e) => {
            e.preventDefault(); e.stopPropagation();
            copyText(card.id);
            toast('已复制 ID：' + card.id);
        });
        const favBtn = box.querySelector('.swe-act-fav');
        updateFavButton(favBtn, !!loadFavList()[card.id]);
        favBtn.addEventListener('click', (e) => {
            e.preventDefault(); e.stopPropagation();
            favoriteEntry(card.id, appId, card.title, favBtn);
        });
    }

    /** 刷新页面上所有悬浮按钮的收藏态（收藏夹变动后调用） */
    function syncCardActionButtons() {
        const list = loadFavList();
        global.document.querySelectorAll('.swe-card-actions .swe-act-fav').forEach((btn) => {
            const host = btn.closest('.swe-card-host');
            if (!host) return;
            const link = host.querySelector(SEL_FILE_LINK);
            const id = link ? parseFileIdFromHref(link.getAttribute('href')) : '';
            if (id) updateFavButton(btn, !!list[id]);
        });
    }

    // ---------- 批量选择状态 ----------
    const picked = new Set();

    function setBatchMode(on) {
        saveSettings({ batchMode: !!on });
        try { global.document.body.classList.toggle('swe-batch-on', !!on); } catch (_) {}
        if (!on) {
            picked.clear();
            // 退出批量模式：移除已注入的复选框
            global.document.querySelectorAll('.swe-pick').forEach((b) => b.remove());
        } else {
            // 进入批量模式：给**已渲染**的卡片补注入复选框
            // （已处理过的卡片不会被 MutationObserver 再次触发，必须显式补）
            for (const card of scanCards(global.document).values()) {
                injectPicker(card, onPickToggle);
            }
        }
        syncPickers();
        updateToolbarCounts();
    }

    function updateToolbarCounts() {
        const el = global.document.querySelector('.swe-count');
        if (el) el.textContent = '已选 ' + picked.size + ' 项';
    }

    // ---------- 订阅动作 ----------
    function getSessionId() {
        // 经典页面：window.g_sessionID / SESSION_ID；cookie 兜底
        const w = global;
        try {
            const p = w.unsafeWindow || w;
            if (p && typeof p.g_sessionID === 'string' && p.g_sessionID) return p.g_sessionID;
            if (p && typeof p.SESSION_ID === 'string' && p.SESSION_ID) return p.SESSION_ID;
        } catch (_) {}
        try {
            const m = (global.document.cookie || '').match(/sessionid=([^;]+)/);
            if (m) return m[1];
        } catch (_) {}
        return '';
    }

    /**
     * 发送一次订阅 / 退订请求。
     *
     * 成败判定（2026-10-28 实测 + Steam 官方 workshop_functions.js 交叉验证）：
     *   · Steam 官方代码用 `response.success == 1` 判成功（失败走 default 分支弹错误框）
     *   · 实测未登录/参数缺失时返回 HTTP 401 + `{"success":2}` —— **2 是失败码**
     *   · 所以必须同时满足「HTTP 2xx」且「success == 1」才算成功。
     *     只看 HTTP 状态或只看 success 值都会误判（GF 手动订阅工具就栽在这）。
     *
     * @returns {Promise<{ok:boolean, status:number, success:number|null, body:string}>}
     */
    async function postWorkshopAction(path, id, appid, sessionid) {
        const body = 'id=' + encodeURIComponent(id) +
            '&appid=' + encodeURIComponent(appid || '') +
            '&include_dependencies=false' +
            '&sessionid=' + encodeURIComponent(sessionid || '');
        const res = await global.fetch('https://steamcommunity.com/sharedfiles/' + path, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                'X-Requested-With': 'XMLHttpRequest'
            },
            body,
            credentials: 'include'
        });
        const text = await res.text();
        let success = null;
        try {
            const j = JSON.parse(text);
            if (j && typeof j.success !== 'undefined') success = Number(j.success);
        } catch (_) {}
        return {
            ok: res.ok && success === 1,
            status: res.status,
            success,
            body: text
        };
    }

    /**
     * 批量订阅 / 退订。entries 支持每条自带 appid（导入备份时条目可能来自不同游戏）。
     */
    async function batchSubscribeEntries(entries, unsubscribe) {
        const list = (entries || []).filter(e => e && e.id);
        if (!list.length) { toast('请先勾选条目'); return; }
        const sid = getSessionId();
        if (!sid) { toast('未取到 sessionid，请先登录 Steam', 3600); return; }
        const path = unsubscribe ? 'unsubscribe' : 'subscribe';
        toast((unsubscribe ? '正在退订 ' : '正在订阅 ') + list.length + ' 项…', 6000);
        let ok = 0, fail = 0;
        for (const entry of list) {
            try {
                const res = await postWorkshopAction(path, entry.id, entry.appid || '', sid);
                if (res.ok) ok++;
                else fail++;
            } catch (e) { fail++; }
            await new Promise(r => setTimeout(r, 220)); // 轻限速，别打爆接口
        }
        // 订阅状态只属于订阅集 SUBS_KEY。
        // （修复：旧版退订时误把 FAV_KEY 整体刷成 false，污染收藏集且订阅角标不消失）
        const set = loadSubscribed();
        for (const entry of list) set[entry.id] = !unsubscribe;
        storeSet(SUBS_KEY, set);
        toast((unsubscribe ? '退订' : '订阅') + '完成：成功 ' + ok + '，失败 ' + fail, 4000);
        refreshBadges();
    }

    async function batchSubscribe(ids, appid, unsubscribe) {
        return batchSubscribeEntries((ids || []).map(id => ({ id, appid })), unsubscribe);
    }

    function refreshBadges() {
        const settings = loadSettings();
        for (const card of scanCards(global.document).values()) {
            renderBadges(card, settings);
        }
    }

    // ---------- 工具条 ----------

    /** 测试钩子：拦截整页跳转（jsdom 里 location.assign 只会报「未实现」，无法断言） */
    let navOverride = null;

    /**
     * 整页跳转。原生排序**必须**整页重载：
     * 2026-10-30 实测 `history.pushState` + `popstate` 不会让 React Router 重新取数
     * （queryKey / data 仍是旧值），只有真正 `location.assign` 才会重新请求。
     *
     * v1.8.1 假导航兜底：e2e 实测（app/4348910 深页码猎取）存在 assign 后「URL 已改、
     * 文档未重载」的假导航 —— 旧文档带着新 URL 继续存活，一切看似正常实则死掉
     * （这很可能就是用户看到的「整页灰掉未响应」的机制之一）。
     * 正常导航会销毁本文档，下面的 3 秒定时器永远不会执行；若 3 秒后仍活着，
     * 说明导航没真正发生 → 强制 location.replace 完成跳转。
     */
    function navigateTo(url) {
        if (!url) return false;
        if (toolbarEl) { try { toolbarEl.dataset.sweNavTarget = url; } catch (_) {} }
        if (typeof navOverride === 'function') {
            try { navOverride(url); } catch (_) {}
            return true;
        }
        let before = '';
        try { before = global.location.href; } catch (_) {}
        let assigned = false;
        try { global.location.assign(url); assigned = true; } catch (_) {}
        if (!assigned) {
            try { global.location.href = url; assigned = true; } catch (_) {}
        }
        if (assigned) {
            try {
                global.setTimeout(function () {
                    try {
                        const now = global.location.href;
                        // 仍在跳转前的页面（assign 完全失败）或 URL 已改但文档未重载（假导航）→ 强制重来
                        if (now === before || now === url) global.location.replace(url);
                    } catch (_) {}
                }, 3000);
            } catch (_) {}
        }
        return assigned;
    }

    /** 当前 URL 上的原生排序键（不在白名单内的一律视为「保持当前」） */
    function currentNativeSortKey() {
        const href = (global.location && global.location.href) || '';
        const key = readBrowseParams(href).browsesort || '';
        return NATIVE_SORT_OPTIONS.some(o => o.key === key) ? key : '';
    }

    /** SPA 内切页后把原生排序下拉与 URL 对齐 */
    function syncNativeSortUi() {
        if (!toolbarEl) return;
        const sel = toolbarEl.querySelector('.swe-native-sort');
        if (sel) sel.value = currentNativeSortKey();
    }

    function buildToolbar(kind) {
        if (toolbarEl) return toolbarEl;
        const settings = loadSettings();
        const doc = global.document;
        const bar = doc.createElement('div');
        bar.className = 'swe-toolbar';
        const grid = isGridPage(kind);
        // 原生排序 / 每页条数只在「浏览页网格」有意义：
        // /app/{id}/workshop/ 是分区展示页，没有分页控件也没有原生排序下拉。
        const sortSec = grid
            ? '  <div class="swe-sec"><div class="swe-sec-t">原生排序</div>' +
              '  <div class="swe-row"><span>排序</span><select class="swe-native-sort" title="服务端排序，跨页生效；切换会整页重新加载">' +
              NATIVE_SORT_OPTIONS.map(o => '<option value="' + o.key + '">' + o.label + '</option>').join('') +
              '  </select></div>' +
              '  <div class="swe-row"><span>跨页</span><button class="swe-native-5star" title="跳到 Steam 原生「最受好评」，并在每页隐藏非 5★">看 5★</button></div>' +
              '</div>'
            : '';
        const pageSec = grid
            ? '  <div class="swe-sec"><div class="swe-sec-t">每页条数</div>' +
              '  <div class="swe-row"><span>条数</span><select class="swe-pp" title="10/15/30/50 由 Steam 服务端原生分页；100/200 由插件跨页聚合实现">' +
              PAGE_SIZES.map(n => '<option value="' + n + '">' + n + '</option>').join('') +
              '  </select></div>' +
              '  <div class="swe-row swe-agg-row" style="display:none">' +
              '    <button class="swe-agg-prev" title="上一组">‹</button>' +
              '    <span class="swe-agg-info"></span>' +
              '    <button class="swe-agg-next" title="下一组">›</button></div>' +
              '</div>'
            : '';
        bar.innerHTML =
            '<div class="swe-panel" style="display:none">' +
            '  <div class="swe-panel-head"><span class="swe-panel-title">创意工坊增强</span>' +
            '    <button class="swe-panel-collapse" title="收起面板">−</button></div>' +
            '  <div class="swe-panel-body">' +
            '  <div class="swe-sec"><div class="swe-sec-t">排序筛选</div>' +
            '  <div class="swe-row"><span class="swe-filter-note">排序请用右侧「原生排序」</span></div>' +
            '  <div class="swe-row"><span>星级</span><select class="swe-stars">' +
            STAR_FILTER_OPTIONS.map(o => '<option value="' + o.key + '">' + o.label + '</option>').join('') +
            '  </select></div>' +
            '  <div class="swe-row"><span>最低票数</span><input class="swe-minvotes" type="number" min="0" step="5" placeholder="不限"></div>' +
            '  <div class="swe-row"><span class="swe-filter-status"></span></div>' +
            '</div>' +
            sortSec +
            pageSec +
            '  <div class="swe-sec"><div class="swe-sec-t">批量</div>' +
            '  <div class="swe-row"><span class="swe-count">已选 0 项</span>' +
            '    <button class="swe-select-all">全选本页</button></div>' +
            '  <div class="swe-row swe-row-2"><button class="swe-invert">反选</button>' +
            '    <button class="swe-clear">清空</button></div>' +
            '  <div class="swe-row swe-row-2"><button class="swe-primary swe-sub">批量订阅</button>' +
            '    <button class="swe-danger swe-unsub">批量退订</button></div>' +
            '  <div class="swe-row"><select class="swe-export-mode">' +
            EXPORT_MODES.map(o => '<option value="' + o.key + '">' + o.label + '</option>').join('') +
            '    </select><button class="swe-export-copy">复制选中</button></div>' +
            '</div>' +
            '  <div class="swe-sec"><div class="swe-sec-t">工具</div>' +
            '  <div class="swe-row swe-row-2"><button class="swe-fav-mgr">⭐ 收藏夹</button>' +
            '    <button class="swe-backup">备份/还原</button></div>' +
            '  <div class="swe-row swe-row-2"><button class="swe-batch-toggle">批量模式</button>' +
            '    <button class="swe-preview">原图预览</button></div>' +
            '</div>' +
            '  <div class="swe-hint">筛选与排序作用于当前页（星级 0 命中时自动翻下一页找）；原生排序跨页生效。' +
            '每页 <b>10/15/30/50</b> 走 Steam 服务端原生分页，<b>100/200</b> 由插件跨页聚合。' +
            '批量订阅需登录 Steam。</div>' +
            '  </div>' +
            '</div>' +
            '<button class="swe-toolbar-toggle" title="创意工坊增强（拖动图标组可贴到窗口边缘，双击可复位）">⚙</button>';
        doc.body.appendChild(bar);
        toolbarEl = bar;
        // 浮动图标组：装上拖拽 + 恢复上次贴边位置
        initDock(bar);

        const panel = bar.querySelector('.swe-panel');
        const toggle = bar.querySelector('.swe-toolbar-toggle');
        toggle.addEventListener('click', () => {
            const open = panel.style.display === 'none';
            panel.style.display = open ? 'flex' : 'none';
            if (open) fitDockPanel(bar);
        });

        // v1.8.3：页内客户端排序（applyClientSort）已移除 ——
        // appendChild 重排 React 拥有的网格子节点会破坏 reconciliation，
        // 之后任何一次 React 更新都会节点错位/区块清空（用户实测：物品页挤成两列、
        // 主页分区直接空白且不可自愈）。排序统一走服务端「原生排序」（跨页生效、无损）。

        // 星级筛选 / 最低票数（作用域 = 当前页）
        const starSel = bar.querySelector('.swe-stars');
        const votesInp = bar.querySelector('.swe-minvotes');
        starSel.value = settings.starFilter || 'all';
        votesInp.value = toNum(settings.minVotes) ? String(toNum(settings.minVotes)) : '';
        const applyStarFilterUi = (announce) => {
            saveSettings({
                starFilter: starSel.value || 'all',
                minVotes: Math.max(0, toNum(votesInp.value) || 0)
            });
            // 用户主动改档位 = 重新声明意图：清掉旧远征（0 命中时猎取会按新档位重开）
            starHuntClear();
            const r = applyStarFilter();
            // v1.8.0：本页 0 命中 → 自动翻下一页继续找
            maybeScheduleStarHunt(r);
            if (announce) {
                toast('星级筛选：显示 ' + r.shown + ' / ' + r.total + ' 条' +
                    (r.shown === 0 ? '，本页无匹配，将自动检查下一页' : ''), 2400);
            }
        };
        starSel.addEventListener('change', () => applyStarFilterUi(true));
        votesInp.addEventListener('change', () => applyStarFilterUi(true));

        // 原生排序（服务端排序，跨页生效）。实测只有 toprated / lastupdated / trend 有效，
        // 其余 key 会被服务端归一成 trend，所以白名单里不放 —— 切换必然整页重载。
        // 注意：非网格页（/app/{id}/workshop/）不渲染这两项 → 必须判空，
        // 否则这里抛错会中断 buildToolbar 剩余的监听绑定，enhanceBrowsePage 也不会被调用。
        const natSel = bar.querySelector('.swe-native-sort');
        if (natSel) {
            natSel.value = currentNativeSortKey();
            natSel.addEventListener('change', () => {
                const key = natSel.value;
                if (!key) return;
                const url = buildNativeSortUrl(global.location.href, key);
                if (!url) { toast('原生排序：无法构造跳转地址'); return; }
                const label = (NATIVE_SORT_OPTIONS.find(o => o.key === key) || {}).label || key;
                toast('按「' + label + '」重新加载…', 1600);
                navigateTo(url);
            });
        }

        // 跨页看 5★：原生 toprated 排序 + 当前页再筛一刀。
        // toprated 前几页几乎全是 5★，但深处的页会混 4★，服务端没有「仅 5★」这种筛选。
        const native5 = bar.querySelector('.swe-native-5star');
        if (native5) native5.addEventListener('click', () => {
            saveSettings({ starFilter: '5', minVotes: 0 });
            starSel.value = '5';
            votesInp.value = '';
            starHuntClear();   // 新远征：跳到 toprated 后由猎取接手 0 命中的页
            if (readBrowseParams(global.location.href).browsesort === 'toprated') {
                const r = applyStarFilter();
                maybeScheduleStarHunt(r);
                toast('已隐藏本页非 5★：显示 ' + r.shown + ' / ' + r.total + ' 条' +
                    (r.shown === 0 ? '，将自动检查下一页' : ''), 2600);
                return;
            }
            const url = buildNativeSortUrl(global.location.href, 'toprated');
            if (!url) { toast('无法构造跳转地址'); return; }
            toast('跳转「最受好评」并自动只看 5★…', 2600);
            navigateTo(url);
        });

        // 每页条数（2026-10-30 实测修正）：
        //   服务端只接受 num_per_page ∈ {10,15,30,50}，其它值被静默归一成 30
        //   （客户端 SPA 自己用的也是这四个：rgNumPerPageOptions ?? [10,15,30,50]）。
        //   → ≤50 走服务端原生分页；>50 由插件跨页聚合实现（runAggregate）。
        const ppSel = bar.querySelector('.swe-pp');
        if (ppSel) {
            ppSel.value = String(settings.perPage || 30);
            ppSel.addEventListener('change', async () => {
                const n = toNum(ppSel.value) || 30;
                saveSettings({ perPage: n });
                const plan = buildAggregatePlan(n);
                if (plan.mode === 'server') {
                    // 服务端原生分页：写 URL 参数整页重载，翻页/总数都由 Steam 负责
                    const u = new URL(global.location.href);
                    u.searchParams.set('num_per_page', String(plan.serverSize));
                    u.searchParams.set('p', '1');
                    navigateTo(u.toString());
                    return;
                }
                // 聚合模式：服务端按 50 条一页取数，插件把后续几页合并进同一网格
                const u = new URL(global.location.href);
                u.searchParams.set('num_per_page', String(plan.serverSize));
                u.searchParams.set('p', '1');
                toast('正在聚合 ' + n + ' 条（服务端单页上限 50，需抓取 ' + plan.pages + ' 页）…', 2400);
                await navigateTo(u.toString());
                const r = await runAggregate(n);
                if (r.ok) {
                    toast('已聚合 ' + (aggState.ids.length) + ' 条', 2600);
                    updateAggregatePager();
                } else {
                    toast('聚合失败：' + (r.error || '未知原因'), 3600);
                }
            });
        }

        // 聚合模式的翻页（原生分页器在聚合模式下由插件接管）
        const aggPrev = bar.querySelector('.swe-agg-prev');
        const aggNext = bar.querySelector('.swe-agg-next');
        if (aggPrev) aggPrev.addEventListener('click', () => navigateAggregate(-1));
        if (aggNext) aggNext.addEventListener('click', () => navigateAggregate(1));

        // 批量
        bar.querySelector('.swe-select-all').addEventListener('click', () => {
            // 只选可见卡片：被星级筛选隐藏的条目不该被「全选」带进批量操作
            for (const [id, card] of scanCards(global.document)) {
                if (!isHiddenCard(card)) picked.add(id);
            }
            syncPickers();
        });
        bar.querySelector('.swe-invert').addEventListener('click', () => {
            for (const [id, card] of scanCards(global.document)) {
                if (isHiddenCard(card)) continue;
                if (picked.has(id)) picked.delete(id); else picked.add(id);
            }
            syncPickers();
        });
        bar.querySelector('.swe-clear').addEventListener('click', () => {
            picked.clear();
            syncPickers();
        });
        bar.querySelector('.swe-sub').addEventListener('click', () => {
            batchSubscribe(Array.from(picked), currentAppId(), false);
        });
        bar.querySelector('.swe-unsub').addEventListener('click', () => {
            batchSubscribe(Array.from(picked), currentAppId(), true);
        });
        const bt = bar.querySelector('.swe-batch-toggle');
        bt.addEventListener('click', () => {
            const on = !loadSettings().batchMode;
            setBatchMode(on);
            bt.textContent = on ? '退出批量' : '批量模式';
        });
        bar.querySelector('.swe-preview').addEventListener('click', () => {
            const on = !loadSettings().upgradePreview;
            saveSettings({ upgradePreview: on });
            toast(on ? '已切换为原图预览（刷新后完全生效）' : '已恢复默认预览图（刷新后完全生效）', 3200);
        });

        // 导出选中：按格式构造文本并复制（元数据优先用缓存详情）
        bar.querySelector('.swe-export-copy').addEventListener('click', async () => {
            const mode = bar.querySelector('.swe-export-mode').value;
            const ids = Array.from(picked);
            if (!ids.length) { toast('请先勾选条目'); return; }
            let details = {};
            try { details = await fetchDetails(ids); } catch (_) {}
            const entries = ids.map(id => {
                const d = details[id] || {};
                return {
                    id,
                    title: d.title || '',
                    appid: d.appid || currentAppId(),
                    timeUpdated: d.timeUpdated || 0
                };
            });
            const text = buildExportText(mode, entries, currentAppId());
            if (!text) { toast('导出失败：无内容'); return; }
            copyText(text);
            toast('已复制 ' + entries.length + ' 项（' +
                ((EXPORT_MODES.find(o => o.key === mode) || {}).label || mode) + '）', 3000);
        });

        bar.querySelector('.swe-fav-mgr').addEventListener('click', () => openFavManager());
        bar.querySelector('.swe-backup').addEventListener('click', () => openBackupModal());

        if (settings.batchMode) setBatchMode(true);
        bt.textContent = settings.batchMode ? '退出批量' : '批量模式';
        return bar;
    }

    function syncPickers() {
        global.document.querySelectorAll('.swe-pick').forEach((box) => {
            const inp = box.querySelector('input');
            if (!inp) return;
            const card = box.parentElement;
            const link = card && card.querySelector(SEL_FILE_LINK);
            const id = link ? parseFileIdFromHref(link.getAttribute('href')) : '';
            const on = !!id && picked.has(id);
            inp.checked = on;
            box.classList.toggle('on', on);
        });
        updateToolbarCounts();
    }

    function currentAppId() {
        const p = readBrowseParams(global.location.href);
        if (p.appid) return p.appid;
        // /app/{appid}/… 形式（截图页 / 艺术作品页 / 游戏创意工坊首页）。
        // 2026-10-31 实测：这些页面的 URL 里**没有 appid 参数**，
        // 少了这一兜底就会返回空串 → 翻页 URL 拼成 /app//homecontent/ → 404 →
        // 「加载更多」永远加载不出来（还会被静默当成"已加载完"）。
        const m = ((global.location && global.location.pathname) || '').match(/\/app\/(\d+)/);
        if (m) return m[1];
        // 从「我的项目」页面的 appid 参数取
        const link = global.document.querySelector('a[href*="appid="]');
        return link ? parseAppIdFromHref(link.getAttribute('href')) : '';
    }

    // v1.8.3：页内客户端排序 applyClientSort 已整体移除。
    // 原因：新版工坊网格子节点由 React 拥有，appendChild 重排会让虚拟树与真实 DOM
    // 顺序失配，此后任何一次 React 更新（切页/刷新/筛选）做 reconciliation 都会
    // 节点错位/丢失/重复 —— 实测物品页卡片挤成两列窄条、主页分区直接空白，且无法
    // 自愈。排序统一走「原生排序」（browsesort，服务端排序，跨页生效、零损伤）。
    // sortEntries（纯函数）保留供单测与未来安全场景复用。

    // ---------- 星级筛选（页内） ----------
    // SSR 星级/票数解析结果按 URL 缓存：要递归遍历整份 React Query 快照，不能每次扫描都重解析；
    // SPA 内翻页后 URL 变化 → 重新读一次（此时快照可能还是首屏的，匹配不到就自然降级为「票数未知」）。
    let ssrStarCache = { href: '', map: null };

    function getSsrStarMap(doc) {
        const href = (global.location && global.location.href) || '';
        if (ssrStarCache.map && ssrStarCache.href === href) return ssrStarCache.map;
        // 油猴沙箱里 window 不是页面 window，必须显式走 unsafeWindow 才能看到 SSR 全局
        let pageWin = global;
        try { pageWin = global.unsafeWindow || global; } catch (_) {}
        const map = readSsrStarData(doc || global.document, pageWin);
        // 合并聚合模式额外抓到的页的星级快照（否则聚合进来的卡片会被当成「票数未知」）
        if (aggState.stars && aggState.stars.size) {
            for (const [id, v] of aggState.stars) {
                if (!map.has(id)) map.set(id, v);
            }
        }
        ssrStarCache = { href, map };
        return map;
    }

    function isHiddenCard(card) {
        return !!(card && card.container && card.container.classList &&
            card.container.classList.contains('swe-card-hidden'));
    }

    function updateFilterStatus(total, shown, active) {
        const el = global.document.querySelector('.swe-filter-status');
        if (!el) return;
        let text = active
            ? '本页 ' + total + ' 条 · 显示 ' + shown + ' 条'
            : '本页 ' + total + ' 条';
        // v1.8.0：0 命中时补充「星级猎取」进展说明
        if (active && shown === 0 && starHuntNote) text += '（' + starHuntNote + '）';
        if (el.textContent !== text) el.textContent = text;
    }

    /**
     * 按设置给当前页卡片打/摘「隐藏」标记（幂等，可被 MutationObserver 反复调用）。
     * 隐藏用类名 + CSS display:none，不删节点 —— React 重渲染能自然恢复。
     * @returns {{total:number, shown:number, hidden:number, active:boolean}}
     */
    function applyStarFilter() {
        const settings = loadSettings();
        const active = (settings.starFilter || 'all') !== 'all' || toNum(settings.minVotes) > 0;
        const cards = scanCards(global.document);
        const ssrMap = active ? getSsrStarMap(global.document) : null;
        let shown = 0, hidden = 0, pruned = false;
        for (const card of cards.values()) {
            const c = card.container;
            if (!c || !c.classList) continue;
            const wasHidden = c.classList.contains('swe-card-hidden');
            const keep = !active || passStarFilter(ratingInfo(card, ssrMap), settings);
            if (keep) {
                if (wasHidden) c.classList.remove('swe-card-hidden');
                shown++;
            } else {
                if (!wasHidden) c.classList.add('swe-card-hidden');
                hidden++;
                // 被筛掉的卡片不能留在勾选集里，否则批量订阅会带上看不见的条目
                if (picked.has(card.id)) { picked.delete(card.id); pruned = true; }
            }
        }
        if (pruned) syncPickers();
        // v1.8.1：筛选激活时给网格容器打标。
        // 隐藏大部分卡片后网格内容只剩一两行，而 Steam 的内容区带 min-height ——
        // 网格默认 align-content:stretch 会把富余高度分给唯一的行轨道，
        // 卡片随行被纵向拉成一根长条（用户截图实测）。CSS 侧按此标记改为顶对齐。
        let gridEl = gridFromCards(cards);
        if (!gridEl) {
            // 单卡页面：gridFromCards 因 bestN≤1 返回 null，退回卡片直接父节点
            const first = cards.values().next().value;
            gridEl = (first && first.container) ? first.container.parentElement : null;
        }
        if (gridEl) {
            const flag = active ? '1' : '0';
            if (gridEl.getAttribute('data-swe-grid-filtered') !== flag) {
                gridEl.setAttribute('data-swe-grid-filtered', flag);
            }
        }
        updateFilterStatus(cards.size, shown, active);
        return { total: cards.size, shown, hidden, active };
    }

    // ---------- 星级猎取（本页 0 命中时自动翻下一页继续筛，v1.8.0） ----------
    //
    // 用户反馈：点「仅 5 星」后整页空白。星级筛选只作用于当前页，本页一张 5★ 都没有
    // 时所有卡片被 display:none 清空 → 新版工坊只剩背景大图，看起来整个页面「灰掉」。
    //
    // 方案：筛选生效且本页 0 命中时，自动把 URL 的 p 推进到下一服务端页（其余参数
    // 原样保留），整页加载后重新筛 —— 直到找到命中页，或触发任一停止条件：
    //   · 已是服务端最后一页（SSR total_pages；读不到时靠跳页次数上限兜底）；
    //   · 本次「远征」累计自动跳页达上限（STAR_HUNT_MAX_HOPS）；
    //   · 用户改了星级档位 / 换了结果集（appid、排序、分区、搜索词任一变化）→ 远征重置。
    //
    // 远征状态存 localStorage（持久化）：跳页是整页加载，状态必须跨文档存活。
    // v1.8.1 实测教训：e2e（headless/假导航环境）里 sessionStorage 的写入**跨文档全部
    // 丢失**（每个新文档读到 null → hops 永远从 0 重计 → 无限假导航循环），localStorage 无此问题。
    // 读取/写入不可用或写入回读校验失败时**禁用**猎取 —— 绝不在无状态下盲跳：
    // 那样每页都从 hops=0 重新计数，等于无限重定向循环（页面永远在加载、始终灰着）。
    const STAR_HUNT_KEY = PREFIX + '_star_hunt';
    const STAR_HUNT_MAX_HOPS = 20;
    const STAR_HUNT_DELAY_MS = 1200;   // 延迟确认：等 React 把星级 SVG 画完、MutationObserver 收尾
    // 看门狗：排程后超过此窗口仍未触发 → 视为定时器丢失（后台节流/极端情况），重新排程。
    // e2e 实测（app/4348910）出现过「状态已排程但定时器 150s 未触发」的卡死，自愈兜底。
    const STAR_HUNT_WATCHDOG_MS = 15000;
    /** 参与自动翻页的星级档位（'all' 不参与；纯最低票数不参与——票数快照可能过期） */
    const STAR_HUNT_MODES = ['rated', '3', '4', '5'];

    let starHuntTimer = null;      // 本页的延迟确认定时器（SPA 切页时清理）
    let starHuntTimerAt = 0;       // 排程时刻（看门狗判定用）
    let starHuntNavLock = false;   // 已发起跳页（防同页重复导航）
    let starHuntBroken = false;    // sessionStorage 不可用/写不进 → 本会话禁用猎取
    let starHuntNote = '';         // 筛选状态行的补充说明（自动翻页中/已停止）

    function starHuntSupported() {
        try {
            const ls = global.localStorage;
            if (!ls || typeof ls.getItem !== 'function' || typeof ls.setItem !== 'function') return false;
            const k = PREFIX + '_probe';
            ls.setItem(k, '1');
            ls.removeItem(k);
            return true;
        } catch (_) { return false; }
    }

    function starHuntRead() {
        try {
            return JSON.parse(global.localStorage.getItem(STAR_HUNT_KEY) || 'null');
        } catch (_) { return null; }
    }

    /** 写入并回读校验；失败返回 false（调用方必须放弃猎取，防止无状态盲跳） */
    function starHuntWrite(st) {
        try {
            global.localStorage.setItem(STAR_HUNT_KEY, JSON.stringify(st));
            const back = starHuntRead();
            if (!back || back.sig !== st.sig || back.base !== st.base || toNum(back.hops) !== toNum(st.hops)) {
                starHuntBroken = true;
                return false;
            }
            return true;
        } catch (_) { starHuntBroken = true; return false; }
    }

    function starHuntClear() {
        try { global.localStorage.removeItem(STAR_HUNT_KEY); } catch (_) {}
        starHuntNote = '';
    }

    /** 远征签名：星级档位 + 最低票数（任一变化 = 新远征） */
    function starHuntSig(settings) {
        const s = settings || {};
        return String(s.starFilter || 'all') + '|' + (toNum(s.minVotes) || 0);
    }

    /** 远征作用域：URL 去掉 p 与 hash（appid/排序/分区/搜索词变了 = 换结果集） */
    function starHuntBase(href) {
        try {
            const u = new URL(href, 'https://steamcommunity.com');
            u.searchParams.delete('p');
            u.hash = '';
            return u.toString();
        } catch (_) { return String(href || ''); }
    }

    /** 构造下一页 URL（只改 p，其余参数原样保留） */
    function buildNextPageUrl(href, nextP) {
        let u;
        try { u = new URL(href, 'https://steamcommunity.com'); } catch (_) { return ''; }
        u.searchParams.set('p', String(toNum(nextP) || 1));
        return u.toString();
    }

    /**
     * 从 hydrate 后的 window.SSR 里读 workshop_browse 的分页总数。
     * 与 readSsrStarData 同一数据源（queryData），走精确路径而非通用遍历。
     * @returns {{totalPages:number, totalCount:number}|null}
     */
    function readSsrBrowseTotalsFromWin() {
        let w = global;
        try { w = global.unsafeWindow || global; } catch (_) {}
        try {
            let qd = w && w.SSR && w.SSR.renderContext && w.SSR.renderContext.queryData;
            if (!qd) return null;
            if (typeof qd === 'string') qd = JSON.parse(qd);
            if (!qd || !Array.isArray(qd.queries)) return null;
            for (const q of qd.queries) {
                if (!q || !q.queryKey || q.queryKey[0] !== 'workshop_browse') continue;
                const d = (q.state && q.state.data) || {};
                return { totalPages: toNum(d.total_pages) || 0, totalCount: toNum(d.total_count) || 0 };
            }
        } catch (_) {}
        return null;
    }

    function starHuntLabel(settings) {
        const key = String((settings && settings.starFilter) || '');
        const o = STAR_FILTER_OPTIONS.find(x => x.key === key);
        return (o && o.label) || key;
    }

    function setStarHuntNote(text, total, shown) {
        starHuntNote = text || '';
        updateFilterStatus(total, shown, true);
    }

    /**
     * 筛选后 0 命中时安排一次「猎取」：延迟确认（星星可能还没画完）→ 仍 0 命中才跳页。
     * 由 enhanceBrowsePage（MutationObserver 反复触发）与筛选下拉调用，幂等。
     * @param {{total:number, shown:number, active:boolean}} result applyStarFilter 的返回值
     */
    function maybeScheduleStarHunt(result) {
        if (starHuntNavLock) return;   // 已跳页
        // 看门狗：排程后长时间未触发（后台节流等导致定时器丢失）→ 清掉重新排程。
        // confirm 触发时会重读当前 URL/DOM/远征状态，重复排程无副作用。
        if (starHuntTimer && Date.now() - starHuntTimerAt > STAR_HUNT_WATCHDOG_MS) {
            try { clearTimeout(starHuntTimer); } catch (_) {}
            starHuntTimer = null;
        }
        if (starHuntTimer) return;   // 本页已安排过
        if (pageKind() !== 'browse') return;            // 分区页/艺术页没有服务端分页，不猎取
        if (aggState.active) return;                    // 聚合模式有自己的翻页语义，不掺和
        if (!result || !result.active || result.total <= 0) return;
        const settings = loadSettings();
        if (STAR_HUNT_MODES.indexOf(String(settings.starFilter)) < 0) return;
        // 纯检查都过了才碰 sessionStorage（探针有 IO，MutationObserver 调用很频繁）
        if (starHuntBroken || !starHuntSupported()) return;
        const sig = starHuntSig(settings);
        const base = starHuntBase(global.location.href);
        const st = starHuntRead();
        if (result.shown > 0) {
            // 命中：若这一页是「跳过来的」（远征 hops>0），报捷并清状态
            if (st && st.sig === sig && st.base === base && !st.done && toNum(st.hops) > 0) {
                toast('已自动跳过 ' + st.hops + ' 页找到「' + starHuntLabel(settings) + '」（本页 ' + result.shown + ' 条）', 3600);
                starHuntClear();
            }
            return;
        }
        // —— 以下为本页 0 命中 ——
        if (!st || st.sig !== sig || st.base !== base) {
            // 新远征：先落盘再排程 —— 写不进去就整个放弃（防无状态盲跳循环）
            if (!starHuntWrite({ sig: sig, base: base, hops: 0, done: false })) return;
        } else if (st.done) {
            setStarHuntNote('已停止自动翻页，可将星级改回「全部」', result.total, result.shown);
            return;
        }
        setStarHuntNote('本页无匹配，稍后自动检查下一页…', result.total, result.shown);
        starHuntTimerAt = Date.now();
        starHuntTimer = setTimeout(() => {
            starHuntTimer = null;
            starHuntConfirm();
        }, STAR_HUNT_DELAY_MS);
    }

    /** 延迟确认：重新筛一遍（此时星星应已画完），仍 0 命中才真正跳下一页 */
    function starHuntConfirm() {
        if (starHuntNavLock || starHuntBroken) return;
        const settings = loadSettings();
        if (STAR_HUNT_MODES.indexOf(String(settings.starFilter)) < 0) { starHuntClear(); return; }
        const r = applyStarFilter();
        if (!r.active || r.shown > 0) {
            // 有货了（或筛选已失效）→ 远征完成
            const st = starHuntRead();
            if (st && toNum(st.hops) > 0) {
                toast('已自动跳过 ' + st.hops + ' 页找到「' + starHuntLabel(settings) + '」（本页 ' + r.shown + ' 条）', 3600);
            }
            starHuntClear();
            return;
        }
        if (pageKind() !== 'browse' || aggState.active) return;
        const href = global.location.href;
        const cur = readBrowseParams(href).p || 1;
        // SSR 给出总页数时服从它：超界会被服务端钳到最后一页，继续跳只会原地打转
        const totals = readSsrBrowseTotalsFromWin();
        if (totals && totals.totalPages > 0 && cur >= totals.totalPages) {
            starHuntGiveUp(r, '已是最后一页');
            return;
        }
        const sig = starHuntSig(settings);
        const base = starHuntBase(href);
        const st = starHuntRead();
        if (st && st.done && st.sig === sig && st.base === base) { starHuntGiveUp(r, ''); return; }
        const hops = (st && st.sig === sig && st.base === base) ? toNum(st.hops) : 0;
        if (hops >= STAR_HUNT_MAX_HOPS) { starHuntGiveUp(r, '已连续检查 ' + hops + ' 页'); return; }
        // 先落盘再跳：写不进去（回读校验失败）→ 放弃本次跳页
        if (!starHuntWrite({ sig: sig, base: base, hops: hops + 1, done: false })) return;
        const nextUrl = buildNextPageUrl(href, cur + 1);
        if (!nextUrl) return;
        starHuntNavLock = true;
        toast('本页 0 条「' + starHuntLabel(settings) + '」，自动跳第 ' + (cur + 1) + ' 页继续筛选…', 3200);
        navigateTo(nextUrl);
    }

    /** 放弃远征：落盘 done 标记（同一结果集不再自动跳），状态行与 toast 说明 */
    function starHuntGiveUp(result, reason) {
        const settings = loadSettings();
        const st = starHuntRead();
        const hops = (st && toNum(st.hops)) || 0;
        starHuntWrite({
            sig: starHuntSig(settings),
            base: starHuntBase(global.location.href),
            hops: hops,
            done: true
        });
        const msg = '连续 ' + hops + ' 页无「' + starHuntLabel(settings) + '」' +
            (reason ? '（' + reason + '）' : '') + '，已停止自动翻页；可将星级改回「全部」';
        toast(msg, 4200);
        setStarHuntNote('已停止自动翻页', result ? result.total : 0, result ? result.shown : 0);
    }

    // ---------- 卡片数据增强主流程 ----------
    const pendingCards = new Map();
    let flushTimer = null;
    // （v1.8.3：客户端重排已移除，sorting 重入保护随之删除）
    let enhancing = false; // 扫描/增强的重入保护

    function queueCard(card, settings) {
        if (!card || !card.container) return;
        if (card.container.getAttribute('data-swe-processed')) return;
        pendingCards.set(card.id, card);
        if (pendingCards.size >= CARD_BATCH_SIZE) { flushCards(settings); return; }
        if (!flushTimer) {
            flushTimer = setTimeout(() => flushCards(loadSettings()), CARD_BATCH_WAIT_MS);
        }
    }

    async function flushCards(settings) {
        clearTimeout(flushTimer);
        flushTimer = null;
        if (!pendingCards.size) return;
        const batch = Array.from(pendingCards.values());
        pendingCards.clear();
        const ids = batch.map(c => c.id);
        let details = {};
        try { details = await fetchDetails(ids); }
        catch (_) { details = {}; }
        for (const card of batch) {
            renderCardStats(card, details[card.id] || null, settings);
            renderBadges(card, settings);
            if (settings.batchMode) injectPicker(card, onPickToggle);
        }
    }

    function onPickToggle(id, on) {
        if (on) picked.add(id); else picked.delete(id);
        updateToolbarCounts();
    }

    // ============================================================
    // 第 8 层：详情页增强
    // ============================================================

    let detailPanelFor = '';   // 已注入数据面板的条目 id

    function enhanceDetailPage() {
        const doc = global.document;
        if (!doc) return;
        // hydration 未完成时禁止注入 DOM
        if (!gateOpen('detail')) return;
        // 条目 id：页面全局变量优先
        let id = '';
        try {
            const p = global.unsafeWindow || global;
            if (p && p.publishedfileid) id = String(p.publishedfileid);
        } catch (_) {}
        if (!id) {
            const link = doc.querySelector(SEL_FILE_LINK);
            if (link) id = parseFileIdFromHref(link.getAttribute('href'));
        }
        // 再兜底：详情页 URL 本身就带 ?id=
        if (!id) {
            try { id = parseFileIdFromHref(global.location.href); } catch (_) {}
        }
        if (!id) return;
        // 同一个条目只注入一次；换条目时清掉旧面板
        const old = doc.querySelector('.swe-detail-panel');
        if (old) {
            if (detailPanelFor === id) return;   // 已有且是同一个 → 不重复
            old.remove();
        }
        detailPanelFor = id;

        let appid = '';
        const ctn = doc.getElementById('sharedfiles_content_ctn');
        if (ctn && ctn.getAttribute('data-miniprofile-appid')) appid = ctn.getAttribute('data-miniprofile-appid');

        fetchDetails([id]).then(details => {
            const d = details[id];
            if (!d) { detailPanelFor = ''; return; }
            // 异步返回时页面可能已经切走 —— 确认还在同一个条目上再注入
            if (detailPanelFor !== id) return;
            const panel = doc.createElement('div');
            panel.className = 'swe-detail-panel';
            const now = Math.floor(Date.now() / 1000);
            const cell = (k, v, cls) => '<div><span class="k">' + k + '</span><span class="v' +
                (cls ? ' ' + cls : '') + '">' + v + '</span></div>';
            const grid = [
                cell('当前订阅', formatCount(d.subscriptions)),
                cell('历史订阅', formatCount(d.lifetimeSubscriptions)),
                cell('当前收藏', formatCount(d.favorited)),
                cell('累计收藏', formatCount(d.lifetimeFavorited)),
                cell('浏览量', formatCount(d.views)),
                cell('文件大小', formatBytes(d.fileSize)),
                cell('发布时间', formatDateTime(d.timeCreated)),
                cell('更新时间', formatDateTime(d.timeUpdated))
            ].join('');

            const tags = (d.tags || []).map(t =>
                '<a class="swe-tag" href="' + buildBrowseUrl(
                    'https://steamcommunity.com/workshop/browse/', appid, t) + '">' +
                escapeHtml(t) + '</a>').join('');

            panel.innerHTML =
                '<h4>创意工坊增强 · 数据面板</h4>' +
                '<div class="swe-detail-grid">' + grid + '</div>' +
                (tags ? '<div class="swe-tags">' + tags + '</div>' : '') +
                '<div class="swe-detail-links">' +
                '<a href="#" class="swe-dp-copy-id">复制 ID</a>' +
                '<a href="#" class="swe-dp-copy-cmd">复制 SteamCMD</a>' +
                '<a href="#" class="swe-dp-fav"></a>' +
                '<a href="https://steamcommunity.com/sharedfiles/filedetails/?id=' + id + '" target="_blank" rel="noreferrer">复制链接</a>' +
                '<a href="https://steamdb.info/app/' + (appid || '0') + '/workshop/' + id + '" target="_blank" rel="noreferrer">在 SteamDB 查看</a>' +
                '<a href="https://steamcommunity.com/workshop/browse/?appid=' + (appid || '') + '" target="_blank" rel="noreferrer">该游戏创意工坊</a>' +
                '<span class="swe-status">最后更新于 ' + formatRelative(d.timeUpdated, now) + '</span>' +
                '</div>';

            const anchor = doc.querySelector('.stats_table') || doc.querySelector('#sharedfiles_content_ctn');
            if (anchor && anchor.parentElement) anchor.parentElement.insertBefore(panel, anchor);
            else doc.body.insertBefore(panel, doc.body.firstChild);

            // 快捷动作：复制 ID / CMD / 收藏切换
            const favLink = panel.querySelector('.swe-dp-fav');
            const syncFavLink = () => {
                const faved = !!loadFavList()[id];
                favLink.textContent = faved ? '✭ 取消收藏' : '⭐ 加入收藏夹';
            };
            syncFavLink();
            panel.querySelector('.swe-dp-copy-id').addEventListener('click', (e) => {
                e.preventDefault();
                copyText(id);
                toast('已复制 ID：' + id);
            });
            panel.querySelector('.swe-dp-copy-cmd').addEventListener('click', (e) => {
                e.preventDefault();
                const cmd = buildSteamCmdCommand(appid, id);
                copyText(cmd);
                toast('已复制：' + cmd);
            });
            favLink.addEventListener('click', (e) => {
                e.preventDefault();
                favoriteEntry(id, appid,
                    (doc.querySelector('.workshopItemTitle') || {}).textContent || '', favLink)
                    .then(syncFavLink);
            });
        }).catch(() => {});
    }

    function escapeHtml(s) {
        return String(s == null ? '' : s)
            .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;').replace(/'/g, '&#39;');
    }

    // ============================================================
    // 第 9 层：艺术作品页（/app/{appid}/images/）
    //
    // 与创意工坊浏览页的关键差异（2026-10-28 实测）：
    //   · 艺术作品页是**经典服务端渲染**（apphub 体系），类名稳定，不像工坊浏览页那样哈希化
    //   · 条目 id 直接在 `data-publishedfileid` 属性上，不用从 href 猜
    //   · 卡片容器就是 `.apphub_Card`，不需要启发式判定
    //   · **无限滚动**（追加 DOM），所以必须靠 MutationObserver 补挂
    //   · 图片 URL 用 `?imw=1024&&ima=fit&...`（双 &，无 imh）——去参数必须用 URL 解析
    // ============================================================

    const SEL_APPHUB_CARD = '.apphub_Card';

    /**
     * 扫描艺术作品卡片。
     * @returns {Map<string, {id, card, img, titleEl, ratingEl, commentEl, authorEl, typeEl}>}
     */
    function scanArtworkCards(root) {
        const scope = root || global.document;
        const map = new Map();
        if (!scope || !scope.querySelectorAll) return map;
        const cards = scope.querySelectorAll(SEL_APPHUB_CARD);
        for (const card of cards) {
            const id = card.getAttribute('data-publishedfileid') ||
                parseFileIdFromHref(card.getAttribute('data-modal-content-url') || '');
            if (!id || map.has(id)) continue;
            const img = card.querySelector('img.apphub_CardContentPreviewImage');
            map.set(id, {
                id,
                card,
                img,
                titleEl: card.querySelector('.apphub_CardContentTitle'),
                ratingEl: card.querySelector('.apphub_CardRating'),
                commentEl: card.querySelector('.apphub_CardCommentCount'),
                authorEl: card.querySelector('.apphub_CardContentAuthorName'),
                typeEl: card.querySelector('.apphub_CardContentType'),
                title: (card.querySelector('.apphub_CardContentTitle') || {}).textContent || ''
            });
        }
        return map;
    }

    /**
     * 取作品原图 URL：去掉 imw（尺寸限制），保留 ima/impolicy/imcolor/letterbox 裁剪策略。
     * 实测：艺术作品默认 ?imw=1024 → 280 KB；去 imw → 707 KB；完全无参 → 1.8 MB / 1908×2808。
     * ⚠️ 必须用 URL 解析（艺术作品 URL 是 `&&` 双 ampersand，正则删会留下 `?&&ima=...` → 404）。
     */
    function artworkOriginalUrl(img) {
        if (!img) return '';
        const src = img.getAttribute('src') || '';
        if (!src) return '';
        const noSize = upgradePreviewUrl(src);
        // 若 src 没有 imw（已经是原图），直接用
        return noSize || src;
    }

    /**
     * 渲染艺术作品卡片的数据条。
     *
     * ⚠️ 位置很关键（2026-10-28 实测 apphub 卡片几何）：
     *   · `.apphub_Card` 是 `position:relative` 且 **高度固定**（721px）
     *   · `.apphub_CardContentClickable`（图片）静态流，高 636px
     *   · `.apphub_CardMetaData`（点赞/评分/标题行）**绝对定位**，压在图片底部
     *   · `.apphub_CardContentAuthorBlock`（作者块）**绝对定位**，压在最底部
     *   → 卡片里**没有任何空闲的流式空间**，把数据条 append 到卡片末尾
     *     或插到标题之后，都会与原生控件**重叠**。
     *   → 正确做法：把数据条**绝对定位**到图片区底部、原生 meta 行**上方**，
     *     并用实测的 meta 行位置动态计算 top（不写死像素，Valve 改样式也不会错位）。
     */
    function renderArtworkStats(card, detail, settings) {
        const c = card.card;
        if (!c || !c.querySelector) return;
        let bar = c.querySelector('.swe-card-stats');
        if (!bar) {
            bar = global.document.createElement('div');
            bar.className = 'swe-card-stats swe-art-stats';
            c.appendChild(bar);
            positionArtworkBar(c, bar);
        }
        if (!detail) {
            bar.innerHTML = '<span class="swe-stat swe-loading">无数据</span>';
            c.setAttribute('data-swe-processed', '1');
            return;
        }
        const parts = [];
        if (detail.views) parts.push('<span class="swe-stat">👁 <b>' + formatCount(detail.views) + '</b> 浏览</span>');
        if (detail.favorited) parts.push('<span class="swe-stat">★ <b>' + formatCount(detail.favorited) + '</b> 收藏</span>');
        if (detail.fileSize) parts.push('<span class="swe-stat">💾 <b>' + formatBytes(detail.fileSize) + '</b></span>');
        if (detail.timeUpdated) {
            parts.push('<span class="swe-stat">🕘 <b>' +
                formatRelative(detail.timeUpdated, Math.floor(Date.now() / 1000)) + '</b>更新</span>');
        }
        bar.innerHTML = parts.join('');
        c.setAttribute('data-swe-processed', '1');
    }

    /**
     * 把数据条定位到「图片区底部、原生 meta 行上方」。
     * 用实测几何动态计算，避免写死像素。
     */
    function positionArtworkBar(card, bar) {
        try {
            const cardRect = card.getBoundingClientRect();
            const meta = card.querySelector('.apphub_CardMetaData');
            const metaRect = meta ? meta.getBoundingClientRect() : null;
            // 数据条自身高度约 20px（16px 文字 + 2px×2 内边距），留 4px 间隙
            const offset = metaRect ? (metaRect.top - cardRect.top) : (cardRect.height - 64);
            bar.style.position = 'absolute';
            bar.style.left = '8px';
            bar.style.top = Math.max(0, offset - 24) + 'px';
        } catch (_) {}
    }

    /** 注入「下载原图 / 复制链接」按钮 */
    function injectArtworkActions(card, settings) {
        const c = card.card;
        if (!c || !c.querySelector) return;
        if (c.querySelector('.swe-art-actions')) return;
        const box = global.document.createElement('div');
        box.className = 'swe-art-actions';
        box.innerHTML =
            '<button type="button" class="swe-art-dl">⬇ 原图</button>' +
            '<button type="button" class="swe-art-copy">🔗 链接</button>';
        c.appendChild(box);

        const url = artworkOriginalUrl(card.img);
        box.querySelector('.swe-art-dl').addEventListener('click', (e) => {
            e.preventDefault(); e.stopPropagation();
            if (!url) { toast('未找到图片地址'); return; }
            openOriginal(url, card.title);
        });
        box.querySelector('.swe-art-copy').addEventListener('click', (e) => {
            e.preventDefault(); e.stopPropagation();
            const link = 'https://steamcommunity.com/sharedfiles/filedetails/?id=' + card.id;
            copyText(link);
            toast('已复制：' + link);
        });
    }

    /**
     * Blob 下载兜底：GM_xmlhttpRequest 拿 blob → a[download]。
     * GM_download 失败（下载被拦 / 管理器限制）时的第二级回落；
     * blob: URL 对页面同源，a[download] 必走下载而非导航。
     */
    function downloadViaBlob(url, filename) {
        return new Promise((resolve) => {
            if (typeof GM_xmlhttpRequest !== 'function') { resolve(false); return; }
            try {
                GM_xmlhttpRequest({
                    method: 'GET',
                    url,
                    responseType: 'blob',
                    timeout: 30000,
                    onload: (res) => {
                        try {
                            const blobUrl = URL.createObjectURL(res.response);
                            const a = global.document.createElement('a');
                            a.href = blobUrl;
                            a.download = filename || '';
                            a.style.display = 'none';
                            global.document.body.appendChild(a);
                            a.click();
                            setTimeout(() => {
                                try { a.remove(); URL.revokeObjectURL(blobUrl); } catch (_) {}
                            }, 800);
                            resolve(true);
                        } catch (_) { resolve(false); }
                    },
                    onerror: () => resolve(false),
                    ontimeout: () => resolve(false)
                });
            } catch (_) { resolve(false); }
        });
    }

    /** 下载原图回落链：GM_download → Blob → 新标签（每级**真正失败**才降级） */
    function openOriginal(url, name) {
        const fname = (name || 'steam-artwork').replace(/[\\/:*?"<>|]+/g, '_').slice(0, 60) || 'steam-artwork';
        const openTab = () => { global.open(url, '_blank', 'noopener'); };
        // 注意：必须判断 Blob 是否真的成功 —— 无条件 then(openTab) 会在下载成功时
        // 再额外开一个新标签页，批量下载时会一口气弹 N 个页签。
        const viaBlobOrTab = () => {
            downloadViaBlob(url, fname + '.jpg').then((ok) => { if (!ok) openTab(); });
        };
        try {
            if (typeof GM_download === 'function') {
                GM_download({ url, name: fname + '.jpg', onerror: viaBlobOrTab });
                return;
            }
        } catch (_) {}
        viaBlobOrTab();
    }

    /** 复制文本（优先剪贴板 API） */
    function copyText(text) {
        try {
            if (global.navigator && global.navigator.clipboard && global.navigator.clipboard.writeText) {
                global.navigator.clipboard.writeText(text).catch(() => {});
                return;
            }
        } catch (_) {}
        try {
            if (typeof GM_setClipboard === 'function') { GM_setClipboard(text); return; }
        } catch (_) {}
    }

    // ---------- 艺术作品页批量下载 ----------
    const artPicked = new Set();

    function setArtBatchMode(on) {
        saveSettings({ artBatchMode: !!on });
        try { global.document.body.classList.toggle('swe-art-batch-on', !!on); } catch (_) {}
        if (!on) {
            artPicked.clear();
            global.document.querySelectorAll('.swe-art-pick').forEach((b) => b.remove());
        } else {
            for (const card of scanArtworkCards(global.document).values()) {
                injectArtPicker(card);
            }
        }
        syncArtPickers();
        updateArtCount();
    }

    function injectArtPicker(card) {
        const c = card.card;
        if (!c || !c.querySelector) return;
        if (c.querySelector('.swe-art-pick')) return;
        const box = global.document.createElement('label');
        box.className = 'swe-art-pick';
        box.innerHTML = '<input type="checkbox">';
        c.appendChild(box);
        box.querySelector('input').addEventListener('change', (e) => {
            e.stopPropagation();
            box.classList.toggle('on', e.target.checked);
            if (e.target.checked) artPicked.add(card.id); else artPicked.delete(card.id);
            updateArtCount();
        });
    }

    function syncArtPickers() {
        global.document.querySelectorAll('.swe-art-pick').forEach((box) => {
            const inp = box.querySelector('input');
            if (!inp) return;
            const cardEl = box.closest ? box.closest(SEL_APPHUB_CARD) : null;
            const id = cardEl ? cardEl.getAttribute('data-publishedfileid') : '';
            const on = !!id && artPicked.has(id);
            inp.checked = on;
            box.classList.toggle('on', on);
        });
    }

    function updateArtCount() {
        const el = global.document.querySelector('.swe-art-count');
        if (el) el.textContent = '已选 ' + artPicked.size + ' 项';
    }

    async function batchDownloadArtworks() {
        if (!artPicked.size) { toast('请先勾选作品'); return; }
        const cards = scanArtworkCards(global.document);
        const list = [];
        for (const id of artPicked) {
            const c = cards.get(id);
            const url = c ? artworkOriginalUrl(c.img) : '';
            if (url) list.push({ url, name: c.title || id });
        }
        if (!list.length) { toast('未找到可下载的图片'); return; }
        toast('开始下载 ' + list.length + ' 张原图…', 5000);
        for (let i = 0; i < list.length; i++) {
            openOriginal(list[i].url, list[i].name);
            await new Promise(r => setTimeout(r, 350)); // 逐个触发，避开浏览器批量下载拦截
        }
        toast('已触发 ' + list.length + ' 张下载', 4000);
    }

    /** 艺术作品页工具条 */
    function buildArtworkToolbar() {
        if (toolbarEl) return toolbarEl;
        const doc = global.document;
        const bar = doc.createElement('div');
        bar.className = 'swe-toolbar';
        bar.innerHTML =
            '<div class="swe-panel" style="display:none">' +
            '  <div class="swe-panel-head"><span class="swe-panel-title">艺术作品增强</span>' +
            '    <button class="swe-panel-collapse" title="收起面板">−</button></div>' +
            '  <div class="swe-panel-body">' +
            '  <div class="swe-row"><span class="swe-art-count">已选 0 项</span>' +
            '    <button class="swe-art-all">全选本页</button></div>' +
            '  <div class="swe-row"><button class="swe-art-invert">反选</button>' +
            '    <button class="swe-art-clear">清空</button></div>' +
            '  <div class="swe-row"><button class="swe-primary swe-art-batch">批量下载原图</button></div>' +
            '  <div class="swe-row"><button class="swe-art-mode">批量模式</button>' +
            '    <button class="swe-art-copyall">复制本页链接</button></div>' +
            '  <div class="swe-hint">原图即去掉尺寸限制的最高分辨率版本；批量下载会逐个触发，避开浏览器拦截。</div>' +
            '  </div>' +
            '</div>' +
            '<button class="swe-toolbar-toggle" title="艺术作品增强（拖动图标组可贴到窗口边缘，双击可复位）">⚙</button>';
        doc.body.appendChild(bar);
        toolbarEl = bar;
        // 浮动图标组：装上拖拽 + 恢复上次贴边位置
        initDock(bar);

        const panel = bar.querySelector('.swe-panel');
        bar.querySelector('.swe-toolbar-toggle').addEventListener('click', () => {
            const open = panel.style.display === 'none';
            panel.style.display = open ? 'flex' : 'none';
            if (open) fitDockPanel(bar);
        });
        bar.querySelector('.swe-art-all').addEventListener('click', () => {
            for (const id of scanArtworkCards(global.document).keys()) artPicked.add(id);
            syncArtPickers(); updateArtCount();
        });
        bar.querySelector('.swe-art-invert').addEventListener('click', () => {
            for (const id of scanArtworkCards(global.document).keys()) {
                if (artPicked.has(id)) artPicked.delete(id); else artPicked.add(id);
            }
            syncArtPickers(); updateArtCount();
        });
        bar.querySelector('.swe-art-clear').addEventListener('click', () => {
            artPicked.clear(); syncArtPickers(); updateArtCount();
        });
        bar.querySelector('.swe-art-batch').addEventListener('click', batchDownloadArtworks);
        const modeBtn = bar.querySelector('.swe-art-mode');
        const settings = loadSettings();
        if (settings.artBatchMode) { setArtBatchMode(true); modeBtn.textContent = '退出批量'; }
        modeBtn.addEventListener('click', () => {
            const on = !loadSettings().artBatchMode;
            setArtBatchMode(on);
            modeBtn.textContent = on ? '退出批量' : '批量模式';
        });
        bar.querySelector('.swe-art-copyall').addEventListener('click', () => {
            const ids = Array.from(scanArtworkCards(global.document).keys());
            if (!ids.length) { toast('本页暂无作品'); return; }
            const text = ids.map(id => 'https://steamcommunity.com/sharedfiles/filedetails/?id=' + id).join('\n');
            copyText(text);
            toast('已复制本页 ' + ids.length + ' 条作品链接', 3000);
        });
        return bar;
    }

    const pendingArtCards = new Map();
    let artFlushTimer = null;

    function queueArtworkCard(card, settings) {
        if (!card || !card.card) return;
        if (card.card.getAttribute('data-swe-processed')) return;
        pendingArtCards.set(card.id, card);
        if (pendingArtCards.size >= CARD_BATCH_SIZE) { flushArtworkCards(settings); return; }
        if (!artFlushTimer) artFlushTimer = setTimeout(() => flushArtworkCards(loadSettings()), CARD_BATCH_WAIT_MS);
    }

    async function flushArtworkCards(settings) {
        clearTimeout(artFlushTimer);
        artFlushTimer = null;
        if (!pendingArtCards.size) return;
        const batch = Array.from(pendingArtCards.values());
        pendingArtCards.clear();
        const ids = batch.map(c => c.id);
        let details = {};
        try { details = await fetchDetails(ids); } catch (_) { details = {}; }
        for (const card of batch) {
            renderArtworkStats(card, details[card.id] || null, settings);
            injectArtworkActions(card, settings);
            if (settings.artBatchMode) injectArtPicker(card);
        }
    }

    function enhanceArtworkPage() {
        const doc = global.document;
        const settings = loadSettings();
        // hydration 未完成时禁止注入 DOM（经典页通常无此问题，但保持口径一致）
        if (!gateOpen('artwork')) return;
        if (enhancing) return;
        enhancing = true;
        try {
            const cards = scanArtworkCards(doc);
            for (const card of cards.values()) {
                // 预览图升级（去 imw → 更高分辨率）
                if (settings.upgradePreview && card.img) {
                    const src = card.img.getAttribute('src') || '';
                    if (src && src.indexOf('imw=') !== -1) {
                        const up = upgradePreviewUrl(src);
                        if (up && up !== src) card.img.setAttribute('src', up);
                    }
                }
                injectArtworkActions(card, settings);
                if (settings.artBatchMode) injectArtPicker(card);
                queueArtworkCard(card, settings);
            }
            // 截图页：挂「瀑布流」入口（浮窗独立 DOM，不改原页面）
            if (isScreenshotPage()) injectWaterfallButton();
        } finally {
            enhancing = false;
        }
    }

    /**
     * 当前是不是「截图」子页（/app/{id}/screenshots/）。
     * 瀑布流只针对截图页 —— 艺术作品页（/images/）的图是插画，混在一起反而乱。
     */
    function isScreenshotPage() {
        const path = (global.location && global.location.pathname) || '';
        return /\/app\/\d+\/screenshots/.test(path);
    }

    // ============================================================
    // 第 9.5 层：收藏夹管理器 + 订阅备份/还原（模态）
    //
    // 思路参考自：
    //   · aggs/Steam Workshop Mod Tool.js —— 列表管理器（搜索/筛选/批量导出/检查更新）
    //   · aggs/Steam-Workshop-optimization.js —— 订阅备份（翻页拉取 mysubscriptions）
    // 按本插件约定重写：零依赖、稳定锚点、公开接口、限速礼貌访问。
    // ============================================================

    /** 下载文本文件（Blob + a[download]，不依赖 GM_download） */
    function downloadTextFile(filename, text) {
        try {
            const doc = global.document;
            const blob = new Blob([text], { type: 'application/json;charset=utf-8' });
            const url = URL.createObjectURL(blob);
            const a = doc.createElement('a');
            a.href = url;
            a.download = filename;
            doc.body.appendChild(a);
            a.click();
            setTimeout(() => {
                try { a.remove(); URL.revokeObjectURL(url); } catch (_) {}
            }, 800);
            return true;
        } catch (_) { return false; }
    }

    /** 通用模态骨架。返回 {backdrop, modal, close}；backdrop 点击 / Esc 均可关闭 */
    function openModal(title, bodyHtml) {
        const doc = global.document;
        const backdrop = doc.createElement('div');
        backdrop.className = 'swe-modal-backdrop';
        backdrop.innerHTML =
            '<div class="swe-modal" role="dialog" aria-label="' + escapeHtml(title) + '">' +
            '  <div class="swe-modal-head"><h3>' + escapeHtml(title) + '</h3>' +
            '    <button type="button" class="swe-modal-close" title="关闭 (Esc)">×</button></div>' +
            '  <div class="swe-modal-body"></div>' +
            '</div>';
        doc.body.appendChild(backdrop);
        const modal = backdrop.querySelector('.swe-modal');
        const body = backdrop.querySelector('.swe-modal-body');
        body.innerHTML = bodyHtml;

        function close() {
            try { doc.removeEventListener('keydown', onKey, true); } catch (_) {}
            try { backdrop.remove(); } catch (_) {}
        }
        function onKey(e) {
            if (e.key === 'Escape') { e.stopPropagation(); close(); }
        }
        backdrop.querySelector('.swe-modal-close').addEventListener('click', close);
        backdrop.addEventListener('mousedown', (e) => { if (e.target === backdrop) close(); });
        doc.addEventListener('keydown', onKey, true);
        return { backdrop, modal, body, close };
    }

    // ---------- 收藏夹管理器 ----------
    const favMgrState = { q: '', filter: 'all', picked: new Set() };

    /** 按搜索词与筛选条件过滤收藏条目（新加入的在前） */
    function favEntriesFiltered() {
        const list = loadFavList();
        const q = (favMgrState.q || '').toLowerCase();
        const now = Math.floor(Date.now() / 1000);
        const out = [];
        for (const rec of Object.values(list)) {
            if (!rec || !rec.id) continue;
            if (q && !(String(rec.title || '').toLowerCase().indexOf(q) !== -1 ||
                String(rec.id).indexOf(q) !== -1)) continue;
            if (favMgrState.filter === 'updated' && !rec.hasUpdate) continue;
            if (favMgrState.filter === 'recent' && !isRecentlyUpdated(rec.timeUpdatedAt, now, 7)) continue;
            out.push(rec);
        }
        out.sort((a, b) => toNum(b.timeAdded) - toNum(a.timeAdded));
        return out;
    }

    /** 渲染收藏夹列表（每次全量重绘；条目量级为百，性能可接受） */
    function renderFavManager(m) {
        const entries = favEntriesFiltered();
        const listEl = m.body.querySelector('.swe-favm-list');
        const countEl = m.body.querySelector('.swe-favm-count');
        if (countEl) {
            countEl.textContent = '共 ' + Object.keys(loadFavList()).length + ' 项' +
                (entries.length !== Object.keys(loadFavList()).length ? ' · 匹配 ' + entries.length + ' 项' : '') +
                ' · 已选 ' + favMgrState.picked.size + ' 项';
        }
        if (!entries.length) {
            listEl.innerHTML = '<div class="swe-modal-empty">收藏夹为空或无匹配。在浏览页卡片悬浮按钮点「⭐ 收藏」即可加入。</div>';
            return;
        }
        const now = Math.floor(Date.now() / 1000);
        listEl.innerHTML = entries.map((r) => {
            const upd = isRecentlyUpdated(r.timeUpdatedAt, now, 7);
            return '<label class="swe-modal-row" data-id="' + escapeHtml(r.id) + '">' +
                '<input type="checkbox" class="swe-favm-check"' +
                (favMgrState.picked.has(r.id) ? ' checked' : '') + '>' +
                '<a class="swe-m-title" href="' + buildItemLink(r.id) + '" target="_blank" rel="noreferrer"' +
                ' title="' + escapeHtml(r.title || r.id) + '">' + escapeHtml(r.title || r.id) + '</a>' +
                (r.hasUpdate ? '<span class="swe-m-upd">🆕 有更新</span>' : '') +
                '<span class="swe-m-meta">appid ' + escapeHtml(r.appid || '?') + '</span>' +
                '<span class="swe-m-meta">存于 ' + formatDateTime(r.timeAdded) + '</span>' +
                '<span class="swe-m-meta' + (upd ? ' swe-m-upd' : '') + '">更新 ' +
                formatRelative(r.timeUpdatedAt, now) + '</span>' +
                '</label>';
        }).join('');

        listEl.querySelectorAll('.swe-favm-check').forEach((inp) => {
            inp.addEventListener('change', () => {
                const id = inp.closest('.swe-modal-row').getAttribute('data-id');
                if (inp.checked) favMgrState.picked.add(id); else favMgrState.picked.delete(id);
                const countEl2 = m.body.querySelector('.swe-favm-count');
                if (countEl2) countEl2.textContent = countEl2.textContent.replace(/已选 \d+ 项/, '已选 ' + favMgrState.picked.size + ' 项');
            });
        });
    }

    /** 收藏条目「检查更新」：强制拉取详情，对比 time_updated 基线 */
    async function checkFavUpdates(statusEl, btn) {
        const list = loadFavList();
        const ids = Object.keys(list);
        if (!ids.length) { toast('收藏夹为空'); return; }
        if (btn) { btn.disabled = true; }
        const BATCH = 100;
        let updated = 0, failed = 0, done = 0;
        const setStatus = (s) => { if (statusEl) statusEl.textContent = s; };
        try {
            for (let i = 0; i < ids.length; i += BATCH) {
                const batch = ids.slice(i, i + BATCH);
                let fresh = {};
                try { fresh = await fetchDetails(batch, { force: true }); }
                catch (_) { failed += batch.length; }
                for (const id of batch) {
                    const d = fresh[id];
                    if (!d) { failed++; continue; }
                    if (hasUpdate(list[id], d)) { list[id].hasUpdate = true; updated++; }
                    else list[id].hasUpdate = false;
                    // 基线提到最新：下次检查只报本次之后的新更新
                    list[id].timeUpdatedAt = toNum(d.timeUpdated) || list[id].timeUpdatedAt;
                    if (d.title) list[id].title = d.title;
                    if (d.appid) list[id].appid = d.appid;
                }
                done = Math.min(i + BATCH, ids.length);
                setStatus('检查中 ' + done + '/' + ids.length + '…');
                if (i + BATCH < ids.length) await new Promise(r => setTimeout(r, 400)); // 限速防 429
            }
            saveFavList();
            setStatus('检查完成：' + updated + ' 项有更新' + (failed ? '，' + failed + ' 项获取失败' : ''));
            toast('检查完成：' + updated + ' 项有更新', 3200);
        } finally {
            if (btn) { btn.disabled = false; }
        }
    }

    function openFavManager() {
        // 重开时保留筛选、清空勾选（勾选指向的行可能已不存在）
        favMgrState.picked.clear();
        const m = openModal('收藏夹管理器',
            '<div class="swe-modal-tools">' +
            '  <input type="text" class="swe-favm-q" placeholder="搜索名称或 ID…">' +
            '  <select class="swe-favm-filter">' +
            '    <option value="all">全部</option>' +
            '    <option value="updated">🆕 有更新</option>' +
            '    <option value="recent">7 天内更新</option>' +
            '  </select>' +
            '  <button type="button" class="swe-favm-check-upd">检查更新</button>' +
            '  <select class="swe-favm-export-mode">' +
            EXPORT_MODES.map(o => '<option value="' + o.key + '">' + o.label + '</option>').join('') +
            '  </select>' +
            '  <button type="button" class="swe-favm-export">复制导出</button>' +
            '  <button type="button" class="swe-favm-export-file">导出文件</button>' +
            '</div>' +
            '<div class="swe-modal-list swe-favm-list"></div>' +
            '<div class="swe-modal-foot">' +
            '  <button type="button" class="swe-favm-all">全选匹配</button>' +
            '  <button type="button" class="swe-favm-none">取消全选</button>' +
            '  <button type="button" class="swe-danger swe-favm-remove">移除选中</button>' +
            '  <span class="swe-modal-status swe-favm-status"></span>' +
            '  <span class="swe-favm-count swe-modal-status"></span>' +
            '</div>');

        renderFavManager(m);

        m.body.querySelector('.swe-favm-q').addEventListener('input', (e) => {
            favMgrState.q = e.target.value.trim();
            renderFavManager(m);
        });
        m.body.querySelector('.swe-favm-filter').addEventListener('change', (e) => {
            favMgrState.filter = e.target.value;
            renderFavManager(m);
        });
        m.body.querySelector('.swe-favm-check-upd').addEventListener('click', async (e) => {
            const statusEl = m.body.querySelector('.swe-favm-status');
            await checkFavUpdates(statusEl, e.target);
            renderFavManager(m);
        });
        m.body.querySelector('.swe-favm-all').addEventListener('click', () => {
            for (const r of favEntriesFiltered()) favMgrState.picked.add(r.id);
            renderFavManager(m);
        });
        m.body.querySelector('.swe-favm-none').addEventListener('click', () => {
            favMgrState.picked.clear();
            renderFavManager(m);
        });
        m.body.querySelector('.swe-favm-remove').addEventListener('click', () => {
            if (!favMgrState.picked.size) { toast('请先勾选条目'); return; }
            const list = loadFavList();
            for (const id of favMgrState.picked) delete list[id];
            saveFavList();
            favMgrState.picked.clear();
            renderFavManager(m);
            syncCardActionButtons();
            toast('已移除选中条目');
        });

        // 导出：勾选优先，未勾选则导出当前匹配列表
        const exportEntries = () => {
            const pickedEntries = favEntriesFiltered().filter(r => favMgrState.picked.has(r.id));
            const source = pickedEntries.length ? pickedEntries : favEntriesFiltered();
            const fallbackAppid = (source.length === 1 && source[0].appid) || '';
            const mode = m.body.querySelector('.swe-favm-export-mode').value;
            return {
                mode,
                count: source.length,
                text: buildExportText(mode, source, fallbackAppid)
            };
        };
        m.body.querySelector('.swe-favm-export').addEventListener('click', () => {
            const r = exportEntries();
            if (!r.count) { toast('收藏夹为空'); return; }
            copyText(r.text);
            toast('已复制 ' + r.count + ' 项（' + r.mode + '）', 3000);
        });
        m.body.querySelector('.swe-favm-export-file').addEventListener('click', () => {
            const r = exportEntries();
            if (!r.count) { toast('收藏夹为空'); return; }
            const ext = r.mode === 'json' ? 'json' : 'txt';
            downloadTextFile('swe-favorites-' + Date.now() + '.' + ext, r.text);
            toast('已导出 ' + r.count + ' 项到文件', 3000);
        });
    }

    // ---------- 订阅备份 / 还原 ----------

    /**
     * 翻页拉取「我的订阅」全部条目 id。
     * 「我的项目」页是经典渲染（设计文档 §1.1），filedetails 链接稳定可解析。
     * 停止条件：空页 / 连续无新增 / 网络失败；页数上限保护。
     */
    async function fetchAllSubscribedIds(onProgress) {
        const seen = new Set();
        const ordered = [];
        const MAX_PAGES = 200;
        for (let p = 1; p <= MAX_PAGES; p++) {
            const url = 'https://steamcommunity.com/my/myworkshopfiles/' +
                '?browsefilter=mysubscriptions&numperpage=30&num_per_page=30&p=' + p;
            let html = '';
            try {
                const res = await global.fetch(url, { credentials: 'include', cache: 'no-store' });
                if (!res.ok) throw new Error('HTTP ' + res.status);
                html = await res.text();
            } catch (_) {
                break; // 网络失败：保守停止，返回已拉到的部分
            }
            const ids = parseWorkshopItemIdsFromHtml(html);
            let added = 0;
            for (const id of ids) {
                if (!seen.has(id)) { seen.add(id); ordered.push(id); added++; }
            }
            if (onProgress) onProgress(p, ordered.length);
            if (!ids.length || !added) break;
            await new Promise(r => setTimeout(r, 350)); // 限速礼貌访问
        }
        return ordered;
    }

    function openBackupModal() {
        const m = openModal('订阅备份 / 还原',
            '<div class="swe-modal-tools">' +
            '  <button type="button" class="swe-primary swe-bk-export">拉取全部订阅并导出</button>' +
            '  <span class="swe-modal-status swe-bk-status"></span>' +
            '</div>' +
            '<div class="swe-modal-body-inner" style="padding:12px 16px">' +
            '  <div class="swe-hint">导出：逐页拉取「我的订阅」（每页 30 条，带限速），生成含元数据的 JSON；' +
            '同时下载文件并复制到剪贴板。<br>还原：粘贴备份 JSON（或纯 ID 列表，每行一个），' +
            '解析后逐条提交订阅（需登录 Steam，限速 220ms/条）。</div>' +
            '  <textarea class="swe-bk-text" placeholder="粘贴备份 JSON 或纯 ID 列表…"></textarea>' +
            '  <div style="display:flex;gap:8px;margin-top:8px;flex-wrap:wrap;align-items:center">' +
            '    <input type="file" class="swe-bk-file" accept=".json,.txt,text/plain,application/json">' +
            '    <button type="button" class="swe-bk-parse">解析</button>' +
            '    <button type="button" class="swe-primary swe-bk-import" disabled>开始还原订阅</button>' +
            '    <span class="swe-modal-status swe-bk-import-status"></span>' +
            '  </div>' +
            '</div>');

        const statusEl = m.body.querySelector('.swe-bk-status');
        // 解析结果暂存，点「开始还原」时才提交
        let parsedItems = null;

        m.body.querySelector('.swe-bk-export').addEventListener('click', async (e) => {
            const btn = e.target;
            btn.disabled = true;
            try {
                statusEl.textContent = '拉取中…';
                const ids = await fetchAllSubscribedIds((p, n) => {
                    statusEl.textContent = '已拉取 ' + p + ' 页，累计 ' + n + ' 条…';
                });
                if (!ids.length) {
                    statusEl.textContent = '未拉到订阅条目（需登录 Steam，且确认「我的订阅」非空）';
                    btn.disabled = false;
                    return;
                }
                statusEl.textContent = '补全元数据中（' + ids.length + ' 条）…';
                let details = {};
                try { details = await fetchDetails(ids); } catch (_) {}
                const entries = ids.map(id => {
                    const d = details[id] || {};
                    return { id, appid: d.appid || '', title: d.title || '', timeUpdated: d.timeUpdated || 0 };
                });
                const json = buildSubscriptionBackupJson(entries);
                downloadTextFile('swe-subscriptions-' + new Date().toISOString().slice(0, 10) + '.json', json);
                copyText(json);
                statusEl.textContent = '完成：' + entries.length + ' 条已下载并复制';
                toast('订阅备份完成：' + entries.length + ' 条', 3600);
            } finally {
                btn.disabled = false;
            }
        });

        const importBtn = m.body.querySelector('.swe-bk-import');
        const importStatus = m.body.querySelector('.swe-bk-import-status');

        const tryParse = () => {
            const r = parseSubscriptionImport(m.body.querySelector('.swe-bk-text').value);
            if (!r.ok) {
                parsedItems = null;
                importBtn.disabled = true;
                const msg = { empty: '请先粘贴内容', 'bad-json': 'JSON 解析失败', 'no-items': '未找到有效条目 id' }[r.error] || r.error;
                importStatus.textContent = '解析失败：' + msg;
                return;
            }
            parsedItems = r.items;
            importBtn.disabled = false;
            importStatus.textContent = '解析到 ' + r.items.length + ' 条（' + r.type + '）';
        };
        m.body.querySelector('.swe-bk-parse').addEventListener('click', tryParse);
        m.body.querySelector('.swe-bk-file').addEventListener('change', async (e) => {
            const f = e.target.files && e.target.files[0];
            if (!f) return;
            try { m.body.querySelector('.swe-bk-text').value = await f.text(); tryParse(); }
            catch (_) { importStatus.textContent = '文件读取失败'; }
        });

        importBtn.addEventListener('click', async () => {
            if (!parsedItems || !parsedItems.length) return;
            importBtn.disabled = true;
            // 缺 appid 的条目先补全（订阅接口实测需要 appid；设计文档 §2.2）
            const missing = parsedItems.filter(x => !x.appid);
            if (missing.length) {
                importStatus.textContent = '补全 appid（' + missing.length + ' 条）…';
                try {
                    const details = await fetchDetails(missing.map(x => x.id));
                    for (const x of missing) {
                        if (details[x.id] && details[x.id].appid) x.appid = details[x.id].appid;
                    }
                } catch (_) {}
            }
            await batchSubscribeEntries(parsedItems, false);
            importStatus.textContent = '还原流程已结束，详见页内提示';
            importBtn.disabled = false;
        });
    }

    // ============================================================
    // 第 10 层：「我的项目」页 —— 收集已订阅 / 已收藏 id
    // ============================================================

    function scanMyItems() {
        const doc = global.document;
        if (!doc) return;
        const ids = new Set();
        doc.querySelectorAll(SEL_FILE_LINK).forEach(a => {
            const id = parseFileIdFromHref(a.getAttribute('href'));
            if (id) ids.add(id);
        });
        if (!ids.size) return;
        const filter = (readBrowseParams(global.location.href) || {}).browsefilter ||
            (global.location.search.match(/browsefilter=([^&]+)/) || [])[1] || '';
        const target = /favorites/.test(filter) ? FAV_KEY : SUBS_KEY;
        const set = target === FAV_KEY ? loadFavorited() : loadSubscribed();
        let changed = false;
        ids.forEach(id => { if (!set[id]) { set[id] = true; changed = true; } });
        if (changed) storeSet(target, set);
    }

    // ============================================================
    // 第 10 层：启动
    // ============================================================

    function pageKind() {
        const path = global.location.pathname || '';
        if (/\/sharedfiles\/filedetails/.test(path)) return 'detail';
        if (/\/myworkshopfiles/.test(path)) return 'myitems';
        // 艺术作品页 / 截图页：/app/{appid}/images/ 与 /app/{appid}/screenshots/
        if (/\/app\/\d+\/(images|screenshots)/.test(path)) return 'artwork';
        // 游戏创意工坊首页：/app/{appid}/workshop/
        // 2026-10-30 实测：与浏览页同样是 React SPA + 同一套哈希化卡片 DOM，
        // 但走 `workshop_query` 查询而非 `workshop_browse`，且页面上没有「每页」下拉，
        // 因此归为独立的 'apphub' 类型：复用卡片增强，隐藏浏览页专属的排序/分页控件。
        if (/\/app\/\d+\/workshop/.test(path)) return 'apphub';
        if (/\/workshop\/browse/.test(path) || /^\/workshop\/?$/.test(path)) return 'browse';
        return 'other';
    }

    /**
     * 该页是否使用「浏览页网格」语义（每页条数 / 原生排序 / 跨页看 5★ 只在网格页有意义）。
     * /app/{id}/workshop/ 是分区展示页，没有分页控件，故排除。
     */
    function isGridPage(kind) {
        return kind === 'browse';
    }

    let observer = null;
    let lastUrl = '';

    // ============================================================
    // React hydration 门控
    // ============================================================
    //
    // 新版创意工坊是 React SSR + hydrate 的 SPA。在 React 完成 hydration 之前
    // 往卡片容器 / body 里插 DOM，React 会认为 DOM 被外部篡改，抛
    // "Minified React error #418"（hydration mismatch），并把整棵树改成 client 重渲染。
    //
    // 实测（2026-10-28，Windows + Edge 156，真实 Steam，三组对照实验已确证）：
    //   browse  页：React 标记 @6.1~7.2s 出现，DOM 变动窗口 2411→7648ms；
    //                插件 @2333ms 注入 → 早于 React 接管 7.4s → 必然 #418
    //                （裸页面 / 仅 GM 桩 两组对照组均无 #418，可排除 Valve 自身问题）
    //   artwork 页：无 React 标记（经典 apphub 卡片），DOM 变动 1924→2619ms → 安全
    //   detail  页：无 React 标记（经典 SSR），DOM 变动 2681→3205ms → 安全
    //
    // 另一条实测结论（决定了判据的形状）：
    //   不注入插件时，browse 页在 React 接管前 **DOM 完全静止**（0 次变动，直到 React 标记出现）。
    //   所以「DOM 静止」不能当作 browse 页的放行条件 —— 只能以 React 标记为准。
    //
    // 放行判据：
    //   - 该页是 React SPA（browse）→ 必须先见到 React 接管痕迹，且 DOM 已静止
    //   - 该页从无 React 痕迹 + DOM 静止 → 经典页，可安全注入
    //   - 兜底：HYDRATION_MAX_WAIT_MS 后强制放行 —— 宁可慢，也绝不让插件彻底不工作

    const HYDRATION_MIN_WAIT_MS = 250;    // 经典页最小等待：给 React 冒头的机会
    const HYDRATION_STABLE_MS = 500;     // 判定「DOM 已静止」的静默时长
    const HYDRATION_REACT_GRACE_MS = 1500; // React 接管后最多再等多久（覆盖其 hydration 提交）
    const HYDRATION_CLASSIC_GRACE_MS = 3000; // 经典页：页面持续变动时的兜底放行
    const HYDRATION_MAX_WAIT_MS = 20000; // 兜底上限

    const gates = {};          // kind -> { open: boolean }
    let lastDomMutationAt = 0; // 最近一次 DOM 变动时刻
    let domWatcher = null;
    let forceGateFlag = false; // 测试钩子：全局强制放行（见 forceOpenGates）

    /** 页面里是否已有 React 接管痕迹（React 18 挂在 root container 上） */
    function reactMarkerPresent() {
        const doc = global.document;
        if (!doc) return false;
        try {
            const keys = Object.keys(doc);
            for (const k of keys) {
                if (k.indexOf('__reactContainer') === 0) return true;
                if (k.indexOf('__reactInternalInstance') === 0) return true;
            }
        } catch (_) {}
        try {
            if (doc._reactRootContainer) return true;
        } catch (_) {}
        return false;
    }

    /** 监听 DOM 变动，用于判断页面是否已静止 */
    function watchDomMutations() {
        if (domWatcher) return;
        const doc = global.document;
        if (!doc || !doc.documentElement || typeof MutationObserver === 'undefined') return;
        domWatcher = new MutationObserver(() => { lastDomMutationAt = Date.now(); });
        domWatcher.observe(doc.documentElement, { childList: true, subtree: true });
        lastDomMutationAt = Date.now();
    }

    function gateOpen(kind) { return !!(gates[kind] && gates[kind].open); }

    /**
     * 门控：在不会破坏 React hydration 的时机执行 run。
     * @param {string} kind    页面类型（browse / artwork / detail）
     * @param {Function} run   真正干活的回调
     */
    function withHydrationGate(kind, run) {
        if (gateOpen(kind)) { run(); return; }
        // 测试钩子：全局强制放行。无论调用时机早于还是晚于 boot 都能生效。
        if (forceGateFlag) {
            gates[kind] = { open: true, pending: false, run: null };
            try { run(); } catch (e) { console.warn('[Steam 创意工坊增强] 增强失败', e); }
            return;
        }
        if (gates[kind] && gates[kind].pending) { gates[kind].run = run; return; }
        gates[kind] = { open: false, pending: true, run: run };

        const startedAt = Date.now();
        // React 痕迹按页面类型独立记录：SPA 内切换页面类型时不该互相污染
        let reactSeenAt = 0;   // React 接管痕迹首次出现的时刻
        const tick = () => {
            const g = gates[kind];
            if (!g || g.open) return;
            const now = Date.now();
            if (!reactSeenAt && reactMarkerPresent()) reactSeenAt = now;
            const stable = (now - lastDomMutationAt) >= HYDRATION_STABLE_MS;
            // React SPA（browse）：**必须**见到 React 接管痕迹才算 hydration 跑完。
            //   放行条件二选一：
            //     ① React 标记出现后 DOM 静默 500ms → hydration 的 DOM 提交已落定（实测典型路径）
            //     ② React 标记出现后已过 1500ms → 兜住「页面后续持续变动导致永不稳定」的情况
            //   实测：React 标记 @6.1~7.2s 出现，其后 DOM 最后变动仅晚 350ms。
            // 经典页（artwork / detail）：实测无 React 痕迹，DOM 静止即可注入；
            //   若页面自身持续变动（广告/动画），3 秒后也放行，避免门控自锁。
            const needReact = (kind === 'browse' || kind === 'apphub');
            const ready = reactSeenAt
                ? (stable || (now - reactSeenAt) >= HYDRATION_REACT_GRACE_MS)
                : (!needReact && (now - startedAt) >= HYDRATION_MIN_WAIT_MS
                    && (stable || (now - startedAt) >= HYDRATION_CLASSIC_GRACE_MS));
            if (ready || (now - startedAt) >= HYDRATION_MAX_WAIT_MS) {
                g.open = true;
                g.pending = false;
                const fn = g.run;
                g.run = null;
                try { if (fn) fn(); } catch (e) { console.warn('[Steam 创意工坊增强] 增强失败', e); }
                return;
            }
            setTimeout(tick, 120);
        };
        setTimeout(tick, 120);
    }

    /**
     * 浏览页 / 游戏创意工坊首页的卡片增强。
     *
     * @param {string} [kind] 'browse'（浏览页网格）| 'apphub'（/app/{id}/workshop/ 分区页）
     *   两者卡片 DOM 完全一致（同一套哈希类名），只是分区页没有分页控件。
     */
    function enhanceBrowsePage(kind) {
        const doc = global.document;
        const settings = loadSettings();
        const k = kind || 'browse';
        // hydration 未完成时禁止注入 DOM —— 插进去会让 React 判定 DOM 被篡改（error #418）
        if (!gateOpen(k)) return;
        // 重入保护：注入 DOM 本身会触发 MutationObserver
        if (enhancing) return;
        enhancing = true;
        try {
            const cards = scanCards(doc);
            for (const card of cards.values()) {
                upgradeCardImage(card, settings);
                renderBadges(card, settings);
                injectCardActions(card);
                if (settings.batchMode) injectPicker(card, onPickToggle);
                queueCard(card, settings);
            }
            // 星级筛选：每次增强后重放（React 重渲染会重建卡片，类名标记随之丢失）
            const filterResult = applyStarFilter();
            // v1.8.0：本页 0 命中时安排「星级猎取」（内部幂等，重复触发无副作用）
            maybeScheduleStarHunt(filterResult);
        } finally {
            enhancing = false;
        }
    }

    function startObserver() {
        if (observer) return;
        const doc = global.document;
        if (!doc || !doc.body || typeof MutationObserver === 'undefined') return;
        observer = new MutationObserver((mutations) => {
            let touched = false;
            for (const m of mutations) {
                for (const n of m.addedNodes) {
                    if (n.nodeType !== 1) continue;
                    if (n.matches && (n.matches(SEL_FILE_LINK) || n.matches(SEL_APPHUB_CARD))) { touched = true; break; }
                    if (n.querySelector && (n.querySelector(SEL_FILE_LINK) || n.querySelector(SEL_APPHUB_CARD))) { touched = true; break; }
                }
                if (touched) break;
            }
            if (!touched) return;
            const kind = pageKind();
            if (kind === 'browse') enhanceBrowsePage(kind);
            else if (kind === 'apphub') enhanceBrowsePage(kind);
            else if (kind === 'artwork') enhanceArtworkPage();
            else if (kind === 'myitems') scanMyItems();
        });
        observer.observe(doc.body, { childList: true, subtree: true });
    }

    function checkUrlChange() {
        const url = global.location.href;
        if (url === lastUrl) return;
        lastUrl = url;
        // v1.8.1：SPA 切页/URL 变化时只重置导航锁与状态文案。
        // 【不能】取消已排程的猎取确认定时器 —— 实测（app/4348910 e2e）Steam 的
        // React Router 会在 hydration 前后对 URL 做参数归一化（replaceState），
        // 触发本函数；若在此取消定时器，跳页与否就取决于「归一化 vs 1.2s 延迟」的
        // 竞速，慢一步就永远卡在「稍后自动检查下一页」。确认回调（starHuntConfirm）
        // 触发时会重新读取当前 URL / DOM / 远征状态再决定，对 URL 变化天然免疫。
        // 远征状态在 localStorage，不受本次清理影响。
        starHuntNavLock = false;
        starHuntNote = '';
        const kind = pageKind();
        // URL 变了 → 旧的聚合容器作废（它属于上一页的数据）
        clearAggregateHost();
        aggState.active = false;
        aggState.ids = [];
        aggState.pages = 0;
        // SPA 内部路由可能切到另一种页面类型 → 走各自的门控（已放行则直接执行）
        if (kind === 'browse') {
            withHydrationGate('browse', async () => {
                enhanceBrowsePage('browse');
                syncNativeSortUi();
                const plan = buildAggregatePlan(loadSettings().perPage);
                if (plan.mode === 'aggregate' && !aggState.active) {
                    const r = await runAggregate(loadSettings().perPage);
                    if (r.ok) { updateAggregatePager(); hideNativePager(global.document); }
                }
            });
        }
        else if (kind === 'apphub') withHydrationGate('apphub', () => enhanceBrowsePage('apphub'));
        else if (kind === 'artwork') withHydrationGate('artwork', () => enhanceArtworkPage());
        else if (kind === 'myitems') scanMyItems();
        else if (kind === 'detail') withHydrationGate('detail', () => enhanceDetailPage());
    }

    function boot() {
        try {
            injectCss();
            watchDomMutations();
            const kind = pageKind();
            if (kind === 'browse') {
                withHydrationGate('browse', async () => {
                    buildToolbar('browse');
                    enhanceBrowsePage('browse');
                    applyPerPageDefault();
                    // 聚合模式（每页 > 50）：服务端按 50 条一页取数，插件把后续几页合并进来
                    const plan = buildAggregatePlan(loadSettings().perPage);
                    if (plan.mode === 'aggregate') {
                        const r = await runAggregate(loadSettings().perPage);
                        if (r.ok) {
                            updateAggregatePager();
                            hideNativePager(global.document);
                        }
                    }
                });
            } else if (kind === 'apphub') {
                // /app/{id}/workshop/：游戏创意工坊首页（分区展示，无分页控件）
                withHydrationGate('apphub', () => {
                    buildToolbar('apphub');
                    enhanceBrowsePage('apphub');
                });
            } else if (kind === 'artwork') {
                withHydrationGate('artwork', () => {
                    buildArtworkToolbar();
                    enhanceArtworkPage();
                });
            } else if (kind === 'myitems') {
                scanMyItems();
            } else if (kind === 'detail') {
                withHydrationGate('detail', () => enhanceDetailPage());
            }
            lastUrl = global.location.href;
            startObserver();

            // SPA 内部路由：轮询 URL（React 路由不改 pushState 之外的事件）
            setInterval(checkUrlChange, 700);
            global.addEventListener('popstate', checkUrlChange);
            if (global.history && typeof global.history.pushState === 'function') {
                const orig = global.history.pushState;
                global.history.pushState = function () {
                    const r = orig.apply(this, arguments);
                    setTimeout(checkUrlChange, 60);
                    return r;
                };
            }
            console.log('%c[Steam 创意工坊增强] v' + VERSION + ' 已启动', 'color:#66c0f4;font-weight:bold;font-size:13px');
        } catch (e) {
            console.warn('[Steam 创意工坊增强] 启动失败', e);
        }
    }

    /** 首次访问时把「每页条数」落到 URL（仅当用户没有自定义过） */
    function applyPerPageDefault() {
        const settings = loadSettings();
        if (!settings.perPage) return;
        const plan = buildAggregatePlan(settings.perPage);
        const p = readBrowseParams(global.location.href);
        // 服务端只认 {10,15,30,50}；聚合模式下服务端按 50 取数，插件自己合并
        if (p.numPerPage === plan.serverSize) return;
        const u = new URL(global.location.href);
        u.searchParams.set('num_per_page', String(plan.serverSize));
        // v1.8.0 刷新循环保险：若 SPA 把 num_per_page 参数又剥掉/改写，旧逻辑会无限
        // location.replace —— 页面永远在加载、始终灰着点不动（「灰色未响应」的死循环模式）。
        // 同一目标 URL 3 秒内只自动重定向一次，第二次直接放弃并留警告。
        try {
            const guardKey = PREFIX + '_ppd_guard';
            const target = u.toString();
            const last = JSON.parse(global.localStorage.getItem(guardKey) || 'null');
            if (last && last.url === target && (Date.now() - toNum(last.ts)) < 3000) {
                console.warn('[Steam 创意工坊增强] 每页条数重定向疑似循环，本次跳过：' + target);
                return;
            }
            global.localStorage.setItem(guardKey, JSON.stringify({ url: target, ts: Date.now() }));
        } catch (_) {}
        global.location.replace(u.toString());
    }

    // ============================================================
    // 导出（单测用）
    // ============================================================

    /**
     * 强制放行所有 hydration 门控并立即执行挂起的增强。
     * 供 DOM 级测试使用：jsdom 里既没有 React 也不会真的异步渲染，
     * 靠时序等门开会不稳定；测试显式开闸，断言的就是「门开之后插件行为是否正确」。
     */
    function forceOpenGates() {
        // 置全局标志：这样无论钩子在 boot 之前还是之后被调用都能生效
        forceGateFlag = true;
        for (const kind in gates) {
            const g = gates[kind];
            if (!g || g.open) continue;
            g.open = true;
            g.pending = false;
            const fn = g.run;
            g.run = null;
            try { if (fn) fn(); } catch (_) {}
        }
    }

    const TEST_HOOKS = {
        parseFileIdFromHref,
        parseAppIdFromHref,
        parseStarRating,
        buildDetailQuery,
        parseDetailsResponse,
        mergeDetails,
        pickStaleIds,
        sortEntries,
        readSsrStarData,
        readSsrStarDataFromHtml,
        ratingInfo,
        passStarFilter,
        applyStarFilter,
        STAR_FILTER_OPTIONS,
        // 星级猎取（v1.8.0：0 命中自动翻下一页）
        STAR_HUNT_KEY,
        STAR_HUNT_MODES,
        STAR_HUNT_MAX_HOPS,
        STAR_HUNT_DELAY_MS,
        STAR_HUNT_WATCHDOG_MS,
        starHuntSig,
        starHuntBase,
        starHuntRead,
        starHuntWrite,
        starHuntClear,
        buildNextPageUrl,
        readSsrBrowseTotalsFromWin,
        formatBytes,
        formatCount,
        formatDateTime,
        formatRelative,
        isRecentlyUpdated,
        upgradePreviewUrl,
        buildBrowseUrl,
        readBrowseParams,
        // 跨页聚合（每页 > 50）
        buildAggregatePlan,
        buildAggregatePageUrl,
        parseSsrBrowseIds,
        parseSsrBrowseMeta,
        parseBrowseIdsFromHtml,
        SERVER_PAGE_SIZES,
        AGGREGATE_FETCH_SIZE,
        runAggregate,
        fetchBrowsePage,
        extractCardNodes,
        findGridContainer,
        gridFromCards,
        aggState,
        // 原生排序（跨页）
        buildNativeSortUrl,
        NATIVE_SORT_OPTIONS,
        currentNativeSortKey,
        navigateTo,
        setNavOverride: (fn) => { navOverride = typeof fn === 'function' ? fn : null; },
        // 艺术作品页
        scanArtworkCards,
        artworkOriginalUrl,
        // 截图瀑布流浮窗（v1.7.0：标题游戏名 + 加载更多真生效 + 加载态）
        wfGameName,
        wfState,
        wfCollectFromDom,
        wfFetchPage,
        wfOpen,
        wfLoadMore,
        wfRelayout,
        wfRenderViewer,
        wfStepViewer,
        wfFindImageIndex,
        WF_PAGE_FETCH,
        WF_BATCH,
        WF_MAX_PAGE_ATTEMPTS,
        // 原图下载降级链（单测用：GM_download → Blob → 新标签）
        openOriginal,
        downloadViaBlob,
        // 收藏夹 / 导出 / 备份
        buildSteamCmdCommand,
        buildSteamCmdBatch,
        mergeFavEntry,
        hasUpdate,
        parseWorkshopItemIdsFromHtml,
        buildItemLink,
        buildSubscriptionBackupJson,
        buildExportText,
        parseSubscriptionImport,
        EXPORT_MODES,
        PAGE_SIZES,
        SORT_OPTIONS,
        API_BATCH_MAX,
        CACHE_TTL_MS,
        // 浮动图标组（dock）
        computeDockPos,
        pickEdgeFromRect,
        loadDockPos,
        saveDockPos,
        applyDockPos,
        ensureDock,
        initDock,
        fitDockPanel,
        DOCK_KEY,
        DOCK_EDGES,
        DOCK_MARGIN,
        DOCK_DEFAULT_EDGE,
        DOCK_DEFAULT_OFF,
        // hydration 门控（DOM 级测试用）
        forceOpenGates,
        gateOpen,
        reactMarkerPresent,
        VERSION
    };

    try { global.__SWE_TEST_HOOKS__ = TEST_HOOKS; } catch (_) {}

    if (global.document && global.document.addEventListener) {
        if (global.document.readyState === 'loading') {
            global.document.addEventListener('DOMContentLoaded', boot, { once: true });
        } else {
            setTimeout(boot, 0);
        }
    }
})(typeof window !== 'undefined' ? window : globalThis);