Upload 104 files

前端页面/components/用户体验_国际化.js

@@ -89,6 +89,12 @@ const translations = {
         'install.source': "来源：{source}",
         'install.source_unavailable': "暂时无法核实安装来源",
         'install.error_source_changed': "资源来源已变更，请刷新资源后重新安装。",
+        'install.open_directory': "打开安装目录",
+        'install.open_receiver': "打开接收目录",
+        'install.directory_requested': "已请求打开，请查看文件管理器。",
+        'install.directory_unavailable': "目标文件夹已移动或不存在，请手动检查。",
+        'install.directory_failed': "暂时无法打开文件夹，请手动打开。",
+        'install.directory_uncertain': "无法确认是否已打开，请先查看文件管理器。",
         'install.error_package_too_large': '下载包超过本地安全上限，已停止安装。',
         'install.error_download': '下载多次中断。请检查网络后重试。',
         'install.error_target_occupied': '旧版本文件仍被占用。关闭 ComfyUI 后再重试更新。',
@@ -867,6 +873,7 @@ const translations = {
         'task.cached_refresh_failed': '暂时无法刷新，仍显示公开缓存内容；操作需联网确认。',
         'feedback.cache_fallback': '⚠️ 网络连接失败，展示的是缓存数据',
         'feedback.refresh_failed_cached': '网络刷新失败，仍显示上次结果',
+        'feedback.list_changed_retry': '列表已更新，请重新加载。',
         // 🔧 新增：以下三条原为散落在各组件里的硬编码中文，现收口到词典以支持多语言
         'feedback.offline_no_cache': '网络已断开，且无本地缓存',
         // ☁️ 云端不可达冷却期内、且本地无缓存可兜底时抛出（详见 网络请求_基础设施.js）。
@@ -1900,6 +1907,12 @@ const translations = {
         'install.source': "Source: {source}",
         'install.source_unavailable': "Installation source cannot be verified",
         'install.error_source_changed': "The resource source changed. Refresh the resource before installing again.",
+        'install.open_directory': "Open installation folder",
+        'install.open_receiver': "Open destination folder",
+        'install.directory_requested': "Open request sent. Check your file manager.",
+        'install.directory_unavailable': "The destination folder moved or no longer exists. Check it manually.",
+        'install.directory_failed': "The folder could not be opened. Open it manually.",
+        'install.directory_uncertain': "The open result is unconfirmed. Check your file manager first.",
         'install.error_package_too_large': 'The download exceeded the local safety limit. Installation was stopped.',
         'install.error_download': 'The download failed repeatedly. Check the network before retrying.',
         'install.error_target_occupied': 'Files from the previous version are in use. Close ComfyUI before retrying the update.',
@@ -2670,6 +2683,7 @@ const translations = {
         'task.cached_refresh_failed': 'Refresh unavailable. Saved public content remains visible; actions require an online check.',
         'feedback.cache_fallback': '⚠️ Network failed, showing cached data',
         'feedback.refresh_failed_cached': 'Refresh failed. The previous results are still shown.',
+        'feedback.list_changed_retry': 'The list has changed. Please reload it.',
         'feedback.offline_no_cache': 'Network disconnected, and no local cache available',
         'feedback.cloud_unreachable_no_cache': 'Cloud service is unreachable, and there is no local content to show',
         'feedback.search_local_result': '⚠️ Network unavailable, showing local search results',

前端页面/core/侧边栏数据引擎.js

@@ -1,713 +1,764 @@
-// 前端页面/core/侧边栏数据引擎.js
-// ==========================================
-// 📊 侧边栏数据加载引擎
-// ==========================================
-// 作用：负责列表数据的加载、缓存、分页、渲染
-// 关联文件：
-//   - 网络请求API.js (数据获取)
-//   - 列表卡片组件.js (工具/应用卡片渲染)
-//   - 创作者卡片组件.js (创作者卡片渲染)
-//   - 性能优化工具.js (分页加载、骨架屏)
-// ==========================================
-// ⚡ P1性能优化：
-//   - 首屏仅加载 PAGE_SIZE 条数据
-//   - 滚动到底部自动加载更多
-//   - 骨架屏加载动画
-//   - 增强缓存策略
-// ==========================================
-
-import { fetchSidebarList, readSidebarListCache, readCreatorsSessionCache as getCreatorsFromSessionStorage,
-    writeCreatorsSessionCache as saveCreatorsToSessionStorage } from "./榜单数据来源.js";
-import { mountSidebarDomainView } from "./榜单视图切换.js";
-import { setupSidebarPagination as _setupPaginationLoader } from "./榜单分页控制.js";
-import { createSidebarPaginationStore } from "./榜单分页状态.js";
-import { sortDataLocally, filterItemsByKeyword, searchCreatorsLocally } from "./榜单本地查询.js";
-
-import { api } from "./网络请求API.js";
-import { proxyImages } from "./网络请求API.js";
-import { createItemCard } from "../market/列表卡片组件.js";
-import { createCreatorCard } from "../market/创作者卡片组件.js";
-import {
-    createSkeleton,
-    setCache,
-    lazyLoadImages,
-    renderListLoadError
-} from "../components/性能优化工具.js";
-import { applyViewportAnimations, getAnimationTypeForTab, scrollCardIntoView, stopViewportAnimations } from "../components/动画音效引擎.js";
-import { t } from "../components/用户体验增强.js";
-import { showToast } from "../components/UI交互提示组件.js";  // 🔧 降级提示改走统一组件（原为手写 div）
-
-// 💬 讨论区组件（动态导入）
-let postsViewModule = null;
-async function getPostsView() {
-    if (!postsViewModule) {
-        postsViewModule = await import("../post/讨论区组件.js");
-    }
-    return postsViewModule;
-}
-
-// 📝 任务榜组件（动态导入）
-let tasksViewModule = null;
-async function getTasksView() {
-    if (!tasksViewModule) {
-        tasksViewModule = await import("../task/任务榜组件.js");
-    }
-    return tasksViewModule;
-}
-
-// 🧩 提示词组件（动态导入）
-let promptsViewModule = null;
-async function getPromptsView() {
-    if (!promptsViewModule) {
-        promptsViewModule = await import("../prompt/提示词组件.js");
-    }
-    return promptsViewModule;
-}
-
-
-// ==========================================
-// 🔧 配置常量
-// ==========================================
-const PAGE_SIZE = 20;                           // 每页数量
-const CREATORS_PAGE_SIZE = 12;                  // 创作者每页数量（卡片更大）
-
-/**
- * ⏱️ 获取缓存过期时间（毫秒）
- * 从用户设置中读取，默认2小时（7200秒）
- * @returns {number} 缓存过期时间（毫秒）
- */
-function getCacheExpireTime() {
-    try {
-        const settingsStr = localStorage.getItem('ComfyCommunity_Settings');
-        if (settingsStr) {
-            const settings = JSON.parse(settingsStr);
-            const seconds = parseInt(settings.cacheExpireSeconds);
-            if (seconds && seconds >= 60 && seconds <= 86400) {
-                return seconds * 1000;  // 转为毫秒
-            }
-        }
-    } catch (e) {}
-    return 1000 * 60 * 60 * 2;  // 默认2小时
-}
-
-// ==========================================
-// 🔄 同榜单数据与创作者会话缓存
-// ==========================================
-/**
- * 从同 tab 的任意排序状态中获取已有数据
- */
-const findExistingTabData = tab => paginationStore.findCompleteData(tab);
-
-// ==========================================
-// 📦 分页状态管理
-// ==========================================
-// 每个标签页独立的分页状态
-const paginationStore = createSidebarPaginationStore();
-const getPaginationState = (tab, sort) => paginationStore.get(tab, sort);
-
-export function disposeSidebarContent(contentArea) {
-    stopViewportAnimations(contentArea);
-    try { paginationStore.stopLoaders(); }
-    catch { console.warn('Sidebar pagination cleanup failed'); }
-    for (const child of Array.from(contentArea.children)) {
-        const cleanup = child._cleanup;
-        child._cleanup = null;
-        try { cleanup?.call(child); }
-        catch { console.warn('Sidebar list view cleanup failed'); }
-    }
-}
-
-
-// ==========================================
-// 🚀 主加载函数
-// ==========================================
-export async function loadSidebarContent({
-    tab,
-    sort,
-    keyword,
-    contentArea,
-    currentUser,
-    renderToken,
-    getRenderToken,
-    force = false,
-    expandItemId = null,  // 新增：要自动展开的卡片ID
-    isNavigationCurrent = () => true
-}) {
-    if (renderToken !== getRenderToken()) return;
-    const canNavigate = () => renderToken === getRenderToken() && isNavigationCurrent();
-    // 新榜单取得视图所有权时停止所有旧分页器，保留各榜单已加载数据。
-    paginationStore.stopLoaders();
-
-    const domainViews = {
-        posts: { loadModule: getPostsView, factory: 'createPostsView', errorKey: 'feedback.load_posts_failed',
-            afterMount: module => { if (module.loadPosts) module.loadPosts(); } },
-        tasks: { loadModule: getTasksView, factory: 'createTasksView', errorKey: 'feedback.load_tasks_failed' },
-        prompts: { loadModule: getPromptsView, factory: 'createPromptsView', errorKey: 'feedback.load_prompts_failed' },
-    };
-    if (Object.hasOwn(domainViews, tab)) {
-        await mountSidebarDomainView({ contentArea, currentUser, keyword, renderToken, getRenderToken,
-            ...domainViews[tab] });
-        return;
-    }
-
-    const cacheKey = `ListCache_${tab}_${sort}`;
-    const state = getPaginationState(tab, sort);
-    const pageSize = tab === "creators" ? CREATORS_PAGE_SIZE : PAGE_SIZE;
-    const sameCreatorSearchData = tab === "creators" && keyword && state.isSearchResult &&
-        state.searchKeyword === keyword && Array.isArray(state.allData) && state.allData.length > 0
-        ? state.allData
-        : null;
-
-    // ========== 🔄 强制刷新：清除当前 tab/sort 的内存缓存 ==========
-    if (force) {
-        state.allData = [];
-        state.displayedCount = 0;
-        state.isFullyLoaded = false;
-        if (!sameCreatorSearchData) {
-            state.isSearchResult = false;
-            state.searchKeyword = "";
-        }
-    }
-
-    // 停止之前的分页加载器
-    if (state.loader) {
-        state.loader.stop();
-        state.loader = null;  // 清除引用，防止旧分页器状态残留
-    }
-
-    // ========== 🔍 搜索过滤统一入口 ==========
-    // 🔧 修复：过滤职责原先分裂在三处且口径不一致 —— loadMoreData 与分页器的
-    // getTotalDataCount 都是「先过滤再切片」（正确），而各首屏分支是「先切 20 条再过滤」，
-    // renderBatch 内部又对切好的批次再过滤一次。后果不只是首屏条数偏少：首屏与分页
-    // 处于不同的数据空间（首屏在「原始前 20 条」里找匹配，分页在「过滤后全集」里按 20
-    // 步长切片），排在第 20 条之后的匹配项会永久丢失，甚至首屏直接显示「没有搜索到相关内容」。
-    // 现统一收口到本函数：所有取数路径都先过滤、再切片，renderBatch 只负责渲染。
-    // 创作者Tab的 keyword 由后端搜索接口过滤，此处不做本地过滤（与原口径一致）。
-    const _applySearchScope = (dataArray) => {
-        const scoped = !keyword || tab === "creators" ? dataArray : filterItemsByKeyword(dataArray, keyword);
-        if (!expandItemId || tab === "creators") return scoped;
-        const target = dataArray.find(item => String(item.id) === String(expandItemId));
-        if (!target) return scoped;
-        return [target, ...scoped.filter(item => String(item.id) !== String(expandItemId))];
-    };
-
-    // ========== 渲染函数：渲染一批数据（只渲染，过滤由 _applySearchScope 统一负责）==========
-    let targetLookupStarted = false;
-    const renderBatch = (dataArray, append = false) => {
-        if (renderToken !== getRenderToken()) return;
-
-        // 🔧 数据已由调用方经 _applySearchScope 过滤，本函数只负责渲染（不再二次过滤）
-        const displayData = dataArray;
-
-        // 首次渲染清空容器
-        if (!append) {
-            disposeSidebarContent(contentArea);
-            contentArea.innerHTML = "";
-            state.displayedCount = 0;
-        }
-
-        // 空数据处理
-        if (displayData.length === 0 && state.displayedCount === 0) {
-            const emptyState = document.createElement('div');
-            emptyState.className = 'sidebar-status-message';
-            emptyState.textContent = t(keyword ? 'feedback.no_search_results' : 'feedback.no_list_data');
-            emptyState.setAttribute('role', 'status');
-            contentArea.replaceChildren(emptyState);
-            if (!expandItemId) return 0;
-        }
-
-        // 渲染卡片
-        const fragment = document.createDocumentFragment();
-        const animationType = getAnimationTypeForTab(tab);
-        const cards = [];
-        let targetCard = null;  // 用于保存需要展开的目标卡片
-
-        if (tab === "tools" || tab === "skills" || tab === "apps" || tab === "recommends") {
-            displayData.forEach(data => {
-                const card = createItemCard(data, currentUser);
-                cards.push(card);
-                fragment.appendChild(card);
-                // 检查是否是需要展开的卡片
-                if (expandItemId && String(data.id) === String(expandItemId)) {
-                    targetCard = card;
-                }
-            });
-        } else if (tab === "creators") {
-            displayData.forEach(data => {
-                const card = createCreatorCard(data, currentUser);
-                cards.push(card);
-                fragment.appendChild(card);
-            });
-        }
-
-        contentArea.appendChild(fragment);
-
-        // ✨ 应用视口感知动画：可见卡片依次错开载入，滚动/分页进入视口的卡片自动补播动画
-        applyViewportAnimations(contentArea, cards, animationType, !append);
-
-        // 对新渲染的图片启用懒加载
-        lazyLoadImages(contentArea, "img:not(.lazy-loaded):not(.lazy-loading)");
-
-        // 🔔 自动展开目标卡片（如果有）
-        if (targetCard && !append) {
-            requestAnimationFrame(() => {
-                if (!canNavigate()) return;
-                // 滚动到卡片位置
-                scrollCardIntoView(targetCard);
-                // 模拟点击摘要区域展开卡片
-                const summary = targetCard.querySelector('.item-summary') || targetCard.firstElementChild;
-                if (summary) summary.click();
-            });
-        }
-
-        // 目标不在列表快照中时补取，仍使用原榜单卡片展开。
-        if (expandItemId && !targetCard && !append && !targetLookupStarted && canNavigate()) {
-            targetLookupStarted = true;
-            (async () => {
-                try {
-                    const res = await api.getItemById(expandItemId);
-                    if (!canNavigate()) return;
-                    if (res?.status !== "success" || !res.data || String(res.data.id) !== String(expandItemId)) {
-                        showToast(t('notif.item_not_found'), "error");
-                        return;
-                    }
-                    const target = state.allData.find(item => String(item.id) === String(expandItemId)) || proxyImages([res.data])[0];
-                    state.loader?.stop();
-                    state.loader = null;
-                    state.allData = [target, ...state.allData.filter(item => String(item.id) !== String(expandItemId))];
-                    const scoped = _applySearchScope(state.allData);
-                    renderBatch(scoped.slice(0, pageSize), false);
-                    if (scoped.length > pageSize) {
-                        _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
-                    }
-                } catch (_) {
-                    if (canNavigate()) showToast(t('notif.load_item_failed'), "error");
-                }
-            })();
-        }
-
-        state.displayedCount += displayData.length;
-        return displayData.length;
-    };
-
-    // ========== 分页加载更多函数 ==========
-    const loadMoreData = async (page, size, { isCurrent = () => true } = {}) => {
-        if (!isCurrent()) return [];
-        // 计算要显示的数据范围
-        const start = (page - 1) * size;
-        const end = start + size;
-
-        // 从全量数据中截取（统一走 _applySearchScope，与首屏处于同一数据空间）
-        const dataSlice = _applySearchScope(state.allData);
-
-        const batch = dataSlice.slice(start, end);
-
-        if (batch.length > 0) {
-            renderBatch(batch, true);
-        }
-
-        return batch;
-    };
-
-    // ========== 尝试从缓存加载 ==========
-    // 📌 本处的缓存口径与 任务榜/讨论区/提示词（统一走 性能优化工具.js 的
-    // readListCache，命中后一律调 silentRefresh 后台补新）**刻意不同**，不是历史遗留，勿顺手归一：
-    //   - 这里缓存的是全量数据（items 200 条 / creators 500 条），分页完全在本地做，
-    //     所以缓存命中即等于「数据完整」，只在 expired 时才值得再发一次网络请求；
-    //   - 那三个列表只缓存第一页，命中后数据必然不完整，故一律后台 silentRefresh 补新。
-    // 若强行统一成「总是后台刷新」，插件榜会在每次 Tab 切换时多发一次 200 条的全量请求。
-    // 获取完整缓存信息（包含过期状态）
-    const { value: cachedData, expired: isCacheExpired, found: hasCacheData } =
-        readSidebarListCache(cacheKey, { creators: tab === 'creators' });
-
-    // 有缓存时直接渲染缓存（搜索时也使用缓存，renderBatch 会处理 keyword 过滤）
-    // 🔍 创作者Tab有keyword时不使用缓存，每次都从后端搜索
-    // 🔧 修复：原实现还把「刚清空搜索框」也列为跳过缓存的理由，但 cacheKey 不含 keyword、
-    // 搜索结果也从不��入该键（见下方 isCreatorSearch 判断），缓存里存的始终是干净的全量列表，
-    // 清空搜索框后完全可以直接用缓存上屏；强制联网只会让用户在弱网下白等一整个重试预算
-    const skipCache = tab === "creators" && !!keyword;
-    if (!force && hasCacheData && !skipCache) {
-        // 🚀 缓存数据也需要过一遍图片代理，确保新字段也被处理
-        const proxiedData = proxyImages(cachedData);
-        state.allData = proxiedData;
-        state.isFullyLoaded = true;
-        // 缓存是全量列表而非搜索结果，清除搜索标记，避免下次加载仍被当作搜索结果处理
-        if (tab === "creators" && !keyword) {
-            state.isSearchResult = false;
-            state.searchKeyword = "";
-        }
-
-        // 首屏渲染（仅第一页）—— 先过滤再切片，与 loadMoreData 同一数据空间
-        const scopedData = _applySearchScope(proxiedData);
-        renderBatch(scopedData.slice(0, pageSize), false);
-
-        // 如果有更多数据，启动分页加载器
-        if (scopedData.length > pageSize) {
-            _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
-        }
-
-        // 【新增】Tab 切换后台静默刷新 —— 仅缓存过期时触发
-        if (isCacheExpired) {
-            console.log(`🔄 缓存已过期，${tab}_${sort} 启动后台静默刷新...`);
-
-            setTimeout(async () => {
-                // 保存当前上下文快照，防止网络延迟期间用户切换Tab导致竞态
-                const savedToken = renderToken;
-                const savedTab = tab;
-                const savedSort = sort;
-
-                // 防竞态检查1：回调开始执行时验证
-                if (savedToken !== getRenderToken()) return;
-
-                try {
-                    const rawData = await fetchSidebarList({ tab: savedTab, sort: savedSort, background: true });
-                    if (savedToken !== getRenderToken()) return;
-                    const newData = proxyImages(rawData);
-
-                    // 防竞态检查2：网络请求完成后再次验证
-                    if (savedToken !== getRenderToken()) return;
-
-                    // 🛡️ 空响应防护：云端返回空列表时不回写缓存、也不清屏重渲染。
-                    // 本分支由「缓存过期」触发，是切 Tab 时最常走到的路径，若不拦，
-                    // 下方 state.allData = newData + contentArea.innerHTML = "" 会把
-                    // 已上屏的本地数据连画面带缓存一起清空（见 _isEmptyOverwrite 说明）
-                    if (_isEmptyOverwrite(newData, state.allData, cachedData)) {
-                        console.warn(`🛡️ ${savedTab}_${savedSort} 云端返回空列表，保留本地数据，跳过缓存回写`);
-                        return;
-                    }
-
-                    // 只有token匹配时才同时更新state.allData和setCache
-                    if (_shouldUpdateData(state.allData, newData)) {
-                        console.log(`✅ ${savedTab}_${savedSort} 检测到新数据，执行静默更新`);
-                        state.allData = newData;
-                        state.displayedCount = 0; // 重置分页计数
-                        // 📴 持久化到 localStorage，保证重启后离线仍可展示
-                        setCache(cacheKey, newData, getCacheExpireTime(), true);
-
-                        // 更新创作者 sessionStorage 缓存
-                        if (savedTab === "creators") {
-                            saveCreatorsToSessionStorage(newData);
-                        }
-
-                        // 完整重新渲染（替代之前只更新数字的方案）
-                        // 🔧 先过滤再切片：搜索场景下静默刷新同样会触发，
-                        // 原实现在 newData 前 20 条里过滤，会漏掉靠后的匹配项
-                        const scopedNewData = _applySearchScope(newData);
-                        renderBatch(scopedNewData.slice(0, pageSize), false);
-
-                        if (scopedNewData.length > pageSize) {
-                            _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, savedTab, savedToken, getRenderToken);
-                        }
-                    } else {
-                        // 关键字段无变化 → 无需重渲染。但 newData 才是刚从云端取回的权威数据，
-                        // 缓存必须回写 newData：若仍回写旧的 state.allData，等于把旧数据固化并
-                        // 续期（续期后 isCacheExpired 转 false，下次连静默刷新都不再触发），
-                        // 导致缓存中的旧版本号被长期锁死、卡片徽章无法出现。
-                        // 注意此处刻意不更新 state.allData：首屏已按旧数据渲染，保持二者一致可
-                        // 避免分页加载与已渲染卡片错位；新数据在下次进入读取缓存时生效
-                        setCache(cacheKey, newData, getCacheExpireTime(), true);
-                    }
-                } catch (err) {
-                    if (savedToken !== getRenderToken()) return;
-                    console.warn(`⚠️ ${savedTab}_${savedSort} 后台刷新失败`);
-                }
-            }, 0);
-        }
-
-        return;
-    }
-
-    // ========== 🔄 本地排序优先：同 tab 已有数据时直接排序渲染（强制刷新时跳过）==========
-    // 🔍 创作者Tab有keyword时不走本地排序优先，必须调用后端搜索API
-    // 🔍 创作者Tab清空搜索框后也不走本地排序优先，避免使用搜索时的部分结果
-    // 🔍 如果当前state是搜索结果，也不走本地排序优先
-    // 仅在"正在搜索"或"刚清空搜索但state仍是搜索结果"时跳过本地排序
-    const isCreatorSearching = tab === "creators" && keyword;
-    const isCreatorSearchCleared = tab === "creators" && !keyword && state.isSearchResult;
-    const skipLocalSort = isCreatorSearching || isCreatorSearchCleared || state.isSearchResult;
-    const existingData = findExistingTabData(tab);
-    if (!force && !skipLocalSort && existingData && existingData.length > 0) {
-        const locallySorted = sortDataLocally(existingData, tab, sort);
-        state.allData = locallySorted;
-        state.isFullyLoaded = true;
-        state.displayedCount = 0;  // 重置已显示计数，因为数据重新排序了
-
-        // 首屏渲染（先过滤再切片）
-        const scopedSorted = _applySearchScope(locallySorted);
-        renderBatch(scopedSorted.slice(0, pageSize), false);
-
-        // 启动分页加载器
-        if (scopedSorted.length > pageSize) {
-            _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
-        }
-
-        // 存入当前排序的缓存（📴 创作者数据同样持久化到 localStorage，保证重启后离线可展示）
-        setCache(cacheKey, locallySorted, getCacheExpireTime(), true);
-
-        return; // 本地排序后直接返回，不需要后台刷新（数据是同一批）
-    }
-
-    // ========== 🚀 缓存先行：阻塞前先用本地已有数据上屏 ==========
-    // 走到这里说明上面两条快路径都没命中：要么是 force 强制刷新（刻意跳过缓存），
-    // 要么是本次会话还没有该 tab 的完整数据。弱网下一次列表请求最长要烧满整个重试预算，
-    // 期间用户只能盯骨架屏；此刻若本地已有可用数据，就先渲染首屏，网络请求照常往下走，
-    // 回来后按 renderToken + _shouldUpdateData 决定是否重渲染（与上方静默刷新同口径）。
-    // 🔍 新关键词的创作者搜索不参与缓存先行，避免显示其它查询结果；只有强制刷新当前同一关键词时，
-    // 才临时复用精确匹配的上一批搜索结果（state.searchKeyword），失败时继续保留它。
-    let renderedInstant = false;
-    if (!isCreatorSearching || sameCreatorSearchData) {
-        // 可立即上屏的数据：当前排序的列表缓存（force 时被跳过）→ 创作者 sessionStorage 降级副本
-        let instantData = sameCreatorSearchData ||
-            ((hasCacheData && Array.isArray(cachedData) && cachedData.length > 0) ? cachedData : null);
-        if (!instantData && tab === "creators") {
-            const sessionData = getCreatorsFromSessionStorage();
-            if (Array.isArray(sessionData) && sessionData.length > 0) instantData = sessionData;
-        }
-        if (instantData) {
-            console.log(`🚀 ${tab}_${sort} 缓存先行：先用本地数据渲染首屏，网络请求转后台`);
-            // 🚀 与上方缓存命中分支同口径：本地数据也过一遍图片代理（proxyImages 内部会先剥除
-            // 已有代理前缀，幂等），确保代理规则新增的字段同样被处理
-            // sessionStorage 副本的顺序不保证与当前排序一致，统一本地排一次（对已排序数据幂等）
-            const sortedData = sortDataLocally(proxyImages(instantData), tab, sort);
-            state.allData = sortedData;
-            state.isFullyLoaded = true;
-            state.isSearchResult = !!sameCreatorSearchData;
-            state.searchKeyword = sameCreatorSearchData ? keyword : "";
-            // 🔧 先过滤再切片（tools/skills/apps/recommends 带 keyword 时同样会进入本分支）
-            const scopedInstant = _applySearchScope(sortedData);
-            renderBatch(scopedInstant.slice(0, pageSize), false);
-            if (scopedInstant.length > pageSize) {
-                _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
-            }
-            renderedInstant = true;
-        }
-    }
-
-    // ========== 显示加载骨架屏（已有本地数据上屏时跳过，避免闪屏）==========
-    if (!renderedInstant) {
-        disposeSidebarContent(contentArea);
-        contentArea.innerHTML = "";
-        const skeleton = createSkeleton(tab === "creators" ? "list" : "card", 3);
-        contentArea.appendChild(skeleton);
-    }
-
-    // ========== 从网络加载数据 ==========
-    try {
-        const rawData = await fetchSidebarList({ tab, sort, keyword, force });
-        if (renderToken !== getRenderToken()) return;
-        const realData = proxyImages(rawData);
-        if (renderToken !== getRenderToken()) return;
-        if (tab === 'creators') {
-            state.isSearchResult = !!keyword;
-            state.searchKeyword = keyword || '';
-        }
-
-        // 存入缓存（📴 创作者数据同样持久化到 localStorage，保证重启后离线仍可展示；搜索结果不存入缓存）
-        const isCreatorSearch = tab === "creators" && keyword;
-        // 🛡️ 空响应防护：创作者搜索命中 0 条是有效答案（下方要渲染「没有搜索到相关内容」），
-        // 必须排除在防护之外，否则会把空搜索结果误判成云端故障、改渲染全量列表
-        const isEmptyOverwrite = !isCreatorSearch && _isEmptyOverwrite(realData, cachedData, state.allData);
-        if (isEmptyOverwrite) {
-            console.warn(`🛡️ ${tab}_${sort} 云端返回空列表，保留本地数据，不覆盖缓存`);
-        } else if (!isCreatorSearch) {
-            setCache(cacheKey, realData, getCacheExpireTime(), true);
-        }
-
-        // 创作者非搜索数据存入 sessionStorage（用于离线降级）
-        if (tab === "creators" && !isCreatorSearch && !isEmptyOverwrite) {
-            saveCreatorsToSessionStorage(realData);
-        }
-
-        state.isFullyLoaded = true;
-
-        // 🛡️ 空响应且本地数据已上屏：保持当前画面，不用空列表清屏（与缓存同口径不回写）
-        if (isEmptyOverwrite && renderedInstant) {
-            return;
-        }
-
-        // 🚀 缓存先行场景：网络数据与已上屏的本地数据无实质差异时不重渲染，避免清屏重画
-        // 打断用户已经滚动的阅读位置（与上方后台静默刷新同口径）。缓存已在上面回写权威新数据，
-        // 此处刻意不更新 state.allData，保持与已渲染卡片一致，防止分页加载错位
-        if (renderedInstant && !_shouldUpdateData(state.allData, realData)) {
-            return;
-        }
-
-        // 更新状态
-        state.allData = realData;
-
-        // 渲染首屏（先过滤再切片：tools/skills/apps/recommends 的 keyword 是本地搜索，
-        // realData 是未过滤的全量数据，原实现在前 20 条里过滤会漏掉靠后的匹配项）
-        const scopedReal = _applySearchScope(realData);
-        renderBatch(scopedReal.slice(0, pageSize), false);
-
-        // 启动分页加载器
-        if (scopedReal.length > pageSize) {
-            _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
-        }
-
-    } catch (error) {
-        // 🔍 防竞态：本次加载已被更新的加载取代（切Tab、换排序、继续输入关键词）时直接退出。
-        // renderBatch 内部本来就有这道守卫，但它之外的降级分支会直接写 contentArea.innerHTML
-        // 并弹提示，缺少守卫会让过期结果覆盖掉新内容
-        if (renderToken !== getRenderToken()) {
-            console.warn(`⏹️ ${tab}_${sort} 请求已过期，忽略本次失败`);
-            return;
-        }
-        // 🔍 主动撤销（上方 cancelAll）不是网络故障：用户只是又敲了一个字，
-        // 新一次加载已经在跑了。这里必须静默退出，否则会误弹「网络不可用」提示
-        if (error && error.name === 'RequestCancelledError') {
-            console.log(`⏹️ ${tab}_${sort} 搜索请求已被新关键词取代`);
-            return;
-        }
-        console.error("数据加载失败");
-
-        // 🚀 缓存先行场景：首屏已经用本地数据上屏，网络失败时保持当前画面即可，不再走下面的
-        // 降级分支（否则会把同一批数据重渲染一遍、重播卡片动画）。与上方后台静默刷新失败一致：
-        // 只记录日志，不额外打扰用户
-        if (renderedInstant) {
-            console.warn(`📴 ${tab}_${sort} 网络刷新失败，保持已渲染的本地数据`);
-            if (force) showToast(t('feedback.refresh_failed_cached'), 'warning');
-            return;
-        }
-
-        // 🚀 回退到任何可用缓存（包括过期的）
-        // 🔍 创作者Tab搜索场景跳过此分支：renderBatch 对��作者不做本地过滤，
-        // 直接渲染全量缓存会导致搜索结果未过滤，改由下方本地搜索降级分支处理
-        if (hasCacheData && cachedData && !(tab === "creators" && keyword)) {
-            console.warn(`📴 网络失败，降级显示${isCacheExpired ? '过期' : ''}缓存`);
-            state.allData = cachedData;
-            // 🔧 先过滤再切片：本分支已排除 creators+keyword，但 tools/skills/apps/recommends
-            // 带 keyword 时会进来；renderBatch 不再自行过滤，此处必须显式过滤
-            const scopedCached = _applySearchScope(cachedData);
-            renderBatch(scopedCached.slice(0, pageSize), false);
-
-            // 如果是过期缓存，显示提示
-            // 🔧 改用统一提示组件 + 词典（原为手写 div、无动画不排队，且文案硬编码中文）
-            if (isCacheExpired) {
-                showToast(t('feedback.cache_fallback'), 'warning');
-            }
-            return;
-        }
-
-        // 🚀 创作者Tab：尝试从 sessionStorage 或内存中降级
-        if (tab === "creators") {
-            let fallbackData = null;
-
-            // 1. 优先从当前内存状态获取
-            if (state.allData && state.allData.length > 0 &&
-                (!state.isSearchResult || state.searchKeyword === keyword)) {
-                fallbackData = state.allData;
-            }
-            // 2. 从本地列表缓存获取（含过期缓存，搜索结果不入库故不会污染）
-            if (!fallbackData && hasCacheData && cachedData) {
-                fallbackData = cachedData;
-            }
-            // 3. 尝试从 sessionStorage 获取
-            if (!fallbackData) {
-                fallbackData = getCreatorsFromSessionStorage();
-            }
-            // 4. 从其他排序状态获取
-            if (!fallbackData) {
-                fallbackData = findExistingTabData("creators");
-            }
-
-            if (fallbackData && fallbackData.length > 0) {
-                let displayData = fallbackData;
-
-                // 搜索场景：执行本地搜索
-                if (keyword) {
-                    displayData = searchCreatorsLocally(keyword, fallbackData);
-                    if (displayData.length === 0) {
-                        const emptyState = document.createElement('div');
-                        emptyState.className = 'sidebar-status-message';
-                        emptyState.textContent = t('feedback.no_search_results');
-                        emptyState.setAttribute('role', 'status');
-                        contentArea.replaceChildren(emptyState);
-
-                        // 🔧 改用统一提示组件 + 词典（原为手写 div 且文案硬编码中文）
-                        showToast(t('feedback.search_local_result'), 'warning');
-                        return;
-                    }
-                }
-
-                // 按当前排序排序
-                displayData = sortDataLocally(displayData, tab, sort);
-                state.allData = displayData;
-                // 统一走 _applySearchScope（创作者Tab恒等返回，数据已由上方
-                // searchCreatorsLocally 过滤），保证各渲染入口口径完全一致
-                const scopedFallback = _applySearchScope(displayData);
-                renderBatch(scopedFallback.slice(0, pageSize), false);
-
-                // 启动分页加载器
-                if (scopedFallback.length > pageSize) {
-                    _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
-                }
-
-                // 🔧 改用统一提示组件 + 词典（原为手写 div 且两条文案均硬编码中文）
-                showToast(keyword ? t('feedback.search_local_result') : t('feedback.cache_fallback'), 'warning');
-                return;
-            } else if (keyword) {
-                renderListLoadError(contentArea, t('common.network_error_retry'), () => loadSidebarContent({
-                    tab, sort, keyword, contentArea, currentUser, renderToken, getRenderToken,
-                    force: true, expandItemId, isNavigationCurrent
-                }), t, error);
-                return;
-            }
-        }
-
-        // 无本地数据时提供原位重试，保留当前 ComfyUI 页面与榜单上下文。
-        renderListLoadError(contentArea, t('common.network_error_retry'), () => loadSidebarContent({
-            tab, sort, keyword, contentArea, currentUser, renderToken, getRenderToken,
-            force: true, expandItemId, isNavigationCurrent
-        }), t, error);
-    }
-}
-
-
-/**
- * 🛡️ 空响应防护：本次云端返回是否属于「请求成功但列表为空」，且本地已有非空数据
- *
- * 背景：网络失败本身从不清理本地数据（重试耗尽只置云端冷却并回退过期缓存，见技术文档
- * 04 章 4.2.2），但云端偶发返回 HTTP 200 + data:[] 会——例如 Space 冷启动时 HF Dataset
- * 尚未加载完。此时 realData/newData 为 []，照原样回写缓存就把断网降级的唯一数据来源清掉了。
- *
- * 只拦「新数据为空 且 本地已有非空数据」这一种组合：本地本来就是空的（首次使用、刚清过
- * 缓存、云端确实一条都没有）时返回 false，照常写入，不改变任何正常流程。
- * 调用方须自行排除搜索结果场景——搜索命中 0 条是有效答案，不是云端故障。
- *
- * @param {Array} newData - 本次从云端取回的数据
- * @param {...(Array|null|undefined)} localData - 本地已有数据（缓存副本 / 内存 state.allData）
- * @returns {boolean} true = 属于会覆盖本地好数据的空响应，应跳过回写与重渲染
- */
-function _isEmptyOverwrite(newData, ...localData) {
-    if (Array.isArray(newData) && newData.length > 0) return false;
-    return localData.some(d => Array.isArray(d) && d.length > 0);
-}
-
-/** 判断是否需要更新数据 —— 对比ID顺序和关键字段 */
-function _shouldUpdateData(oldData, newData) {
-    if (!oldData || !newData) return true;
-    if (oldData.length !== newData.length) return true;
-
-    // 检查ID顺序是否一致（检测排序变化、新增/删除）
-    // 比对条数覆盖首屏渲染量（PAGE_SIZE），避免首屏可见卡片（第 11~20 条）的版本/数字更新被漏检
-    const checkCount = Math.min(PAGE_SIZE, oldData.length);
-    for (let i = 0; i < checkCount; i++) {
-        const oldId = oldData[i].id || oldData[i].account;
-        const newId = newData[i].id || newData[i].account;
-        if (oldId !== newId) return true;
-
-        // 检查关键数字字段
-        const keyFields = ['likes', 'downloads', 'uses', 'views', 'daily_views', 'recent_tips', 'favorites', 'rating_avg', 'rating_count'];
-        for (const field of keyFields) {
-            if ((oldData[i][field] || 0) !== (newData[i][field] || 0)) return true;
-        }
-
-        // 检查版本号（字符串）：云端扫描到插件新版本时往往只有 latest_version 变化，
-        // 点赞/下载/浏览等数字字段全不动；若不比对它，卡片上的"可更新"徽章将永远刷不出来
-        if ((oldData[i].latest_version || '') !== (newData[i].latest_version || '')) return true;
-    }
-    return false;
-}
-
-
+// 前端页面/core/侧边栏数据引擎.js
+// ==========================================
+// 📊 侧边栏数据加载引擎
+// ==========================================
+// 作用：负责列表数据的加载、缓存、分页、渲染
+// 关联文件：
+//   - 网络请求API.js (数据获取)
+//   - 列表卡片组件.js (工具/应用卡片渲染)
+//   - 创作者卡片组件.js (创作者卡片渲染)
+//   - 性能优化工具.js (分页加载、骨架屏)
+// ==========================================
+// ⚡ P1性能优化：
+//   - 首屏仅加载 PAGE_SIZE 条数据
+//   - 滚动到底部自动加载更多
+//   - 骨架屏加载动画
+//   - 增强缓存策略
+// ==========================================
+
+import { fetchSidebarList, getSidebarResponseCacheSource, readSidebarListCache, readCreatorsSessionCache as getCreatorsFromSessionStorage,
+    writeCreatorsSessionCache as saveCreatorsToSessionStorage } from "./榜单数据来源.js";
+import { mountSidebarDomainView } from "./榜单视图切换.js";
+import { setupSidebarPagination as _setupPaginationLoader } from "./榜单分页控制.js";
+import { createSidebarPaginationStore } from "./榜单分页状态.js";
+import { sortDataLocally, filterItemsByKeyword, searchCreatorsLocally } from "./榜单本地查询.js";
+import { getSidebarListCacheKey } from "./全局配置.js";
+import { captureCacheSource, captureCacheWrite } from "./网络请求_缓存管理.js";
+
+import { api } from "./网络请求API.js";
+import { proxyImages } from "./网络请求API.js";
+import { createItemCard } from "../market/列表卡片组件.js";
+import { createCreatorCard } from "../market/创作者卡片组件.js";
+import {
+    createSkeleton,
+    setCache,
+    lazyLoadImages,
+    renderListLoadError
+} from "../components/性能优化工具.js";
+import { applyViewportAnimations, getAnimationTypeForTab, scrollCardIntoView, stopViewportAnimations } from "../components/动画音效引擎.js";
+import { t } from "../components/用户体验增强.js";
+import { showToast } from "../components/UI交互提示组件.js";  // 🔧 降级提示改走统一组件（原为手写 div）
+
+// 💬 讨论区组件（动态导入）
+let postsViewModule = null;
+async function getPostsView() {
+    if (!postsViewModule) {
+        postsViewModule = await import("../post/讨论区组件.js");
+    }
+    return postsViewModule;
+}
+
+// 📝 任务榜组件（动态导入）
+let tasksViewModule = null;
+async function getTasksView() {
+    if (!tasksViewModule) {
+        tasksViewModule = await import("../task/任务榜组件.js");
+    }
+    return tasksViewModule;
+}
+
+// 🧩 提示词组件（动态导入）
+let promptsViewModule = null;
+async function getPromptsView() {
+    if (!promptsViewModule) {
+        promptsViewModule = await import("../prompt/提示词组件.js");
+    }
+    return promptsViewModule;
+}
+
+
+// ==========================================
+// 🔧 配置常量
+// ==========================================
+const PAGE_SIZE = 20;                           // 每页数量
+const CREATORS_PAGE_SIZE = 12;                  // 创作者每页数量（卡片更大）
+
+/**
+ * ⏱️ 获取缓存过期时间（毫秒）
+ * 从用户设置中读取，默认2小时（7200秒）
+ * @returns {number} 缓存过期时间（毫秒）
+ */
+function getCacheExpireTime() {
+    try {
+        const settingsStr = localStorage.getItem('ComfyCommunity_Settings');
+        if (settingsStr) {
+            const settings = JSON.parse(settingsStr);
+            const seconds = parseInt(settings.cacheExpireSeconds);
+            if (seconds && seconds >= 60 && seconds <= 86400) {
+                return seconds * 1000;  // 转为毫秒
+            }
+        }
+    } catch (e) {}
+    return 1000 * 60 * 60 * 2;  // 默认2小时
+}
+
+// ==========================================
+// 🔄 同榜单数据与创作者会话缓存
+// ==========================================
+/**
+ * 从同 tab 的任意排序状态中获取已有数据
+ */
+function findExistingTabData(tab, freshOnly = true) {
+    let source;
+    const data = paginationStore.findCompleteData(tab, (_state, sort) => {
+        const key = getSidebarListCacheKey(tab, sort);
+        const metadata = readSidebarListCache(key, { creators: tab === 'creators' });
+        if (!metadata.found || (freshOnly && metadata.expired)) return null;
+        const candidate = captureCacheSource(key);
+        if (!candidate?.isAvailable() || (freshOnly && !candidate.isFresh())) return null;
+        source = candidate;
+        return metadata.value === _state.allData ? _state.allData : proxyImages(metadata.value);
+    });
+    return data ? { data, source } : null;
+}
+
+function saveSidebarResponse(cacheKey, data, rawData) {
+    const cachedResponse = getSidebarResponseCacheSource(rawData);
+    if (cachedResponse) return cachedResponse.source?.copyTo(cacheKey, data) || false;
+    setCache(cacheKey, data, getCacheExpireTime(), true);
+    return true;
+}
+
+// ==========================================
+// 📦 分页状态管理
+// ==========================================
+// 每个标签页独立的分页状态
+const paginationStore = createSidebarPaginationStore();
+const contentReadOwners = new WeakMap();
+const ownedRenderGetters = new WeakMap();
+const expiredRenderToken = Symbol();
+const getPaginationState = (tab, sort) => paginationStore.get(tab, sort);
+
+export function disposeSidebarContent(contentArea) {
+    stopViewportAnimations(contentArea);
+    try { paginationStore.stopLoaders(); }
+    catch { console.warn('Sidebar pagination cleanup failed'); }
+    for (const child of Array.from(contentArea.children)) {
+        const cleanup = child._cleanup;
+        child._cleanup = null;
+        try { cleanup?.call(child); }
+        catch { console.warn('Sidebar list view cleanup failed'); }
+    }
+}
+
+
+// ==========================================
+// 🚀 主加载函数
+// ==========================================
+export async function loadSidebarContent({
+    tab,
+    sort,
+    keyword,
+    contentArea,
+    currentUser,
+    renderToken,
+    getRenderToken,
+    force = false,
+    expandItemId = null,  // 新增：要自动展开的卡片ID
+    isNavigationCurrent = () => true
+}) {
+    if (renderToken !== getRenderToken()) return;
+    const previousGetter = ownedRenderGetters.get(getRenderToken);
+    const getHostRenderToken = previousGetter?.area === contentArea ? previousGetter.getHost : getRenderToken;
+    const readOwner = {};
+    contentReadOwners.set(contentArea, readOwner);
+    getRenderToken = () => contentReadOwners.get(contentArea) === readOwner ? getHostRenderToken() : expiredRenderToken;
+    ownedRenderGetters.set(getRenderToken, { area: contentArea, getHost: getHostRenderToken });
+    const canNavigate = () => renderToken === getRenderToken() && isNavigationCurrent();
+    // 新榜单取得视图所有权时停止所有旧分页器，保留各榜单已加载数据。
+    paginationStore.stopLoaders();
+
+    const domainViews = {
+        posts: { loadModule: getPostsView, factory: 'createPostsView', errorKey: 'feedback.load_posts_failed',
+            afterMount: module => { if (module.loadPosts) module.loadPosts(); } },
+        tasks: { loadModule: getTasksView, factory: 'createTasksView', errorKey: 'feedback.load_tasks_failed' },
+        prompts: { loadModule: getPromptsView, factory: 'createPromptsView', errorKey: 'feedback.load_prompts_failed' },
+    };
+    if (Object.hasOwn(domainViews, tab)) {
+        await mountSidebarDomainView({ contentArea, currentUser, keyword, renderToken, getRenderToken,
+            ...domainViews[tab] });
+        return;
+    }
+
+    const cacheKey = getSidebarListCacheKey(tab, sort);
+    const state = getPaginationState(tab, sort);
+    const pageSize = tab === "creators" ? CREATORS_PAGE_SIZE : PAGE_SIZE;
+    const sameCreatorSearchData = tab === "creators" && keyword && state.isSearchResult &&
+        state.searchKeyword === keyword && Array.isArray(state.allData) && state.allData.length > 0
+        ? state.allData
+        : null;
+
+    // ========== 🔄 强制刷新：清除当前 tab/sort 的内存缓存 ==========
+    if (force) {
+        state.allData = [];
+        state.displayedCount = 0;
+        state.isFullyLoaded = false;
+        if (!sameCreatorSearchData) {
+            state.isSearchResult = false;
+            state.searchKeyword = "";
+        }
+    }
+
+    // 停止之前的分页加载器
+    if (state.loader) {
+        state.loader.stop();
+        state.loader = null;  // 清除引用，防止旧分页器状态残留
+    }
+
+    // ========== 🔍 搜索过滤统一入口 ==========
+    // 🔧 修复：过滤职责原先分裂在三处且口径不一致 —— loadMoreData 与分页器的
+    // getTotalDataCount 都是「先过滤再切片」（正确），而各首屏分支是「先切 20 条再过滤」，
+    // renderBatch 内部又对切好的批次再过滤一次。后果不只是首屏条数偏少：首屏与分页
+    // 处于不同的数据空间（首屏在「原始前 20 条」里找匹配，分页在「过滤后全集」里按 20
+    // 步长切片），排在第 20 条之后的匹配项会永久丢失，甚至首屏直接显示「没有搜索到相关内容」。
+    // 现统一收口到本函数：所有取数路径都先过滤、再切片，renderBatch 只负责渲染。
+    // 创作者Tab的 keyword 由后端搜索接口过滤，此处不做本地过滤（与原口径一致）。
+    const _applySearchScope = (dataArray) => {
+        const scoped = !keyword || tab === "creators" ? dataArray : filterItemsByKeyword(dataArray, keyword);
+        if (!expandItemId || tab === "creators") return scoped;
+        const target = dataArray.find(item => String(item.id) === String(expandItemId));
+        if (!target) return scoped;
+        return [target, ...scoped.filter(item => String(item.id) !== String(expandItemId))];
+    };
+
+    // ========== 渲染函数：渲染一批数据（只渲染，过滤由 _applySearchScope 统一负责）==========
+    let targetLookupStarted = false;
+    const renderBatch = (dataArray, append = false) => {
+        if (renderToken !== getRenderToken()) return;
+
+        // 🔧 数据已由调用方经 _applySearchScope 过滤，本函数只负责渲染（不再二次过滤）
+        const displayData = dataArray;
+
+        // 首次渲染清空容器
+        if (!append) {
+            disposeSidebarContent(contentArea);
+            contentArea.innerHTML = "";
+            state.displayedCount = 0;
+        }
+
+        // 空数据处理
+        if (displayData.length === 0 && state.displayedCount === 0) {
+            const emptyState = document.createElement('div');
+            emptyState.className = 'sidebar-status-message';
+            emptyState.textContent = t(keyword ? 'feedback.no_search_results' : 'feedback.no_list_data');
+            emptyState.setAttribute('role', 'status');
+            contentArea.replaceChildren(emptyState);
+            if (!expandItemId) return 0;
+        }
+
+        // 渲染卡片
+        const fragment = document.createDocumentFragment();
+        const animationType = getAnimationTypeForTab(tab);
+        const cards = [];
+        let targetCard = null;  // 用于保存需要展开的目标卡片
+
+        if (tab === "tools" || tab === "skills" || tab === "apps" || tab === "recommends") {
+            displayData.forEach(data => {
+                const card = createItemCard(data, currentUser);
+                cards.push(card);
+                fragment.appendChild(card);
+                // 检查是否是需要展开的卡片
+                if (expandItemId && String(data.id) === String(expandItemId)) {
+                    targetCard = card;
+                }
+            });
+        } else if (tab === "creators") {
+            displayData.forEach(data => {
+                const card = createCreatorCard(data, currentUser);
+                cards.push(card);
+                fragment.appendChild(card);
+            });
+        }
+
+        contentArea.appendChild(fragment);
+
+        // ✨ 应用视口感知动画：可见卡片依次错开载入，滚动/分页进入视口的卡片自动补播动画
+        applyViewportAnimations(contentArea, cards, animationType, !append);
+
+        // 对新渲染的图片启用懒加载
+        lazyLoadImages(contentArea, "img:not(.lazy-loaded):not(.lazy-loading)");
+
+        // 🔔 自动展开目标卡片（如果有）
+        if (targetCard && !append) {
+            requestAnimationFrame(() => {
+                if (!canNavigate()) return;
+                // 滚���到卡片位置
+                scrollCardIntoView(targetCard);
+                // 模拟点击摘要区域展开卡片
+                const summary = targetCard.querySelector('.item-summary') || targetCard.firstElementChild;
+                if (summary) summary.click();
+            });
+        }
+
+        // 目标不在列表快照中时补取，仍使用原榜单卡片展开。
+        if (expandItemId && !targetCard && !append && !targetLookupStarted && canNavigate()) {
+            targetLookupStarted = true;
+            (async () => {
+                try {
+                    const res = await api.getItemById(expandItemId);
+                    if (!canNavigate()) return;
+                    if (res?.status !== "success" || !res.data || String(res.data.id) !== String(expandItemId)) {
+                        showToast(t('notif.item_not_found'), "error");
+                        return;
+                    }
+                    const target = state.allData.find(item => String(item.id) === String(expandItemId)) || proxyImages([res.data])[0];
+                    state.loader?.stop();
+                    state.loader = null;
+                    state.allData = [target, ...state.allData.filter(item => String(item.id) !== String(expandItemId))];
+                    const scoped = _applySearchScope(state.allData);
+                    renderBatch(scoped.slice(0, pageSize), false);
+                    if (scoped.length > pageSize) {
+                        _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
+                    }
+                } catch (_) {
+                    if (canNavigate()) showToast(t('notif.load_item_failed'), "error");
+                }
+            })();
+        }
+
+        state.displayedCount += displayData.length;
+        return displayData.length;
+    };
+
+    // ========== 分页加载更多函数 ==========
+    const loadMoreData = async (page, size, { isCurrent = () => true } = {}) => {
+        if (!isCurrent()) return [];
+        // 计算要显示的数据范围
+        const start = (page - 1) * size;
+        const end = start + size;
+
+        // 从全量数据中截取（统一走 _applySearchScope，与首屏处于同一数据空间）
+        const dataSlice = _applySearchScope(state.allData);
+
+        const batch = dataSlice.slice(start, end);
+
+        if (batch.length > 0) {
+            renderBatch(batch, true);
+        }
+
+        return batch;
+    };
+
+    // ========== 尝试从缓存加载 ==========
+    // 📌 本处的缓存口径与 任务榜/讨论区/提示词（统一走 性能优化工具.js 的
+    // readListCache，命中后一律调 silentRefresh 后台补新）**刻意不同**，不是历史遗留，勿顺手归一：
+    //   - 这里缓存的是全量数据（items 200 条 / creators 500 条），分页完全在本地做，
+    //     所以缓存命中即等于「数据完整」，只在 expired 时才值得再发一次网络请求；
+    //   - 那三个列表只缓存第一页，命中后数据必然不完整，故一律后台 silentRefresh 补新。
+    // 若强行统一成「总是后台刷新」，插件榜会在每次 Tab 切换时多发一次 200 条的全量请求。
+    // 获取完整缓存信息（包含过期状态）
+    const { value: cachedData, expired: isCacheExpired, found: hasCacheData } =
+        readSidebarListCache(cacheKey, { creators: tab === 'creators' });
+
+    // 有缓存时直接渲染缓存（搜索时也使用缓存，renderBatch 会处理 keyword 过滤）
+    // 🔍 创作者Tab有keyword时不使用缓存，每次都从后端搜索
+    // 🔧 修复：原实现还把「刚清空搜索框」也列为跳过缓存的理由，但 cacheKey 不含 keyword、
+    // 搜索结果也从不写入该键（见下方 isCreatorSearch 判断），缓存里存的始终是干净的全量列表，
+    // 清空搜索框后完全可以直接用缓存上屏；强制联网只会让用户在弱网下白等一整个重试预算
+    const skipCache = tab === "creators" && !!keyword;
+    if (!force && hasCacheData && !skipCache) {
+        // 🚀 缓存数据也需要过一遍图片代理，确保新字段也被处理
+        const proxiedData = proxyImages(cachedData);
+        state.allData = proxiedData;
+        state.isFullyLoaded = true;
+        // 缓存是全量列表而非搜索结果，清除搜索标记，避免下次加载仍被当作搜索结果处理
+        if (tab === "creators" && !keyword) {
+            state.isSearchResult = false;
+            state.searchKeyword = "";
+        }
+
+        // 首屏渲染（仅第一页）—— 先过滤再切片，与 loadMoreData 同一数据空间
+        const scopedData = _applySearchScope(proxiedData);
+        renderBatch(scopedData.slice(0, pageSize), false);
+
+        // 如果有更多数据，启动分页加载器
+        if (scopedData.length > pageSize) {
+            _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
+        }
+
+        // 【新增】Tab 切换后台静默刷新 —— 仅缓存过期时触发
+        if (isCacheExpired) {
+            console.log(`🔄 缓存已过期，${tab}_${sort} 启动后台静默刷新...`);
+
+            setTimeout(async () => {
+                // 保存当前上下文快照，防止网络延迟期间用户切换Tab导致竞态
+                const savedToken = renderToken;
+                const savedTab = tab;
+                const savedSort = sort;
+
+                // 防竞态检查1：回调开始执行时验证
+                if (savedToken !== getRenderToken()) return;
+
+                const isReadCurrent = captureCacheWrite(cacheKey);
+                try {
+                    const rawData = await fetchSidebarList({ tab: savedTab, sort: savedSort, background: true });
+                    if (savedToken !== getRenderToken() || !isReadCurrent()) return;
+                    const newData = proxyImages(rawData);
+
+                    // 防竞态检查2：网络请求完成后再次验证
+                    if (savedToken !== getRenderToken()) return;
+
+                    // 🛡️ 空响应防护：云端返回空列表时不回写缓存、也不清屏重渲染。
+                    // 本分支由「缓存过期」触发，是切 Tab 时最常走到的路径，若不拦，
+                    // 下方 state.allData = newData + contentArea.innerHTML = "" 会把
+                    // 已上屏的本地数据连画面带缓存一起清空（见 _isEmptyOverwrite 说明）
+                    if (_isEmptyOverwrite(newData, state.allData, cachedData)) {
+                        console.warn(`🛡️ ${savedTab}_${savedSort} 云端返回空列表，保留本地数据，跳过缓存回写`);
+                        return;
+                    }
+
+                    // 只有token匹配时才同时更新state.allData和setCache
+                    if (_shouldUpdateData(state.allData, newData)) {
+                        console.log(`✅ ${savedTab}_${savedSort} 检测到新数据，执行静默更新`);
+                        state.allData = newData;
+                        state.displayedCount = 0; // 重置分页计数
+                        // 📴 持久化到 localStorage，保证重启后离线仍可展示
+                        saveSidebarResponse(cacheKey, newData, rawData);
+
+                        // 更新创作者 sessionStorage 缓存
+                        if (savedTab === "creators") {
+                            saveCreatorsToSessionStorage(newData);
+                        }
+
+                        // 完整重新渲染（替代之前只更新数字的方案）
+                        // 🔧 先过滤再切片：搜索场景下静默刷新同样会触发，
+                        // 原实现在 newData 前 20 条里过滤，会漏掉靠后的匹配项
+                        const scopedNewData = _applySearchScope(newData);
+                        renderBatch(scopedNewData.slice(0, pageSize), false);
+
+                        if (scopedNewData.length > pageSize) {
+                            _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, savedTab, savedToken, getRenderToken);
+                        }
+                    } else {
+                        // 关键字段无变化 → 无需重渲染。但 newData 才是刚从云端取回的权威数据，
+                        // 缓存必须回写 newData：若仍回写旧的 state.allData，等于把旧数据固化并
+                        // 续期（续期后 isCacheExpired 转 false，下次连静默刷新都不再触发），
+                        // 导致缓存中的旧版本号被长期锁死、卡片徽章无法出现。
+                        // 注意此处刻意不更新 state.allData：首屏已按旧数据渲染，保持二者一致可
+                        // 避免分页加载与已渲染卡片错位；新数据在下次进入读取缓存时生效
+                        saveSidebarResponse(cacheKey, newData, rawData);
+                    }
+                } catch (err) {
+                    if (savedToken !== getRenderToken()) return;
+                    console.warn(`⚠️ ${savedTab}_${savedSort} 后台刷新失败`);
+                }
+            }, 0);
+        }
+
+        return;
+    }
+
+    // ========== 🔄 本地排序优先：同 tab 已有数据时直接排序渲染（强制刷新时跳过）==========
+    // 🔍 创作者Tab有keyword时不走本地排序优先，必须调用后端搜索API
+    // 🔍 创作者Tab清空搜索框后也不走本地排序优先，避免使用搜索时的部分结果
+    // 🔍 如果当前state是搜索结果，也不走本地排序优先
+    // 仅在"正在搜索"或"刚清空搜索但state仍是搜索结果"时跳过本地排序
+    const isCreatorSearching = tab === "creators" && keyword;
+    const isCreatorSearchCleared = tab === "creators" && !keyword && state.isSearchResult;
+    const skipLocalSort = isCreatorSearching || isCreatorSearchCleared || state.isSearchResult;
+    const existingData = findExistingTabData(tab);
+    if (!force && !skipLocalSort && existingData && existingData.data.length > 0 && existingData.source.isFresh()) {
+        const locallySorted = sortDataLocally(existingData.data, tab, sort);
+        if (existingData.source.copyTo(cacheKey, locallySorted)) {
+            state.allData = locallySorted;
+            state.isFullyLoaded = true;
+            state.displayedCount = 0;  // 重置已显示计数，因为数据重新排序了
+
+            // 首屏渲染（先过滤再切片）
+            const scopedSorted = _applySearchScope(locallySorted);
+            renderBatch(scopedSorted.slice(0, pageSize), false);
+
+            // 启动分页加载器
+            if (scopedSorted.length > pageSize) {
+                _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
+            }
+
+            // 存入当前排序的缓存（📴 创作者数据同样持久化到 localStorage，保证重启后离线可展示）
+            return; // 本地排序后直接返回，不需要后台刷新（数据是同一批）
+        }
+    }
+
+    // ========== 🚀 缓存先行：阻塞前先用本地已有数据上屏 ==========
+    // 走到这里说明上面两条快路径都没命中：要么是 force 强制刷新（刻意跳过缓存），
+    // 要么是本次会话还没有该 tab 的完整数据。弱网下一次列表请求最长要烧满整个重试预算，
+    // 期间用户只能盯骨架屏；此刻若本地已有可用数据，就先渲染首屏，网络请求照常往下走，
+    // 回来后按 renderToken + _shouldUpdateData 决定是否重渲染（与上方静默刷新同口径）。
+    // 🔍 新关键词的创作者搜索不参与缓存先行，避免显示其它查询结果；只有强制刷新当前同一关键词时，
+    // 才临时复用精确匹配的上一批搜索结果（state.searchKeyword），失败时继续保留它。
+    let renderedInstant = false;
+    if (!isCreatorSearching || sameCreatorSearchData) {
+        // 可立即上屏的数据：当前排序的列表缓存（force 时被跳过）→ 创作者 sessionStorage 降级副本
+        let instantData = sameCreatorSearchData ||
+            ((hasCacheData && Array.isArray(cachedData) && cachedData.length > 0) ? cachedData : null);
+        if (!instantData && tab === "creators") {
+            const sessionData = getCreatorsFromSessionStorage();
+            if (Array.isArray(sessionData) && sessionData.length > 0) instantData = sessionData;
+        }
+        if (!instantData && !isCreatorSearching) instantData = findExistingTabData(tab, false)?.data || null;
+        if (instantData) {
+            console.log(`🚀 ${tab}_${sort} 缓存先行：先用本地数据渲染首屏，网络请求转后台`);
+            // 🚀 与上方缓存命中分支同口径：本地数据也过一遍图片代理（proxyImages 内部会先剥除
+            // 已有代理前缀，幂等），确保代理规则新增的字段同样被处理
+            // sessionStorage 副本的顺序不保证与当前排序一致，统一本地排一次（对已排序数据幂等）
+            const sortedData = sortDataLocally(proxyImages(instantData), tab, sort);
+            state.allData = sortedData;
+            state.isFullyLoaded = true;
+            state.isSearchResult = !!sameCreatorSearchData;
+            state.searchKeyword = sameCreatorSearchData ? keyword : "";
+            // 🔧 先过滤再切片（tools/skills/apps/recommends 带 keyword 时同样会进入本分支）
+            const scopedInstant = _applySearchScope(sortedData);
+            renderBatch(scopedInstant.slice(0, pageSize), false);
+            if (scopedInstant.length > pageSize) {
+                _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
+            }
+            renderedInstant = true;
+        }
+    }
+
+    // ========== 显示加载骨架屏（已有本地数据上屏时跳过，避免闪屏）==========
+    if (!renderedInstant) {
+        disposeSidebarContent(contentArea);
+        contentArea.innerHTML = "";
+        const skeleton = createSkeleton(tab === "creators" ? "list" : "card", 3);
+        contentArea.appendChild(skeleton);
+    }
+
+    // ========== 从网络加载数据 ==========
+    try {
+        const isReadCurrent = captureCacheWrite(cacheKey);
+        const rawData = await fetchSidebarList({ tab, sort, keyword, force });
+        if (renderToken !== getRenderToken()) return;
+        if (!isReadCurrent()) {
+            const error = new Error();
+            error.name = "ListCacheChangedError";
+            throw error;
+        }
+        const realData = proxyImages(rawData);
+        if (renderToken !== getRenderToken()) return;
+        if (tab === 'creators') {
+            state.isSearchResult = !!keyword;
+            state.searchKeyword = keyword || '';
+        }
+
+        // 存入缓存（📴 创作者数据同样持久化到 localStorage，保证重启后离线仍可展示；搜索结果不存入缓存）
+        const isCreatorSearch = tab === "creators" && keyword;
+        // 🛡️ 空响应防护：创作者搜索命中 0 条是有效答案（下方要渲染「没有搜索到相关内容」），
+        // 必须排除在防护之外，否则会把空搜索结果误判成云端故障、改渲染全量列表
+        const isEmptyOverwrite = !isCreatorSearch && _isEmptyOverwrite(realData, cachedData, state.allData);
+        if (isEmptyOverwrite) {
+            console.warn(`🛡️ ${tab}_${sort} 云端返回空列表，保留本地数据，不覆盖缓存`);
+        } else if (!isCreatorSearch) {
+            saveSidebarResponse(cacheKey, realData, rawData);
+        }
+
+        // 创作者非搜索数据存入 sessionStorage（用于离线降级）
+        if (tab === "creators" && !isCreatorSearch && !isEmptyOverwrite) {
+            saveCreatorsToSessionStorage(realData);
+        }
+
+        state.isFullyLoaded = true;
+
+        // 🛡️ 空响应且本地数据已上屏：保持当前画面，不用空列表清屏（与缓存同口径不回写）
+        if (isEmptyOverwrite && renderedInstant) {
+            return;
+        }
+
+        // 🚀 缓存先行场景：网络数据与已上屏的本地数据无实质差异时不重渲染，避免清屏重画
+        // 打断用户已经滚动的阅读位置（与上方后台静默刷新同口径）。缓存已在上面回写权威新数据，
+        // 此处刻意不更新 state.allData，保持与已渲染卡片一致，防止分页加载错位
+        if (renderedInstant && !_shouldUpdateData(state.allData, realData)) {
+            return;
+        }
+
+        // 更新状态
+        state.allData = realData;
+
+        // 渲染首屏（先过滤再切片：tools/skills/apps/recommends 的 keyword 是本地搜索，
+        // realData 是未过滤的全量数据，原实现在前 20 条里过滤会漏掉靠后的匹配项）
+        const scopedReal = _applySearchScope(realData);
+        renderBatch(scopedReal.slice(0, pageSize), false);
+
+        // 启动分页加载器
+        if (scopedReal.length > pageSize) {
+            _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
+        }
+
+    } catch (error) {
+        // 🔍 防竞态：本次加载已被更新的加载取代（切Tab、换排序、继续输入关键词）时直接退出。
+        // renderBatch 内部本来就有这道守卫，但它之外的降级分支会直接写 contentArea.innerHTML
+        // 并弹提示，缺少守卫会让过期结果覆盖掉新内容
+        if (renderToken !== getRenderToken()) {
+            console.warn(`⏹️ ${tab}_${sort} 请求已过期，忽略本次失败`);
+            return;
+        }
+        if (error?.name === "ListCacheChangedError") {
+            if (renderedInstant) {
+                if (force) showToast(t('feedback.list_changed_retry'), 'warning');
+                return;
+            }
+            renderListLoadError(contentArea, t('feedback.list_changed_retry'), () => loadSidebarContent({
+                tab, sort, keyword, contentArea, currentUser, renderToken, getRenderToken,
+                force: true, expandItemId, isNavigationCurrent
+            }), t);
+            return;
+        }
+        // 🔍 主动撤销（上方 cancelAll）不是网络故障：用户只是又敲了一个字，
+        // 新一次加载已经在跑了。这里必须静默退出，否则会误弹「网络不可用」提示
+        if (error && error.name === 'RequestCancelledError') {
+            console.log(`⏹️ ${tab}_${sort} 搜索请求已被新关键词取代`);
+            return;
+        }
+        console.error("数据加载失败");
+
+        // 🚀 缓存先行场景：首屏已经用本地数据上屏，网络失败时保持当前画面即可，不再走下面的
+        // 降级分支（否则会把同一批数据重渲染一遍、重播卡片动画）。与上方后台静默刷新失败一致：
+        // 只记录日志，不额外打扰用户
+        if (renderedInstant) {
+            console.warn(`📴 ${tab}_${sort} 网络刷新失败，保持已渲染的本地数据`);
+            if (force) showToast(t('feedback.refresh_failed_cached'), 'warning');
+            return;
+        }
+
+        // 🚀 回退到任何可用缓存（包括过期的）
+        // 🔍 创作者Tab搜索场景跳过此分支：renderBatch 对创作者不做本地过滤，
+        // 直接渲染全量缓存会导致搜索结果未过滤，改由下方本地搜索降级分支处理
+        if (hasCacheData && cachedData && !(tab === "creators" && keyword)) {
+            console.warn(`📴 网络失败，降级显示${isCacheExpired ? '过期' : ''}缓存`);
+            state.allData = cachedData;
+            // 🔧 先过滤再切片：本分支已排除 creators+keyword，但 tools/skills/apps/recommends
+            // 带 keyword 时会进来；renderBatch 不再自行过滤，此处必须显式过滤
+            const scopedCached = _applySearchScope(cachedData);
+            renderBatch(scopedCached.slice(0, pageSize), false);
+
+            // 如果是过期缓存，显示提示
+            // 🔧 改用统一提示组件 + 词典（原为手写 div、无动画不排队，且文案硬编码中文）
+            if (isCacheExpired) {
+                showToast(t('feedback.cache_fallback'), 'warning');
+            }
+            return;
+        }
+
+        // 🚀 创作者Tab：尝试从 sessionStorage 或内存中降级
+        if (tab === "creators") {
+            let fallbackData = null;
+
+            // 1. 优先从当前内存状态获取
+            if (keyword && state.isSearchResult && state.searchKeyword === keyword &&
+                state.allData && state.allData.length > 0) {
+                fallbackData = state.allData;
+            }
+            // 2. 从本地列表缓存获取（含过期缓存，搜索结果不入库故不会污染）
+            if (!fallbackData && hasCacheData && cachedData) {
+                fallbackData = cachedData;
+            }
+            // 3. 尝试从 sessionStorage 获取
+            if (!fallbackData) {
+                fallbackData = getCreatorsFromSessionStorage();
+            }
+            // 4. 从其他排序状态获取
+            if (!fallbackData) {
+                fallbackData = findExistingTabData("creators", false)?.data || null;
+            }
+
+            if (fallbackData && fallbackData.length > 0) {
+                let displayData = fallbackData;
+
+                // 搜索场景：执行本地搜索
+                if (keyword) {
+                    displayData = searchCreatorsLocally(keyword, fallbackData);
+                    if (displayData.length === 0) {
+                        const emptyState = document.createElement('div');
+                        emptyState.className = 'sidebar-status-message';
+                        emptyState.textContent = t('feedback.no_search_results');
+                        emptyState.setAttribute('role', 'status');
+                        contentArea.replaceChildren(emptyState);
+
+                        // 🔧 改用统一提示组件 + 词典（原为手写 div 且文案硬编码中文）
+                        showToast(t('feedback.search_local_result'), 'warning');
+                        return;
+                    }
+                }
+
+                // 按当前排序排序
+                displayData = sortDataLocally(displayData, tab, sort);
+                state.allData = displayData;
+                state.isSearchResult = !!keyword;
+                state.searchKeyword = keyword || '';
+                // 统一走 _applySearchScope（创作者Tab恒等返回，数据已由上方
+                // searchCreatorsLocally 过滤），保证各渲染入口口径完全一致
+                const scopedFallback = _applySearchScope(displayData);
+                renderBatch(scopedFallback.slice(0, pageSize), false);
+
+                // 启动分页加载器
+                if (scopedFallback.length > pageSize) {
+                    _setupPaginationLoader(contentArea, state, pageSize, loadMoreData, keyword, tab, renderToken, getRenderToken);
+                }
+
+                // 🔧 改用统一提示组件 + 词典（原为手写 div 且两条文案均硬编码中文）
+                showToast(keyword ? t('feedback.search_local_result') : t('feedback.cache_fallback'), 'warning');
+                return;
+            } else if (keyword) {
+                renderListLoadError(contentArea, t('common.network_error_retry'), () => loadSidebarContent({
+                    tab, sort, keyword, contentArea, currentUser, renderToken, getRenderToken,
+                    force: true, expandItemId, isNavigationCurrent
+                }), t, error);
+                return;
+            }
+        }
+
+        // 无本地数据时提供原位重试，保留当前 ComfyUI 页面与榜单上下文。
+        renderListLoadError(contentArea, t('common.network_error_retry'), () => loadSidebarContent({
+            tab, sort, keyword, contentArea, currentUser, renderToken, getRenderToken,
+            force: true, expandItemId, isNavigationCurrent
+        }), t, error);
+    }
+}
+
+
+/**
+ * 🛡️ 空响应防护：本次云端返回是否属于「请求成功但列表为空」，且本地已有非空数据
+ *
+ * 背景：网络失败本身从不清理本地数据（重试耗尽只置云端冷却并回退过期缓存，见技术文档
+ * 04 章 4.2.2），但云端偶发返回 HTTP 200 + data:[] 会——例如 Space 冷启动时 HF Dataset
+ * 尚未加载完。此时 realData/newData 为 []，照原样回写缓存就把断网降级的唯一数据来源清掉了。
+ *
+ * 只拦「新数据为空 且 本地已有非空数据」这一种组合：本地本来就是空的（首次使用、刚清过
+ * 缓存、云端确实一条都没有）时返回 false，照��写入，不改变任何正常流程。
+ * 调用方须自行排除搜索结果场景——搜索命中 0 条是有效答案，不是云端故障。
+ *
+ * @param {Array} newData - 本次从云端取回的数据
+ * @param {...(Array|null|undefined)} localData - 本地已有数据（缓存副本 / 内存 state.allData）
+ * @returns {boolean} true = 属于会覆盖本地好数据的空响应，应跳过回写与重渲染
+ */
+function _isEmptyOverwrite(newData, ...localData) {
+    if (Array.isArray(newData) && newData.length > 0) return false;
+    return localData.some(d => Array.isArray(d) && d.length > 0);
+}
+
+/** 判断是否需要更新数据 —— 对比ID顺序和关键字段 */
+function _shouldUpdateData(oldData, newData) {
+    if (!oldData || !newData) return true;
+    if (oldData.length !== newData.length) return true;
+
+    // 检查ID顺序是否一致（检测排序变化、新增/删除）
+    // 比对条数覆盖首屏渲染量（PAGE_SIZE），避免首屏可见卡片（第 11~20 条）的版本/数字更新被漏检
+    const checkCount = Math.min(PAGE_SIZE, oldData.length);
+    for (let i = 0; i < checkCount; i++) {
+        const oldId = oldData[i].id || oldData[i].account;
+        const newId = newData[i].id || newData[i].account;
+        if (oldId !== newId) return true;
+
+        // 检查关键数字字段
+        const keyFields = ['likes', 'downloads', 'uses', 'views', 'daily_views', 'recent_tips', 'favorites', 'rating_avg', 'rating_count'];
+        for (const field of keyFields) {
+            if ((oldData[i][field] || 0) !== (newData[i][field] || 0)) return true;
+        }
+
+        // 检查版本号（字符串）：云端扫描到插件新版本时往往只有 latest_version 变化，
+        // 点赞/下载/浏览等数字字段全不动；若不比对它，卡片上的"可更新"徽章将永远刷不出来
+        if ((oldData[i].latest_version || '') !== (newData[i].latest_version || '')) return true;
+    }
+    return false;
+}
+
+

前端页面/core/全局配置.js

@@ -121,6 +121,12 @@ export const LOCAL_PERFORMANCE = Object.freeze({
     LABELS: Object.freeze({ tools: 'nav.tools', skills: 'nav.skills', apps: 'nav.apps', recommends: 'nav.recommends', creators: 'nav.creators', tasks: 'nav.tasks', posts: 'nav.posts', prompts: 'nav.prompts' })
 });
 
+export const LOCAL_INSTALL_DIRECTORY = Object.freeze({
+    PATH: '/community_hub/open_install_directory',
+    TIMEOUT: 25000,
+    RESPONSE_MAX_BYTES: 8192
+});
+
 export const SKILL_INSTALL = Object.freeze({
     PATH: '/community_hub/skill_install',
     PREFLIGHT_TIMEOUT: 30000,
@@ -191,6 +197,11 @@ export function isAdmin(account) {
 // ==========================================
 // 💾 缓存配置
 // ==========================================
+export function getSidebarListCacheKey(tab, sort) {
+    const list = tab === 'creators' ? 'creators_full' : tab;
+    return `ListCache_${list}_${sort}`;
+}
+
 const RESOURCE_LIST_PREFIXES = [
     "ListCache_tools_", "ListCache_skills_", "ListCache_apps_", "ListCache_recommends_"
 ];

前端页面/core/榜单分页状态.js

@@ -16,10 +16,11 @@ export function createSidebarPaginationStore() {
             }
             return states.get(key);
         },
-        findCompleteData(tab) {
+        findCompleteData(tab, readData = state => state.allData) {
             for (const [key, state] of states) {
-                if (key.startsWith(`${tab}_`) && state.allData.length > 0 && state.isFullyLoaded) {
-                    return state.allData;
+                if (key.startsWith(`${tab}_`) && state.allData.length > 0 && state.isFullyLoaded && !state.isSearchResult) {
+                    const data = readData(state, key.slice(tab.length + 1));
+                    if (Array.isArray(data) && data.length > 0) return data;
                 }
             }
             return null;

前端页面/core/榜单数据来源.js

@@ -2,6 +2,12 @@ import { api, requestCancelManager } from './网络请求API.js';
 import { API, CACHE, PAGINATION } from './全局配置.js';
 import { requireListResponseData, getCacheWithMeta, removeCache } from '../components/性能优化工具.js';
 
+import { captureCacheWrite } from './网络请求_缓存管理.js';
+import { getResponseCacheSource } from './网络请求_基础设施.js';
+
+const sidebarResponseSources = new WeakMap();
+export const getSidebarResponseCacheSource = data => sidebarResponseSources.get(data) || null;
+
 const itemTypes = Object.freeze({ tools: 'tool', skills: 'skill', apps: 'app', recommends: 'recommend' });
 
 // 只读取与校验，不提交视图状态或缓存；提交时由调用方核查界面代次。
@@ -9,6 +15,8 @@ export async function fetchSidebarList({ tab, sort, keyword = '', force = false,
     const options = background
         ? { noCache: true, timeout: API.BACKGROUND_TIMEOUT, retries: API.BACKGROUND_RETRIES }
         : (force ? { noCache: true } : {});
+    const endpoint = Object.hasOwn(itemTypes, tab) ? "/api/items" : keyword ? "/api/creators/search" : "/api/creators";
+    const isCurrent = captureCacheWrite(`api_${endpoint}`);
     let response;
     if (Object.hasOwn(itemTypes, tab)) {
         response = await api.getItems(itemTypes[tab], sort, PAGINATION.SIDEBAR_ITEM_FETCH_LIMIT, options);
@@ -22,7 +30,21 @@ export async function fetchSidebarList({ tab, sort, keyword = '', force = false,
     } else {
         throw new TypeError('Unsupported sidebar list');
     }
-    return requireListResponseData(response);
+    if (!isCurrent()) {
+        const error = new Error();
+        error.name = "ListCacheChangedError";
+        throw error;
+    }
+    const source = getResponseCacheSource(response);
+    if (source && !source.source?.isAvailable()) {
+        const error = new Error();
+        error.name = "ListCacheChangedError";
+        throw error;
+    }
+    const data = requireListResponseData(response);
+    sidebarResponseSources.delete(data);
+    if (source) sidebarResponseSources.set(data, source);
+    return data;
 }
 
 function validCreatorList(data) {

前端页面/core/网络请求_基础设施.js

@@ -1,912 +1,946 @@
-// 前端页面/core/网络请求_基础设施.js
-// ==========================================
-// 🌐 网络请求基础设施模块
-// ==========================================
-// 作用：提供底层网络请求能力，包括缓存、重试、错误处理、请求取消等
-// 关联文件：
-//   - 全局配置.js (配置中心)
-//   - 网络请求_缓存管理.js (缓存管理)
-//   - 网络请求_图片代理.js (图片代理)
-// ==========================================
-
-import { removeCache, getCacheWithMeta } from "../components/性能优化工具.js";
+// 前端页面/core/网络请求_基础设施.js
+// ==========================================
+// 🌐 网络请求基础设施模块
+// ==========================================
+// 作用：提供底层网络请求能力，包括缓存、重试、错误处理、请求取消等
+// 关联文件：
+//   - 全局配置.js (配置中心)
+//   - 网络请求_缓存管理.js (缓存管理)
+//   - 网络请求_图片代理.js (图片代理)
+// ==========================================
+
+import { removeCache, getCacheWithMeta } from "../components/性能优化工具.js";
 import { API, CACHE } from "./全局配置.js";
-import { beginLocalPerformanceSample } from "./本机性能统计.js";
-import { eventBus, EVENTS, logoutAndClearUserData, isOnline, isCloudReachable, markCloudDown, markCloudUp } from "./状态管理.js";
-import { CACHE_CONFIG, CACHE_INVALIDATION_MAP, invalidateRelatedCache, _getCacheTTL, getCache, setCache, isPrivateApiGet } from "./网络请求_缓存管理.js";
-import { unproxyImages } from "./网络请求_图片代理.js";
-// 🔧 直接引入 i18n 叶子模块（而非 用户体验增强.js）：本文件处于依赖链最上游，
-// 引入带 DOM 初始化副作用的增强层可能造成启动时序问题；国际化模块无副作用、零循环依赖
-import { t } from "../components/用户体验_国际化.js";
-
-// 🚀 动态时序导入：proxyImages 通过动态 import() 获取，避免模块初始化时序问题
-let _proxyImages = null;
-async function getProxyImages() {
-    if (!_proxyImages) {
-        const mod = await import("./网络请求_图片代理.js");
-        _proxyImages = mod.proxyImages;
-    }
-    return _proxyImages;
-}
-
-// 🏗️ P2架构优化：使用配置中心的 API 地址
-const BASE_URL = API.BASE_URL;
-
-// ⚡ P1性能优化：请求去重（相同GET请求只发一次）
-const pendingRequests = new Map();
-
-function withRequestDiagnostic(error, response, data = null) {
-    let headerId;
-    try { headerId = response.headers?.get?.(API.REQUEST_ID_HEADER); } catch {}
-    for (const value of [headerId, data?.error_id]) {
-        if (typeof value === 'string' && API.REQUEST_ID_PATTERN.test(value)) {
-            error.requestId = value;
-            break;
-        }
-    }
-    return error;
-}
-
-function httpErrorMessage(data, status) {
-    if (typeof data.detail === 'string' && Object.hasOwn(API.REQUEST_BODY_ERRORS, data.detail)) {
-        const rule = API.REQUEST_BODY_ERRORS[data.detail];
-        if (rule.status === status) return t(rule.msgKey);
-    }
-    if (Array.isArray(data.detail)) return t('feedback.invalid_request_data');
-    for (const value of [data.detail, data.message, data.error]) {
-        if (typeof value === 'string' && value.trim()) return value;
-    }
-    return t('feedback.http_request_failed', { status });
-}
-
-// 🚀 P3优化：网络状态由 状态管理.js 的 isOnline() 统一提供（见下方离线模式支持），
-// 本模块不再自行注册 online/offline 监听。
-
-// 🔧 修复：401（Token 过期/签名无效）统一处理——清除本地凭证并提示重新登录。
-// 背景：服务端更换 JWT_SECRET 或 Token 过期后，旧 Token 被云端拒签，若不清除
-// 本地凭证会导致所有登录态操作反复报「Token 签名无效」。去重窗口：并发请求
-// 同时收到 401 时只提示一次。
-let _authExpiredAt = 0;
-function _safeStorageGet(storageName, key) {
-    try {
-        const storage = window[storageName];
-        return storage ? storage.getItem(key) : null;
-    } catch (_) {
-        return null;
-    }
-}
-
-function _safeGetAuthToken() {
-    return _safeStorageGet('localStorage', 'ComfyCommunity_Token')
-        || _safeStorageGet('sessionStorage', 'ComfyCommunity_Token')
-        || '';
-}
-
-/** 与实际 Authorization 使用同一存储读取；仅返回比较函数，不暴露凭证。 */
-export function captureRequestSession() {
-    const originalToken = _safeGetAuthToken();
-    return () => originalToken === _safeGetAuthToken();
-}
-
-// 仅跟踪私有 GET；会话撤销不取消或重放已提交的业务写操作。
-const activePrivateReads = new Set();
-function revokePrivateReads(force = false) {
-    for (const entry of activePrivateReads) {
-        if (force || !entry.matches()) {
-            entry.revoked = true;
-            entry.controller?.abort();
-        }
-    }
-}
-for (const event of ['comfy-user-login', 'comfy-user-logout', 'comfy-ranking-auth-expired']) {
-    window.addEventListener(event, () => revokePrivateReads(true));
-}
-window.addEventListener('storage', event => {
-    if (event.key === null || event.key === CACHE.LEGACY_KEYS.USER) revokePrivateReads(true);
-    else if (event.key === CACHE.LEGACY_KEYS.TOKEN) revokePrivateReads();
-});
-eventBus.on(EVENTS.USER_LOGIN, () => revokePrivateReads(true));
-eventBus.on(EVENTS.USER_LOGOUT, () => revokePrivateReads(true));
-
-function _safeClearAuthStorage() {
-    for (const storageName of ['localStorage', 'sessionStorage']) {
-        try {
-            const storage = window[storageName];
-            storage?.removeItem('ComfyCommunity_Token');
-            storage?.removeItem('ComfyCommunity_User');
-        } catch (_) {
-            // 浏览器禁用 Storage 时仍继续完成内存登出和事件通知。
-        }
-    }
-}
-
-function notifyTokenExpired() {
-    const now = Date.now();
-    if (now - _authExpiredAt < 5000) return;
-    _authExpiredAt = now;
-    console.warn("⚠️ 登录凭证已失效，本地凭证已清除，请重新登录");
-    // 动态 import UI 组件，与 proxyImages 同样避免模块初始化时序问题
-    import("../components/UI交互提示组件.js").then(async ({ showToast }) => {
-        const { t } = await import("../components/用户体验_国际化.js");
-        showToast(t('auth.token_expired'), "warning", 4000);
-    }).catch(() => {});
-}
-
-function handleAuthExpired(failedToken) {
-    // 竞态防护：若用户在 401 返回前已重新登录（存储中的 Token 已更换），
-    // 不清理新凭证；失败请求未携带 Token 时 401 与登录态无关，同样不打扰
-    if (!failedToken) return false;
-    const currentToken = _safeGetAuthToken();
-    if (currentToken !== failedToken) return false;
-    // 清除前取出账号，用于清理账号级 Profile 缓存
-    let account = null;
-    try {
-        const userStr = _safeStorageGet('localStorage', "ComfyCommunity_User")
-            || _safeStorageGet('sessionStorage', "ComfyCommunity_User");
-        if (userStr) account = JSON.parse(userStr)?.user?.account || null;
-    } catch (e) {}
-    // 与手动登出同深度的完整清理：Token/User、私有数据缓存、内存缓存与安装版本戳
-    logoutAndClearUserData(account);
-    notifyTokenExpired();
-    return true;
-}
-
-// 🚀 P4优化：请求取消管理器
-const requestCancelManager = {
-    _controllers: new Map(),  // {componentId: Set<AbortController>}
-    
-    /**
-     * 创建并注册 AbortController
-     * @param {string} componentId - 组件 ID
-     * @returns {AbortController}
-     */
-    create(componentId = '_global') {
-        if (!this._controllers.has(componentId)) {
-            this._controllers.set(componentId, new Set());
-        }
-        const controller = new AbortController();
-        this._controllers.get(componentId).add(controller);
-        return controller;
-    },
-    
-    /**
-     * 移除已完成的 controller
-     */
-    remove(componentId, controller) {
-        const controllers = this._controllers.get(componentId);
-        if (controllers) {
-            controllers.delete(controller);
-        }
-    },
-    
-    /**
-     * 取消指定组件的所有请求
-     * @param {string} componentId - 组件 ID
-     */
-    cancelAll(componentId) {
-        const controllers = this._controllers.get(componentId);
-        if (controllers) {
-            const count = controllers.size;
-            for (const controller of controllers) {
-                controller.abort();
-            }
-            controllers.clear();
-            // 🔧 仅在实际撤销了请求时打日志：本方法会被搜索框的每一次输入触发，
-            // 绝大多数时候并没有在途请求，无条件打印会刷出大量无意义日志
-            if (count > 0) {
-                console.log(`🚫 已取消组件 [${componentId}] 的 ${count} 个在途请求`);
-            }
-        }
-    },
-    
-    /**
-     * 取消所有请求
-     */
-    cancelAllGlobal() {
-        for (const [componentId, controllers] of this._controllers) {
-            for (const controller of controllers) {
-                controller.abort();
-            }
-            controllers.clear();
-        }
-        console.log('🚫 已取消所有进行中的请求');
-    },
-    
-    /**
-     * 获取统计信息
-     */
-    getStats() {
-        let total = 0;
-        for (const controllers of this._controllers.values()) {
-            total += controllers.size;
-        }
-        return { components: this._controllers.size, activeRequests: total };
-    }
-};
-
-// 🚀 P3优化：请求队列管理（限制并发数）
-const requestQueue = {
-    maxConcurrent: 6,  // 浏览器同域名默认限制 6 个并发
-    running: 0,
-    pending: [],
-    
-    async add(fn, signal) {
-        signal.throwIfAborted();
-        // 如果还有槽位，直接执行
-        if (this.running < this.maxConcurrent) {
-            this.running++;
-            try {
-                return await fn();
-            } finally {
-                this.running--;
-                this._processNext();
-            }
-        }
-        
-        // 否则加入队列等待
-        return new Promise((resolve, reject) => {
-            const onAbort = () => {
-                const index = this.pending.indexOf(run);
-                if (index !== -1) this.pending.splice(index, 1);
-                reject(signal.reason);
-            };
-            const run = async () => {
-                signal.removeEventListener('abort', onAbort);
-                try {
-                    signal.throwIfAborted();
-                    resolve(await fn());
-                } catch (e) {
-                    reject(e);
-                }
-            };
-            this.pending.push(run);
-            signal.addEventListener('abort', onAbort, { once: true });
-        });
-    },
-    
-    _processNext() {
-        if (this.pending.length > 0 && this.running < this.maxConcurrent) {
-            const next = this.pending.shift();
-            this.running++;
-            next().finally(() => {
-                this.running--;
-                this._processNext();
-            });
-        }
-    },
-    
-    getStats() {
-        return { running: this.running, pending: this.pending.length };
-    }
-};
-
+import { beginLocalPerformanceSample } from "./本机性能统计.js";
+import { eventBus, EVENTS, logoutAndClearUserData, isOnline, isCloudReachable, markCloudDown, markCloudUp } from "./状态管理.js";
+import { CACHE_CONFIG, CACHE_INVALIDATION_MAP, invalidateRelatedCache, _getCacheTTL, getCache, setCache, isPrivateApiGet, captureCacheWrite, captureCacheSource } from "./网络请求_缓存管理.js";
+import { unproxyImages } from "./网络请求_图片代理.js";
+// 🔧 直接引入 i18n 叶子模块（而非 用户体验增强.js）：本文件处于依赖链最上游，
+// 引入带 DOM 初始化副作用的增强层可能造成启动时序问题；国际化模块无副作用、零循环依赖
+import { t } from "../components/用户体验_国际化.js";
+
+// 🚀 动态时序导入：proxyImages 通过动态 import() 获取，避免模块初始化时序问题
+let _proxyImages = null;
+async function getProxyImages() {
+    if (!_proxyImages) {
+        const mod = await import("./网络请求_图片代理.js");
+        _proxyImages = mod.proxyImages;
+    }
+    return _proxyImages;
+}
+
+// 🏗️ P2架构优化：使用配置中心的 API 地址
+const BASE_URL = API.BASE_URL;
+
+// ⚡ P1性能优化：请求去重（相同GET请求只发一次）
+const pendingRequests = new Map();
+const cacheReadOwners = new Map();
+const pendingRequestGuards = new WeakMap();
+const responseCacheSources = new WeakMap();
+
+function _cachedResponse(value, source) {
+    if (value && typeof value === 'object') responseCacheSources.set(value, { source });
+    return value;
+}
+
+export function getResponseCacheSource(value) {
+    return responseCacheSources.get(value) || null;
+}
+
+
+function withRequestDiagnostic(error, response, data = null) {
+    let headerId;
+    try { headerId = response.headers?.get?.(API.REQUEST_ID_HEADER); } catch {}
+    for (const value of [headerId, data?.error_id]) {
+        if (typeof value === 'string' && API.REQUEST_ID_PATTERN.test(value)) {
+            error.requestId = value;
+            break;
+        }
+    }
+    return error;
+}
+
+function httpErrorMessage(data, status) {
+    if (typeof data.detail === 'string' && Object.hasOwn(API.REQUEST_BODY_ERRORS, data.detail)) {
+        const rule = API.REQUEST_BODY_ERRORS[data.detail];
+        if (rule.status === status) return t(rule.msgKey);
+    }
+    if (Array.isArray(data.detail)) return t('feedback.invalid_request_data');
+    for (const value of [data.detail, data.message, data.error]) {
+        if (typeof value === 'string' && value.trim()) return value;
+    }
+    return t('feedback.http_request_failed', { status });
+}
+
+// 🚀 P3优化：网络状态由 状态管理.js 的 isOnline() 统一提供（见下方离线模式支持），
+// 本模块不再自行注册 online/offline 监听。
+
+// 🔧 修复：401（Token 过期/签名无效）统一处理——清除本地凭证并提示重新登录。
+// 背景：服务端更换 JWT_SECRET 或 Token 过期后，旧 Token 被云端拒签，若不清除
+// 本地凭证会导致所有登录态操作反复报「Token 签名无效」。去重窗口：并发请求
+// 同时收到 401 时只提示一次。
+let _authExpiredAt = 0;
+function _safeStorageGet(storageName, key) {
+    try {
+        const storage = window[storageName];
+        return storage ? storage.getItem(key) : null;
+    } catch (_) {
+        return null;
+    }
+}
+
+function _safeGetAuthToken() {
+    return _safeStorageGet('localStorage', 'ComfyCommunity_Token')
+        || _safeStorageGet('sessionStorage', 'ComfyCommunity_Token')
+        || '';
+}
+
+/** 与实际 Authorization 使用同一存储读取；仅返回比较函数，不暴露凭证。 */
+export function captureRequestSession() {
+    const originalToken = _safeGetAuthToken();
+    return () => originalToken === _safeGetAuthToken();
+}
+
+// 仅跟踪私有 GET；会话撤销不取消或重放已提交的业务写操作。
+const activePrivateReads = new Set();
+function revokePrivateReads(force = false) {
+    for (const entry of activePrivateReads) {
+        if (force || !entry.matches()) {
+            entry.revoked = true;
+            entry.controller?.abort();
+        }
+    }
+}
+for (const event of ['comfy-user-login', 'comfy-user-logout', 'comfy-ranking-auth-expired']) {
+    window.addEventListener(event, () => revokePrivateReads(true));
+}
+window.addEventListener('storage', event => {
+    if (event.key === null || event.key === CACHE.LEGACY_KEYS.USER) revokePrivateReads(true);
+    else if (event.key === CACHE.LEGACY_KEYS.TOKEN) revokePrivateReads();
+});
+eventBus.on(EVENTS.USER_LOGIN, () => revokePrivateReads(true));
+eventBus.on(EVENTS.USER_LOGOUT, () => revokePrivateReads(true));
+
+function _safeClearAuthStorage() {
+    for (const storageName of ['localStorage', 'sessionStorage']) {
+        try {
+            const storage = window[storageName];
+            storage?.removeItem('ComfyCommunity_Token');
+            storage?.removeItem('ComfyCommunity_User');
+        } catch (_) {
+            // 浏览器禁用 Storage 时仍继续完成内存登出和事件通知。
+        }
+    }
+}
+
+function notifyTokenExpired() {
+    const now = Date.now();
+    if (now - _authExpiredAt < 5000) return;
+    _authExpiredAt = now;
+    console.warn("⚠️ 登录凭证已失效，本地凭证已清除，请重新登录");
+    // 动态 import UI 组件，与 proxyImages 同样避免模块初始化时序问题
+    import("../components/UI交互提示组件.js").then(async ({ showToast }) => {
+        const { t } = await import("../components/用户体验_国际化.js");
+        showToast(t('auth.token_expired'), "warning", 4000);
+    }).catch(() => {});
+}
+
+function handleAuthExpired(failedToken) {
+    // 竞态防护：若用户在 401 返回前已重新登录（存储中的 Token 已更换），
+    // 不清理新凭证；失败请求未携带 Token 时 401 与登录态无关，同样不打扰
+    if (!failedToken) return false;
+    const currentToken = _safeGetAuthToken();
+    if (currentToken !== failedToken) return false;
+    // 清除前取出账号，用于清理账号级 Profile 缓存
+    let account = null;
+    try {
+        const userStr = _safeStorageGet('localStorage', "ComfyCommunity_User")
+            || _safeStorageGet('sessionStorage', "ComfyCommunity_User");
+        if (userStr) account = JSON.parse(userStr)?.user?.account || null;
+    } catch (e) {}
+    // 与手动登出同深度的完整清理：Token/User、私有数据缓存、内存缓存与安装版本戳
+    logoutAndClearUserData(account);
+    notifyTokenExpired();
+    return true;
+}
+
+// 🚀 P4优化：请求取消管理器
+const requestCancelManager = {
+    _controllers: new Map(),  // {componentId: Set<AbortController>}
+    
+    /**
+     * 创建并注册 AbortController
+     * @param {string} componentId - 组件 ID
+     * @returns {AbortController}
+     */
+    create(componentId = '_global') {
+        if (!this._controllers.has(componentId)) {
+            this._controllers.set(componentId, new Set());
+        }
+        const controller = new AbortController();
+        this._controllers.get(componentId).add(controller);
+        return controller;
+    },
+    
+    /**
+     * 移除已完成的 controller
+     */
+    remove(componentId, controller) {
+        const controllers = this._controllers.get(componentId);
+        if (controllers) {
+            controllers.delete(controller);
+        }
+    },
+    
+    /**
+     * 取消指定组件的所有请求
+     * @param {string} componentId - 组件 ID
+     */
+    cancelAll(componentId) {
+        const controllers = this._controllers.get(componentId);
+        if (controllers) {
+            const count = controllers.size;
+            for (const controller of controllers) {
+                controller.abort();
+            }
+            controllers.clear();
+            // 🔧 仅在实际撤销了请求时打日志：本方法会被搜索框的每一次输入触发，
+            // 绝大多数时候并没有在途请求，无条件打印会刷出大量无意义日志
+            if (count > 0) {
+                console.log(`🚫 已取消组件 [${componentId}] 的 ${count} 个在途请求`);
+            }
+        }
+    },
+    
+    /**
+     * 取消所有请求
+     */
+    cancelAllGlobal() {
+        for (const [componentId, controllers] of this._controllers) {
+            for (const controller of controllers) {
+                controller.abort();
+            }
+            controllers.clear();
+        }
+        console.log('🚫 已取消所有进行中的请求');
+    },
+    
+    /**
+     * 获取统计信息
+     */
+    getStats() {
+        let total = 0;
+        for (const controllers of this._controllers.values()) {
+            total += controllers.size;
+        }
+        return { components: this._controllers.size, activeRequests: total };
+    }
+};
+
+// 🚀 P3优化：请求队列管理（限制并发数）
+const requestQueue = {
+    maxConcurrent: 6,  // 浏览器同域名默认限制 6 个并发
+    running: 0,
+    pending: [],
+    
+    async add(fn, signal) {
+        signal.throwIfAborted();
+        // 如果还有槽位，直接执行
+        if (this.running < this.maxConcurrent) {
+            this.running++;
+            try {
+                return await fn();
+            } finally {
+                this.running--;
+                this._processNext();
+            }
+        }
+        
+        // 否则加入队列等待
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                const index = this.pending.indexOf(run);
+                if (index !== -1) this.pending.splice(index, 1);
+                reject(signal.reason);
+            };
+            const run = async () => {
+                signal.removeEventListener('abort', onAbort);
+                try {
+                    signal.throwIfAborted();
+                    resolve(await fn());
+                } catch (e) {
+                    reject(e);
+                }
+            };
+            this.pending.push(run);
+            signal.addEventListener('abort', onAbort, { once: true });
+        });
+    },
+    
+    _processNext() {
+        if (this.pending.length > 0 && this.running < this.maxConcurrent) {
+            const next = this.pending.shift();
+            this.running++;
+            next().finally(() => {
+                this.running--;
+                this._processNext();
+            });
+        }
+    },
+    
+    getStats() {
+        return { running: this.running, pending: this.pending.length };
+    }
+};
+
 async function request(endpoint, options = {}) {
     const sample = beginLocalPerformanceSample(endpoint, options.method || 'GET');
     try { return await performRequest(endpoint, options, sample); }
     finally { sample?.finish(); }
 }
 
-async function performRequest(endpoint, options = {}, sample = null) {
-    const privateRead = (options.method || "GET").toUpperCase() === "GET" && isPrivateApiGet(endpoint);
-    if (privateRead) {
-        removeCache(`api_${endpoint}`);
-        options = { ...options, noStore: true };
-    }
-    // 私有详情显式不留存：同时绕过响应命中/回退/去重、插件写缓存和浏览器缓存。
-    if (options.noStore) options = { ...options, noCache: true, cache: "no-store" };
-    const url = `${BASE_URL}${endpoint}`;
-    const method = (options.method || "GET").toUpperCase();
-    const headers = { ...options.headers };
-    if (!(options.body instanceof FormData)) { headers["Content-Type"] = "application/json"; }
-    const token = _safeGetAuthToken();
-    const privateEntry = privateRead ? { revoked: false, controller: null, matches: () => token === _safeGetAuthToken() } : null;
-    const assertReadSession = () => {
-        if (privateRead && (privateEntry.revoked || !privateEntry.matches())) {
-            const error = new Error(t('auth.session_changed'));
-            error.name = 'SessionChangedError';
-            error.isCancelled = true;
-            throw error;
-        }
-    };
-    if (token) {
-        const tokenParts = token.split(".");
-        if (tokenParts.length === 3) {
-            // 标准 JWT 格式
-            headers["Authorization"] = `Bearer ${token}`;
-        } else {
-            // 🔒 P0同步：旧版 mock_token 已被后端明确拒绝（伪造后门已封堵），
-            // 以及其他无法识别的格式，统一清除本地旧凭证并提示重新登录。
-            // 🔧 修复：凭证既已清除，同步广播登出事件重置导航登录态/停止轮询，
-            // 并给用户明确提示（原实现仅 console.warn 静默清理）
-            console.warn("⚠️ 检测到无效/已过期的旧版 Token，已自动清除，请重新登录");
-            _safeClearAuthStorage();
-            window.dispatchEvent(new CustomEvent('comfy-ranking-auth-expired'));
-            notifyTokenExpired();
-        }
-    }
-    
-    // 🚀 P4优化：组件级请求取消支持
-    const componentId = options.componentId || '_global';
-    
-    // ⚡ P1性能优化：GET 请求缓存检查
-    // 🔑 P0修复：cacheKey 必须包含完整 endpoint（含查询参数），不能截断 '?' 之后的部分
-    // 例：'/api/items?type=tool&sort=time' 和 '/api/items?type=tool&sort=views' 必须产生不同的缓存 Key
-    const cacheKey = `api_${endpoint}`;
-    const trackPendingRequest = method === "GET" && !options.noCache;
-    if (method === "GET" && !options.noCache) {
-        const cached = getCache(cacheKey);
-        if (cached) {
-            const proxyFn = await getProxyImages();
+async function performRequest(endpoint, options = {}, sample = null) {
+    const privateRead = (options.method || "GET").toUpperCase() === "GET" && isPrivateApiGet(endpoint);
+    if (privateRead) {
+        removeCache(`api_${endpoint}`);
+        options = { ...options, noStore: true };
+    }
+    // 私有详情显式不留存：同时绕过响应命中/回退/去重、插件写缓存和浏览器缓存。
+    if (options.noStore) options = { ...options, noCache: true, cache: "no-store" };
+    const url = `${BASE_URL}${endpoint}`;
+    const method = (options.method || "GET").toUpperCase();
+    const headers = { ...options.headers };
+    if (!(options.body instanceof FormData)) { headers["Content-Type"] = "application/json"; }
+    const token = _safeGetAuthToken();
+    const privateEntry = privateRead ? { revoked: false, controller: null, matches: () => token === _safeGetAuthToken() } : null;
+    const assertReadSession = () => {
+        if (privateRead && (privateEntry.revoked || !privateEntry.matches())) {
+            const error = new Error(t('auth.session_changed'));
+            error.name = 'SessionChangedError';
+            error.isCancelled = true;
+            throw error;
+        }
+    };
+    if (token) {
+        const tokenParts = token.split(".");
+        if (tokenParts.length === 3) {
+            // 标准 JWT 格式
+            headers["Authorization"] = `Bearer ${token}`;
+        } else {
+            // 🔒 P0同步：旧版 mock_token 已被后端明确拒绝（伪造后门已封堵），
+            // 以及其他无法识别的格式，统一清除本地旧凭证并提示重新登录。
+            // 🔧 修复：凭证既已清除，同步广播登出事件重置导航登录态/停止轮询，
+            // 并给用户明确提示（原实现仅 console.warn 静默清理）
+            console.warn("⚠️ 检测到无效/已过期的旧版 Token，已自动清除，请重新登录");
+            _safeClearAuthStorage();
+            window.dispatchEvent(new CustomEvent('comfy-ranking-auth-expired'));
+            notifyTokenExpired();
+        }
+    }
+    
+    // 🚀 P4优化：组件级请求取消支持
+    const componentId = options.componentId || '_global';
+    
+    // ⚡ P1性能优化：GET 请求缓存检查
+    // 🔑 P0修复：cacheKey 必须包含完整 endpoint（含查询参数），不能截断 '?' 之后的部分
+    // 例：'/api/items?type=tool&sort=time' 和 '/api/items?type=tool&sort=views' 必须产生不同的缓存 Key
+    const cacheKey = `api_${endpoint}`;
+    const isRequestCacheCurrent = method === "GET" && !options.noStore ? captureCacheWrite(cacheKey) : null;
+    let isCacheWriteCurrent = isRequestCacheCurrent;
+    const trackPendingRequest = method === "GET" && !options.noCache;
+    const trackCacheOwner = method === "GET" && !options.noStore;
+    if (method === "GET" && !options.noCache) {
+        const cached = getCache(cacheKey);
+        if (cached) {
+            const source = captureCacheSource(cacheKey);
+            const proxyFn = await getProxyImages();
             sample?.cacheHit();
-            return proxyFn(cached);
-        }
-    }
-    
-    // 📴 本地兜底数据（含过期缓存）——一次读取，供下面三处复用：
-    //   ① 离线/云端不可达时直接返回它；② 判定本次 GET 是否属于「后台补新」（走短预算）；
-    //   ③ 重试耗尽后的最终回退仍按原口径自行重读一次（期间可能有并发请求写入更新的数据）
-    const fallbackMeta = (method === "GET" && !options.noCache)
-        ? getCacheWithMeta(cacheKey, true)  // 忽略过期
-        : { value: null, expired: false, found: false };
-    const conditionalRead = method === "GET" && !options.noStore && options.credentials !== "include"
-        && !Object.keys(headers).some(name => name.toLowerCase() === "authorization")
-        && API.PUBLIC_CONDITIONAL_GET_PATHS.includes(endpoint.split(/[?#]/)[0]);
-    const conditionalMeta = conditionalRead ? getCacheWithMeta(cacheKey, true) : null;
-    if (conditionalRead) {
-        for (const name of Object.keys(headers)) if (name.toLowerCase() === "if-none-match") delete headers[name];
-        if (conditionalMeta?.found && conditionalMeta.etag) headers["If-None-Match"] = conditionalMeta.etag;
-    }
-
-    // 🚀 P3优化：离线模式支持（网络状态取自 状态管理.js 的 isOnline()）
-    // ☁️ 云端不可达冷却与本机断网同等对待：两者的结论都是「这次联网注定拿不到东西」，
-    // 区别只在判据——前者看 navigator.onLine（本机网卡通不通），后者看上一次请求的
-    // 失败结论是否还在冷却期内。没有这层的话，HF Space 单独连不上时 isOnline() 恒为 true，
-    // 本分支永远不触���，于是每个界面、每轮 30 秒的消息轮询都要各自烧满 61~93 秒重试预算，
-    // 而全局并发额度只有 6 个，挂死的后台请求会把前台请求全部挤到排队
-    // noCache 只代表绕过该 endpoint 的响应缓存，不得绕过共享网络熔断；榜单强制刷新
-    // 仍由列表层先显示自己的缓存，冷却期内直接失败返回，避免切换榜单逐个重试 HF。
-    if (method === "GET" && (!isOnline() || !isCloudReachable())) {
-        if (fallbackMeta.found) {
-            console.log(`📴 ${isOnline() ? '☁️ 云端不可达' : '离线模式'}：返回${fallbackMeta.expired ? '过期' : ''}缓存`);
-            const proxyFn2 = await getProxyImages();
+            return _cachedResponse(proxyFn(cached), source);
+        }
+    }
+    
+    // 📴 本地兜底数据（含过期缓存）——一次读取，供下面三处复用：
+    //   ① 离线/云端不可达时直接返回它；② 判定本次 GET 是否属于「后台补新」（走短预算）；
+    //   ③ 重试耗尽后的最终回退仍按原口径自行重读一次（期间可能有并发请求写入更新的数据）
+    const fallbackMeta = (method === "GET" && !options.noCache)
+        ? getCacheWithMeta(cacheKey, true)  // 忽略过期
+        : { value: null, expired: false, found: false };
+    const conditionalRead = method === "GET" && !options.noStore && options.credentials !== "include"
+        && !Object.keys(headers).some(name => name.toLowerCase() === "authorization")
+        && API.PUBLIC_CONDITIONAL_GET_PATHS.includes(endpoint.split(/[?#]/)[0]);
+    const conditionalMeta = conditionalRead ? getCacheWithMeta(cacheKey, true) : null;
+    if (conditionalRead) {
+        for (const name of Object.keys(headers)) if (name.toLowerCase() === "if-none-match") delete headers[name];
+        if (conditionalMeta?.found && conditionalMeta.etag) headers["If-None-Match"] = conditionalMeta.etag;
+    }
+
+    // 🚀 P3优化：离线模式支持（网络状态取自 状态管理.js 的 isOnline()）
+    // ☁️ 云端不可达冷却与本机断网同等对待：两者的结论都是「这次联网注定拿不到东西」，
+    // 区别只在判据——前者看 navigator.onLine（本机网卡通不通），后者看上一次请求的
+    // 失败结论是否还在冷却期内。没有这层的话，HF Space 单独连不上时 isOnline() 恒为 true，
+    // 本分支永远不触发，于是每个界面、每轮 30 秒的消息轮询都要各自烧满 61~93 秒重试预算，
+    // 而全局并发额度只有 6 个，挂死的后台请求会把前台请求全部挤到排队
+    // noCache 只代表绕过该 endpoint 的响应缓存，不得绕过共享网络熔断；榜单强制刷新
+    // 仍由列表层先显示自己的缓存，冷却期内直接失败返回，避免切换榜单逐个重试 HF。
+    if (method === "GET" && (!isOnline() || !isCloudReachable())) {
+        if (fallbackMeta.found) {
+            console.log(`📴 ${isOnline() ? '☁️ 云端不可达' : '离线模式'}：返回${fallbackMeta.expired ? '过期' : ''}缓存`);
+            const source = captureCacheSource(cacheKey);
+            const proxyFn2 = await getProxyImages();
             sample?.cacheHit();
-            return proxyFn2(fallbackMeta.value);
-        }
-        // 🔧 修复：原为硬编码中文，而本错误会被 12+ 处调用方直接 showToast(err.message) 弹给用户，
-        // 导致英文界面下仍弹中文提示；现改走词典。云端不可达与本机断网分开用词，
-        // 否则本机明明有网的用户会被「网络已断开」误导去查自己的路由器
-        throw new Error(isOnline() ? t('feedback.cloud_unreachable_no_cache') : t('feedback.offline_no_cache'));
-    }
-    
-    // ⚡ P1性能优化：请求去重（相同GET请求只发一次）
-    if (trackPendingRequest) {
-        if (pendingRequests.has(cacheKey)) {
+            return _cachedResponse(proxyFn2(fallbackMeta.value), source);
+        }
+        // 🔧 修复：原为硬编码中文，而本错误会被 12+ 处调用方直接 showToast(err.message) 弹给用户，
+        // 导致英文界面下仍弹中文提示；现改走词典。云端不可达与本机断网分开用词，
+        // 否则本机明明有网的用户会被「网络已断开」误导去查自己的路由器
+        throw new Error(isOnline() ? t('feedback.cloud_unreachable_no_cache') : t('feedback.offline_no_cache'));
+    }
+    
+    // ⚡ P1性能优化：请求去重（相同GET请求只发一次）
+    if (trackPendingRequest) {
+        const pending = pendingRequests.get(cacheKey);
+        if (pending && pendingRequestGuards.get(pending)?.() && cacheReadOwners.get(cacheKey) === pending) {
             sample?.discard();
-            return pendingRequests.get(cacheKey);
-        }
-    }
-    
-    const fetchOptions = { ...options, method, headers };
-    
-    // 🚀 核心修改：在将 body 转为 JSON 字符串发送前，执行无情剥离！
-    if (options.body && !(options.body instanceof FormData) && typeof options.body !== "string") {
-        fetchOptions.body = JSON.stringify(unproxyImages(options.body));
-    } else if (options.body instanceof FormData) {
-        fetchOptions.body = options.body;
-    }
-
-    // 🚀 P1优化：重试与超时预算
-    // 🔧 修复：重试次数/间隔此前硬编码在本文件（2 / 1000），使 全局配置.js 的
-    // API.MAX_RETRIES、API.RETRY_DELAY 成为死配置，现统一读取配置中心
-    // 🐢 弱网预算分级：列表/搜索类 GET 有本地缓存兜底，失败上限适当收紧，
-    // 避免弱网下用户长时间盯骨架屏；按去掉查询串的路径全匹配，
-    // 不会误伤 /api/items/{id}、/api/creators/{account}/details 等详情请求
-    const endpointPath = endpoint.split("?")[0];
-    let defaultTimeout = API.TIMEOUT;
-    let defaultRetries = method === "GET" ? API.MAX_RETRIES : 0;  // 非 GET 不重试
-    if (method === "GET") {
-        if (endpointPath === "/api/creators/search") {
-            defaultTimeout = API.SEARCH_TIMEOUT;
-            defaultRetries = API.SEARCH_RETRIES;
-        } else if (endpointPath === "/api/items" || endpointPath === "/api/creators") {
-            defaultRetries = API.LIST_RETRIES;
-        }
-    }
-    // 🐢 后台补新短预算：本地已有该请求的缓存，说明列表视图已经把内容渲染上屏了
-    // （七大列表都是「本地数据先上屏 → 再发请求补新」），这次请求纯属后台行为，
-    // 失败要快——它每多挂 1 秒就多占 1 个并发额度（全局仅 6 个）。用 Math.min 只收不放，
-    // 不会把搜索类已经收紧过的 10s 预算又放宽回去。
-    // noCache 请求不参与：调用方明确要权威新数据（余额、安装前的资源详情、广告配置），
-    // 把它的超时砍短会把「慢但能成功」变成「快速失败」，违背调用方意图
-    const useCacheBudget = method === "GET" && !options.noCache && fallbackMeta.found;
-    if (useCacheBudget) {
-        defaultTimeout = Math.min(defaultTimeout, API.BACKGROUND_TIMEOUT);
-        defaultRetries = Math.min(defaultRetries, API.BACKGROUND_RETRIES);
-    }
-    const requestTimeout = options.timeout || defaultTimeout;
-    const maxRetries = options.retries ?? defaultRetries;
-    const retryDelay = options.retryDelay ?? API.RETRY_DELAY;  // 指数退避基数
-    
-    // ⚡ P1性能优化：封装请求 Promise（支持去重 + 重试）
-    if (privateEntry) activePrivateReads.add(privateEntry);
-    const requestPromise = (async () => {
-        let lastError = null;
-        // ☁️ 本次失败是否属于「网络层不可达」（超时 / 连不上），用于循环结束后决定是否打冷却。
-        // 5xx 不置位：服务端已经应答说明云端可达，若也打冷却会让一个坏接口把全站 GET 拖下水
-        let networkLevelFailure = false;
-        
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            assertReadSession();
-            // 🚀 P1优化：指数退避延迟
-            if (attempt > 0) {
-                // ☁️ 冷却已生效就停止重试：另一个并发请求可能刚刚确证云端不可达，
-                // 继续重试只是白烧一轮超时预算、白占一个并发额度，直接跳去下方缓存兜底
-                if (method === "GET" && !isCloudReachable()) break;
-                const delay = retryDelay * Math.pow(2, attempt - 1);  // 1s, 2s, 4s...
-                console.log(`🔄 请求重试 (${attempt}/${maxRetries})...`);
-                await new Promise(r => setTimeout(r, delay));
-            }
-                    
-            // 🚀 P4优化：使用请求取消管理器（支持超时 + 组件级取消）
-            const controller = requestCancelManager.create(componentId);
-            if (privateEntry) privateEntry.controller = controller;
-            const currentFetchOptions = { ...fetchOptions, signal: controller.signal };
-            let timeoutId = null;
-            let timedOut = false;
-            let fetchStarted = false;
-            let transportFailed = false;
-            const onTimeout = () => { timedOut = true; controller.abort(); };
-            // 已有缓存时排队也计入预算，避免被无缓存的慢请求无限拖住。
-            if (useCacheBudget) timeoutId = setTimeout(onTimeout, requestTimeout);
-                    
-            try {
-                const result = await requestQueue.add(async () => {
-                    if (!useCacheBudget) timeoutId = setTimeout(onTimeout, requestTimeout);
-                    // 请求可能在云端故障被另一个并发请求确认前进入队列；出队发出 fetch
-                    // 前复查共享状态，避免队列继续逐个访问已知不可达的 HF endpoint。
-                    if (method === "GET" && (!isOnline() || !isCloudReachable())) {
-                        const unavailableError = new Error(
-                            isOnline() ? t('feedback.cloud_unreachable_no_cache') : t('feedback.offline_no_cache')
-                        );
-                        unavailableError.name = 'CloudUnavailableError';
-                        throw unavailableError;
-                    }
-                    assertReadSession();
-                    fetchStarted = true;
-                    try {
-                        let response = await fetch(url, currentFetchOptions);
-                        let validatedData;
-                        if (response.status === 304 && conditionalRead) {
-                            const currentMeta = getCacheWithMeta(cacheKey, true);
-                            if (conditionalMeta?.found && conditionalMeta.etag
-                                && response.headers?.get?.('ETag') === conditionalMeta.etag
-                                && currentMeta.found && currentMeta.etag === conditionalMeta.etag
-                                && currentMeta.value === conditionalMeta.value) {
+            return pending;
+        }
+    }
+    
+    const fetchOptions = { ...options, method, headers };
+    
+    // 🚀 核心修改：在将 body 转为 JSON 字符串发送前，执行无情剥离！
+    if (options.body && !(options.body instanceof FormData) && typeof options.body !== "string") {
+        fetchOptions.body = JSON.stringify(unproxyImages(options.body));
+    } else if (options.body instanceof FormData) {
+        fetchOptions.body = options.body;
+    }
+
+    // 🚀 P1优化：重试与超时预算
+    // 🔧 修复：重试次数/间隔此前硬编码在本文件（2 / 1000），使 全局配置.js 的
+    // API.MAX_RETRIES、API.RETRY_DELAY 成为死配置，现统一读取配置中心
+    // 🐢 弱网预算分级：列表/搜索类 GET 有本地缓存兜底，失败上限适当收紧，
+    // 避免弱网下用户长时间盯骨架屏；按去掉查询串的路径全匹配，
+    // 不会误伤 /api/items/{id}、/api/creators/{account}/details 等详情请求
+    const endpointPath = endpoint.split("?")[0];
+    let defaultTimeout = API.TIMEOUT;
+    let defaultRetries = method === "GET" ? API.MAX_RETRIES : 0;  // 非 GET 不重试
+    if (method === "GET") {
+        if (endpointPath === "/api/creators/search") {
+            defaultTimeout = API.SEARCH_TIMEOUT;
+            defaultRetries = API.SEARCH_RETRIES;
+        } else if (endpointPath === "/api/items" || endpointPath === "/api/creators") {
+            defaultRetries = API.LIST_RETRIES;
+        }
+    }
+    // 🐢 后台补新短预算：本地已有该请求的缓存，说明列表视图已经把内容渲染上屏了
+    // （七大列表都是「本地数据先上屏 → 再发请求补新」），这次请求纯属后台行为，
+    // 失败要快——它每多挂 1 秒就多占 1 个并发额度（全局仅 6 个）。用 Math.min 只收不放，
+    // 不会把搜索类已经收紧过的 10s 预算又放宽回去。
+    // noCache 请求不参与：调用方明确要权威新数据（余额、安装前的资源详情、广告配置），
+    // 把它的超时砍短会把「慢但能成功」变成「快速失败」，违背调用方意图
+    const useCacheBudget = method === "GET" && !options.noCache && fallbackMeta.found;
+    if (useCacheBudget) {
+        defaultTimeout = Math.min(defaultTimeout, API.BACKGROUND_TIMEOUT);
+        defaultRetries = Math.min(defaultRetries, API.BACKGROUND_RETRIES);
+    }
+    const requestTimeout = options.timeout || defaultTimeout;
+    const maxRetries = options.retries ?? defaultRetries;
+    const retryDelay = options.retryDelay ?? API.RETRY_DELAY;  // 指数退避基数
+    
+    // ⚡ P1性能优化：封装请求 Promise（支持去重 + 重试）
+    if (privateEntry) activePrivateReads.add(privateEntry);
+    const requestPromise = (async () => {
+        let lastError = null;
+        // ☁️ 本次失败是否属于「网络层不可达」（超时 / 连不上），用于循环结束后决定是否打冷却。
+        // 5xx 不置位：服务端已经应答说明云端可达，若也打冷却会让一个坏接口把全站 GET 拖下水
+        let networkLevelFailure = false;
+        
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            assertReadSession();
+            // 🚀 P1优化：指数退避延迟
+            if (attempt > 0) {
+                // ☁️ 冷却已生效就停止重试：另一个并发请求可能刚刚确证云端不可达，
+                // 继续重试只是白烧一轮超时预算、白占一个并发额度，直接跳去下方缓存兜底
+                if (method === "GET" && !isCloudReachable()) break;
+                const delay = retryDelay * Math.pow(2, attempt - 1);  // 1s, 2s, 4s...
+                console.log(`🔄 请求重试 (${attempt}/${maxRetries})...`);
+                await new Promise(r => setTimeout(r, delay));
+            }
+                    
+            // 🚀 P4优化：使用请求取消管理器（支持超时 + 组件级取消）
+            const controller = requestCancelManager.create(componentId);
+            if (privateEntry) privateEntry.controller = controller;
+            const currentFetchOptions = { ...fetchOptions, signal: controller.signal };
+            let timeoutId = null;
+            let timedOut = false;
+            let fetchStarted = false;
+            let transportFailed = false;
+            const onTimeout = () => { timedOut = true; controller.abort(); };
+            // 已有缓存时排队也计入预算，避免被无缓存的慢请求无限拖住。
+            if (useCacheBudget) timeoutId = setTimeout(onTimeout, requestTimeout);
+                    
+            try {
+                const result = await requestQueue.add(async () => {
+                    if (!useCacheBudget) timeoutId = setTimeout(onTimeout, requestTimeout);
+                    // 请求可能在云端故障被另一个并发请求确认前进入队列；出队发出 fetch
+                    // 前复查共享状态，避免队列继续逐个访问已知不可达的 HF endpoint。
+                    if (method === "GET" && (!isOnline() || !isCloudReachable())) {
+                        const unavailableError = new Error(
+                            isOnline() ? t('feedback.cloud_unreachable_no_cache') : t('feedback.offline_no_cache')
+                        );
+                        unavailableError.name = 'CloudUnavailableError';
+                        throw unavailableError;
+                    }
+                    assertReadSession();
+                    fetchStarted = true;
+                    try {
+                        if (isRequestCacheCurrent) isCacheWriteCurrent = captureCacheWrite(cacheKey);
+                        let response = await fetch(url, currentFetchOptions);
+                        let validatedData;
+                        if (response.status === 304 && conditionalRead) {
+                            const currentMeta = getCacheWithMeta(cacheKey, true);
+                            if (conditionalMeta?.found && conditionalMeta.etag
+                                && response.headers?.get?.('ETag') === conditionalMeta.etag
+                                && currentMeta.found && currentMeta.etag === conditionalMeta.etag
+                                && currentMeta.value === conditionalMeta.value) {
                                 sample?.cacheHit();
-                                validatedData = currentMeta.value;
-                            } else {
-                                // 缓存可能在等待期间被清理/写操作失效；同一预算内补取完整响应。
-                                const fullHeaders = { ...currentFetchOptions.headers };
-                                for (const name of Object.keys(fullHeaders)) if (name.toLowerCase() === "if-none-match") delete fullHeaders[name];
-                                if (controller.signal.aborted) throw new DOMException('Aborted', 'AbortError');
-                                response = await fetch(url, { ...currentFetchOptions, headers: fullHeaders, cache: "no-store" });
-                                if (response.status === 304) throw new SyntaxError('Unexpected not-modified response');
-                            }
-                        }
-                        let data;
-                        let bodyConfirmed = true;
-                        try {
-                            data = validatedData !== undefined ? validatedData
-                                : response.status === 204 ? {} : await response.json();
-                        } catch (error) {
-                            // 错误响应的正文不可读时仍按 HTTP 状态处理，不能用缓存掩盖 401/403。
-                            if (!response.ok && (error instanceof SyntaxError || error instanceof TypeError || (timedOut && error.name === 'AbortError'))) {
-                                data = {};
-                                bodyConfirmed = false;
-                            } else {
-                                throw error;
-                            }
-                        }
-                        return { response, data, bodyConfirmed, validated: validatedData !== undefined };
-                    } catch (error) {
-                        transportFailed = error instanceof TypeError;
-                        throw error;
-                    }
-                }, controller.signal);
-                clearTimeout(timeoutId);
-                requestCancelManager.remove(componentId, controller);
-                const { response } = result;
-                let responseData = result.data;
-                assertReadSession();
-
-                if (!response.ok && !result.validated) {
-                    if (!responseData || typeof responseData !== "object" || Array.isArray(responseData)) responseData = {};
-                    const errorMsg = httpErrorMessage(responseData, response.status);
-                    
-                    // 🚀 P1优化：4xx 错误不重试，5xx 错误可重试
-                    if (response.status >= 400 && response.status < 500) {
-                        if (response.status === 401) {
-                            // 🔧 修复：清除失效凭证并提示重新登录（原实现仅广播事件，无人清理）；
-                            // 传入本请求实际使用的 Token 做竞态比对，避免误清重新登录后签发的新凭证。
-                            // 仅当确认凭证确实失效后才广播登出事件（导航停止轮询并重置登录态），
-                            // 迟到的旧 401 或匿名请求的 401 不再误触发登录态重置。
-                            // 登录接口的 401 语义是「密码错误」而非凭证失效，不走全局清理，
-                            // 避免与登录表单自身的错误提示重复叠加
-                            if (endpoint !== "/api/users/login" && handleAuthExpired(token)) {
-                                window.dispatchEvent(new CustomEvent('comfy-ranking-auth-expired'));
-                            }
-                        }
-                        const error = withRequestDiagnostic(new Error(errorMsg), response, responseData);
-                        error.status = response.status;
-                        if (typeof responseData.detail === "string" && /^[a-z][a-z0-9_]{0,79}$/.test(responseData.detail)) error.code = responseData.detail;
-                        if (result.bodyConfirmed && Object.hasOwn(API.REQUEST_BODY_ERRORS, error.code)
-                                && API.REQUEST_BODY_ERRORS[error.code].status === error.status) {
-                            error.requestBodyRejected = true;
-                        }
-                        throw error;
-                    }
-
-                    // 应用明确标记且正文可读的503只影响当前接口，仍允许其它榜单联网。
-                    if (response.status === 503 && result.bodyConfirmed &&
-                            response.headers?.get?.(API.ENDPOINT_ERROR_SCOPE_HEADER) === API.ENDPOINT_ERROR_SCOPE_VALUE) {
-                        lastError = withRequestDiagnostic(new Error(errorMsg), response, responseData);
-                        lastError.status = response.status;
-                        networkLevelFailure = false;
-                        break;
-                    }
-
-                    // Hugging Face Space / 网关不可用通常以 502、503 或 504 响应，
-                    // 这类响应证明请求到达了代理层，但云端当前无法提供服务。
-                    // 与超时/连接失败一样共享冷却，避免切换榜单时每个 endpoint
-                    // 都重复访问一次；普通 500 仍只视为单接口服务端错误。
-                    if ([502, 503, 504].includes(response.status)) {
-                        lastError = withRequestDiagnostic(new Error(errorMsg), response, responseData);
-                        lastError.status = response.status;
-                        networkLevelFailure = true;
-                        markCloudDown(endpoint);
-                        break;
-                    }
-                    
-                    lastError = withRequestDiagnostic(new Error(errorMsg), response, responseData);
-                    lastError.status = response.status;
-                    continue;  // 5xx 错误重试
-                }
-
-                // ☁️ 拿到了正常应答即证明云端可达，立即清零冷却（不必等它自然过期）。
-                // 非 GET 的成功同样算数——写操作是冷却期内唯一还在联网的请求，天然是探针
-                markCloudUp();
-
-                // 🚀 P1优化：精确清除相关缓存（替代暴力清空）
-                if (["POST", "PUT", "DELETE"].includes(method)) {
-                    invalidateRelatedCache(endpoint, method);
-                }
-
-                // ⚡ P1性能优化：GET 请求结果缓存
-                if (method === "GET" && !options.noStore) {
-                    const ttl = _getCacheTTL(endpoint);
-                    if (ttl > 0) {
-                        // 创作者列表不持久化到 localStorage，避免空间不足
-                        const persist = !endpoint.includes('/api/creators');
-                        setCache(cacheKey, responseData, ttl, persist,
-                            conditionalRead ? { etag: response.headers?.get?.('ETag') } : {});
-                    }
-                }
-
-                // 入口数据挂载代理
-                const proxyFn3 = await getProxyImages();
-                assertReadSession();
-                responseData = proxyFn3(responseData);
-                return responseData;
-            } catch (error) {
-                clearTimeout(timeoutId);  // 清除超时计时器
-                // 🔍 失败/超��同样摘除 controller：成功路径在上方已 remove，这里不补的话，
-                // 取消分组里会堆积已失效的 controller，使 cancelAll 的在途计数虚高
-                requestCancelManager.remove(componentId, controller);
-                assertReadSession();
-
-                // 🔍 主动撤销（组件级取消）与超时都表现为 AbortError，但语义完全相反：
-                // 超时该重试；主动撤销是调用方明确表示「这次结果我不要了」，绝不能重试，
-                // 否则会白烧一轮超时预算（搜索场景下用户每敲一次键都可能触发一次撤销）。
-                // 直接抛出而不走循环后的「过期缓存兜底」，避免把作废请求的结果上屏
-                if (error.name === 'AbortError' && !timedOut) {
-                    const cancelErr = new Error(t('feedback.request_cancelled'));
-                    cancelErr.name = 'RequestCancelledError';
-                    cancelErr.isCancelled = true;
-                    throw cancelErr;
-                }
-
-                // 队列等待期间已有并发请求确证网络不可达：该请求尚未发出 fetch，
-                // 直接交给统一缓存兜底，不重试、不延长冷却，也不把队列错误当作网络探测。
-                if (error.name === 'CloudUnavailableError') {
-                    lastError = error;
-                    break;
-                }
-                
-                // 🔧 P1优化：可重试的错误类型
-                const isRetryable = (
-                    error.name === 'AbortError' ||
-                    transportFailed
-                );
-                
-                if (isRetryable) {
-                    // 🔧 修复：重试耗尽时不再直接 throw（否则循环后的「过期缓存兜底」
-                    // 分支永远不可达，断网时无法无缝切换本地数据）。记录友好错误后跳出循环，
-                    // 让 GET 请求走过期缓存回退；无缓存时仍以该友好错误抛出。
-                    const isTimeout = error.name === 'AbortError';
-                    lastError = isTimeout
-                        ? new Error(t('feedback.network_timeout'))
-                        : new Error(t('feedback.network_unavailable'));
-                    lastError.code = isTimeout ? 'network_timeout' : 'network_unavailable';
-                    if (fetchStarted) networkLevelFailure = true;
-                    // ☁️ 连接层失败（被墙 / DNS 污染 / 拒绝连接 / 证书错误）几乎不会是偶发抖动，
-                    // 打上冷却后其它界面与轮询就不用再各自烧一遍预算。但单次失败不足以定论，
-                    // 故分两种口径：已配重试时要求第二次尝试仍失败才定论（连接层失败是毫秒级的，
-                    // 多等一轮只多花约 1 秒，却能挡住偶发抖动误伤 60 秒）；
-                    // 未配重试时（后台补新短预算，界面已用缓存上屏）误判零代价，立即定论。
-                    // 超时则可能是 HF Space 冷启动（慢但能成功），不在此定论，耗尽后由下方统一处理
-                    if (!isTimeout && (attempt >= 1 || maxRetries === 0)) markCloudDown(endpoint);
-                    if (attempt < maxRetries) continue;  // 重试
-                    break;  // 重试耗尽 → 跳到过期缓存兜底
-                }
-                
-                // 🔧 P3优化：错误分类处理，提供更清晰的错误信息（不可重试错误直接抛出）
-                if (error instanceof SyntaxError) {
-                    throw new Error(t('feedback.response_format_error'));
-                }
-                throw error;
-            }
-        }
-        
-        // ☁️ 所有尝试都因网络层原因失败（超时耗尽重试也走这里）→ 打上冷却，
-        // 接下来 API.CLOUD_DOWN_COOLDOWN 内的 GET 全部就地走缓存，不再重复等待
-        if (networkLevelFailure) markCloudDown(endpoint);
-
-        // 所有重试都失败，尝试回退到过期缓存
-        if (method === "GET" && !options.noCache) {
-            const fallback = getCacheWithMeta(cacheKey, true);  // true = 允许过期
-            if (fallback.found) {
-                console.warn('📴 网络请求失败，回退到本地缓存');
-                const proxyFn4 = await getProxyImages();
+                                validatedData = currentMeta.value;
+                            } else {
+                                // 缓存可能在等待期间被清理/写操作失效；同一预算内补取完整响应。
+                                const fullHeaders = { ...currentFetchOptions.headers };
+                                for (const name of Object.keys(fullHeaders)) if (name.toLowerCase() === "if-none-match") delete fullHeaders[name];
+                                if (controller.signal.aborted) throw new DOMException('Aborted', 'AbortError');
+                                isCacheWriteCurrent = captureCacheWrite(cacheKey);
+                                response = await fetch(url, { ...currentFetchOptions, headers: fullHeaders, cache: "no-store" });
+                                if (response.status === 304) throw new SyntaxError('Unexpected not-modified response');
+                            }
+                        }
+                        let data;
+                        let bodyConfirmed = true;
+                        try {
+                            data = validatedData !== undefined ? validatedData
+                                : response.status === 204 ? {} : await response.json();
+                        } catch (error) {
+                            // 错误响应的正文不可读时仍按 HTTP 状态处理，不能用缓存掩盖 401/403。
+                            if (!response.ok && (error instanceof SyntaxError || error instanceof TypeError || (timedOut && error.name === 'AbortError'))) {
+                                data = {};
+                                bodyConfirmed = false;
+                            } else {
+                                throw error;
+                            }
+                        }
+                        return { response, data, bodyConfirmed, validated: validatedData !== undefined };
+                    } catch (error) {
+                        transportFailed = error instanceof TypeError;
+                        throw error;
+                    }
+                }, controller.signal);
+                clearTimeout(timeoutId);
+                requestCancelManager.remove(componentId, controller);
+                const { response } = result;
+                let responseData = result.data;
+                assertReadSession();
+
+                if (!response.ok && !result.validated) {
+                    if (!responseData || typeof responseData !== "object" || Array.isArray(responseData)) responseData = {};
+                    const errorMsg = httpErrorMessage(responseData, response.status);
+                    
+                    // 🚀 P1优化：4xx 错误不重试，5xx 错误可重试
+                    if (response.status >= 400 && response.status < 500) {
+                        if (response.status === 401) {
+                            // 🔧 修复：清除失效凭证并提示重新登录（原实现仅广播事件，无人清理）；
+                            // 传入本请求实际使用的 Token 做竞态比对，避免误清重新登录后签发的新凭证。
+                            // 仅当确认凭证确实失效后才广播登出事件（导航停止轮询并重置登录态），
+                            // 迟到的旧 401 或匿名请求的 401 不再误触发登录态重置。
+                            // 登录接口的 401 语义是「密码错误」而非凭证失效，不走全局清理，
+                            // 避免与登录表单自身的错误提示重复叠加
+                            if (endpoint !== "/api/users/login" && handleAuthExpired(token)) {
+                                window.dispatchEvent(new CustomEvent('comfy-ranking-auth-expired'));
+                            }
+                        }
+                        const error = withRequestDiagnostic(new Error(errorMsg), response, responseData);
+                        error.status = response.status;
+                        if (typeof responseData.detail === "string" && /^[a-z][a-z0-9_]{0,79}$/.test(responseData.detail)) error.code = responseData.detail;
+                        if (result.bodyConfirmed && Object.hasOwn(API.REQUEST_BODY_ERRORS, error.code)
+                                && API.REQUEST_BODY_ERRORS[error.code].status === error.status) {
+                            error.requestBodyRejected = true;
+                        }
+                        throw error;
+                    }
+
+                    // 应用明确标记且正文可读的503只影响当前接口，仍允许其它榜单联网。
+                    if (response.status === 503 && result.bodyConfirmed &&
+                            response.headers?.get?.(API.ENDPOINT_ERROR_SCOPE_HEADER) === API.ENDPOINT_ERROR_SCOPE_VALUE) {
+                        lastError = withRequestDiagnostic(new Error(errorMsg), response, responseData);
+                        lastError.status = response.status;
+                        networkLevelFailure = false;
+                        break;
+                    }
+
+                    // Hugging Face Space / 网关不可用通常以 502、503 或 504 响应，
+                    // 这类响应证明请求到达了代理层，但云端当前无法提供服务。
+                    // 与超时/连接失败一样共享冷却，避免切换榜单时每个 endpoint
+                    // 都重复访问一次；普通 500 仍只视为单接口服务端错误。
+                    if ([502, 503, 504].includes(response.status)) {
+                        lastError = withRequestDiagnostic(new Error(errorMsg), response, responseData);
+                        lastError.status = response.status;
+                        networkLevelFailure = true;
+                        markCloudDown(endpoint);
+                        break;
+                    }
+                    
+                    lastError = withRequestDiagnostic(new Error(errorMsg), response, responseData);
+                    lastError.status = response.status;
+                    continue;  // 5xx 错误重试
+                }
+
+                // ☁️ 拿到了正常应答即证明云端可达，立即清零冷却（不必等它自然过期）。
+                // 非 GET 的成功同样算数——写操作是冷却期内唯一还在联网的请求，天然是探针
+                markCloudUp();
+
+                // 🚀 P1优化：精确清除相关缓存（替代暴力清空）
+                if (["POST", "PUT", "DELETE"].includes(method)) {
+                    invalidateRelatedCache(endpoint, method);
+                }
+
+                // ⚡ P1性能优化：GET 请求结果缓存
+                if (method === "GET" && !options.noStore && isCacheWriteCurrent() && cacheReadOwners.get(cacheKey) === requestPromise) {
+                    const ttl = _getCacheTTL(endpoint);
+                    if (ttl > 0) {
+                        // 创作者列表不持久化到 localStorage，避免空间不足
+                        const persist = !endpoint.includes('/api/creators');
+                        setCache(cacheKey, responseData, ttl, persist,
+                            conditionalRead ? { etag: response.headers?.get?.('ETag') } : {});
+                    }
+                }
+
+                // 入口数据挂载代理
+                const proxyFn3 = await getProxyImages();
+                assertReadSession();
+                responseData = proxyFn3(responseData);
+                if (responseData && typeof responseData === "object") {
+                    responseCacheSources.delete(responseData);
+                    if (trackCacheOwner && (!isCacheWriteCurrent() || cacheReadOwners.get(cacheKey) !== requestPromise)) responseCacheSources.set(responseData, { source: null });
+                }
+                return responseData;
+            } catch (error) {
+                clearTimeout(timeoutId);  // 清除超时计时器
+                // 🔍 失败/超时同样摘除 controller：成功路径在上方已 remove，这里不补的话，
+                // 取消分组里会堆积已失效的 controller，使 cancelAll 的在途计数虚高
+                requestCancelManager.remove(componentId, controller);
+                assertReadSession();
+
+                // 🔍 主动撤销（组件级取消）与超时都表现为 AbortError，但语义完全相反：
+                // 超时该重试；主动撤销是调用方明确表示「这次结果我不要了」，绝不能重试，
+                // 否则会白烧一轮超时预算（搜索场景下用户每敲一次键都可能触发一次撤销）。
+                // 直接抛出而不走循环后的「过期缓存兜底」，避免把作废请求的结果上屏
+                if (error.name === 'AbortError' && !timedOut) {
+                    const cancelErr = new Error(t('feedback.request_cancelled'));
+                    cancelErr.name = 'RequestCancelledError';
+                    cancelErr.isCancelled = true;
+                    throw cancelErr;
+                }
+
+                // 队列等待期间已有并发请求确证网络不可达：该请求尚未发出 fetch，
+                // 直接交给统一缓存兜底，不重试、不延长冷却，也不把队列错误当作网络探测。
+                if (error.name === 'CloudUnavailableError') {
+                    lastError = error;
+                    break;
+                }
+                
+                // 🔧 P1优化：可重试的错误类型
+                const isRetryable = (
+                    error.name === 'AbortError' ||
+                    transportFailed
+                );
+                
+                if (isRetryable) {
+                    // 🔧 修复：重试耗尽时不再直接 throw（否则循环后的「过期缓存兜底」
+                    // 分支永远不可达，断网时无法无缝切换本地数据）。记录友好错误后跳出循环，
+                    // 让 GET 请求走过期缓存回退；无缓存时仍以该友好错误抛出。
+                    const isTimeout = error.name === 'AbortError';
+                    lastError = isTimeout
+                        ? new Error(t('feedback.network_timeout'))
+                        : new Error(t('feedback.network_unavailable'));
+                    lastError.code = isTimeout ? 'network_timeout' : 'network_unavailable';
+                    if (fetchStarted) networkLevelFailure = true;
+                    // ☁️ 连接层失败（被墙 / DNS 污染 / ���绝连接 / 证书错误）几乎不会是偶发抖动，
+                    // 打上冷却后其它界面与轮询就不用再各自烧一遍预算。但单次失败不足以定论，
+                    // 故分两种口径：已配重试时要求第二次尝试仍失败才定论（连接层失败是毫秒级的，
+                    // 多等一轮只多花约 1 秒，却能挡住偶发抖动误伤 60 秒）；
+                    // 未配重试时（后台补新短预算，界面已用缓存上屏）误判零代价，立即定论。
+                    // 超时则可能是 HF Space 冷启动（慢但能成功），不在此定论，耗尽后由下方统一处理
+                    if (!isTimeout && (attempt >= 1 || maxRetries === 0)) markCloudDown(endpoint);
+                    if (attempt < maxRetries) continue;  // 重试
+                    break;  // 重试耗尽 → 跳到过期缓存兜底
+                }
+                
+                // 🔧 P3优化：错误分类处理，提供更清晰的错误信息（不可重试错误直接抛出）
+                if (error instanceof SyntaxError) {
+                    throw new Error(t('feedback.response_format_error'));
+                }
+                throw error;
+            }
+        }
+        
+        // ☁️ 所有尝试都因网络层原因失败（超时耗尽重试也走这里）→ 打上冷却，
+        // 接下来 API.CLOUD_DOWN_COOLDOWN 内的 GET 全部就地走缓存，不再重复等待
+        if (networkLevelFailure) markCloudDown(endpoint);
+
+        // 所有重试都失败，尝试回退到过期缓存
+        if (method === "GET" && !options.noCache) {
+            const fallback = getCacheWithMeta(cacheKey, true);  // true = 允许过期
+            if (fallback.found) {
+                console.warn('📴 网络请求失败，回退到本地缓存');
+                const source = captureCacheSource(cacheKey);
+                const proxyFn4 = await getProxyImages();
                 sample?.cacheHit();
-                return proxyFn4(fallback.value);  // 返回过期缓存数据
-            }
-        }
-        // 仍无缓存，才抛异常
-        throw lastError || new Error(t('feedback.error'));
-    })();
-    
-    if (privateEntry) requestPromise.finally(() => activePrivateReads.delete(privateEntry)).catch(() => {});
-
-    // 记录进行中的请求
-    if (trackPendingRequest) {
-        pendingRequests.set(cacheKey, requestPromise);
-    }
-    
-    // 确保请求完成后清除去重记录
-    // 🔧 补 .catch 空处理：finally 会派生出一个新的 Promise，而它从未被返回也无人接收，
-    // 一旦请求失败（含主动撤销）就会在控制台抛 Uncaught (in promise)。
-    // 原始 requestPromise 仍在下方正常返回给调用方处理，此处只是吞掉这份重复的拒绝
-    if (trackPendingRequest) {
-        requestPromise.finally(() => {
-            pendingRequests.delete(cacheKey);
-        }).catch(() => {});
-    }
-    
-    return requestPromise;
-}
-
-// ==========================================
-// 📡 SSE 流式请求（用于安装进度等长时间操作）
-// ==========================================
-
-/**
- * 发起 SSE 流式请求（用于安装进度等长时间操作）
- * @param {string} endpoint - API端点路径（本地ComfyUI路径，如 /community_hub/install_tool_stream）
- * @param {Object} body - POST请求体
- * @param {Function} onProgress - 进度回调 ({stage, progress, message, status, data}) => void
- * @param {Object} [options] - 可选配置 { timeout: 300000 }
- * @returns {Promise<Object>} 最终结果事件
- */
-export async function requestSSE(endpoint, body, onProgress, options = {}) {
-    const timeout = options.timeout || 1200000; // 20分钟全局超时（大型工具克隆需要较长时间）
-    const controller = new AbortController();
-    const globalTimer = setTimeout(() => controller.abort(), timeout);
-    const externalSignal = options.signal;
-    const abortFromCaller = () => controller.abort();
-    if (externalSignal?.aborted) controller.abort();
-    else externalSignal?.addEventListener("abort", abortFromCaller, { once: true });
-
-    // 📡 空闲超时检测：长时间无数据视为连接已断
-    const IDLE_TIMEOUT_DEFAULT = 30000;  // 30 秒无数据视为空闲
-    const IDLE_TIMEOUT_GRACE = 5000;     // 收到 finalResult 后的宽限期 5 秒
-    let currentIdleTimeout = options.idleTimeout || IDLE_TIMEOUT_DEFAULT;
-    let idleTimer = null;
-    let finalResult = null;
-    let streamReader = null;
-
-    const clearIdleTimer = () => {
-        if (idleTimer !== null) {
-            clearTimeout(idleTimer);
-            idleTimer = null;
-        }
-    };
-
-    try {
-        const response = await fetch(endpoint, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: controller.signal
-        });
-
-        if (!response.ok) {
-            const error = withRequestDiagnostic(new Error(t('feedback.http_request_failed', { status: response.status })), response);
-            error.status = response.status;
-            // 仅当流式路由明确不存在/不接受该方法时，调用方可安全回退到旧端点。
-            // 网络错误、超时和服务端错误都可能发生在操作已开始后，不可自动重发。
-            error.fallbackSafe = response.status === 404 || response.status === 405;
-            throw error;
-        }
-
-        const reader = streamReader = response.body.getReader();
-        const decoder = new TextDecoder('utf-8', { fatal: true });
-        const decodeSSEChunk = (value, options) => {
-            try {
-                return decoder.decode(value, options);
-            } catch (_) {
-                const error = new Error(t('feedback.stream_invalid_encoding'));
-                error.code = 'invalid_stream_encoding';
-                error.outcomeUnknown = true;
-                throw error;
-            }
-        };
-        let totalBytes = 0, lineBytes = 0, lineCount = 0;
-        let workBytes = 0, workLines = 0, workChunks = 0;
-        const lineParts = [];
-        const limitError = () => {
-            const error = new Error(t('feedback.stream_limit_exceeded'));
-            error.code = 'stream_limit_exceeded';
-            error.outcomeUnknown = true;
-            return error;
-        };
-        const appendLinePart = (part) => {
-            if (!part) return;
-            let level = 0;
-            while (lineParts[level] !== undefined) {
-                part = lineParts[level] + part;
-                lineParts[level++] = undefined;
-            }
-            lineParts[level] = part;
-        };
-        const takeLine = () => {
-            const line = lineParts.slice().reverse().filter(part => part !== undefined).join('');
-            lineParts.length = 0;
-            return line;
-        };
-        const yieldIfNeeded = async () => {
-            if (workBytes >= API.SSE_YIELD_BYTES || workLines >= API.SSE_YIELD_LINES || workChunks >= API.SSE_YIELD_CHUNKS) {
-                workBytes = workLines = workChunks = 0;
-                await new Promise(resolve => setTimeout(resolve, 0));
-            }
-            if (controller.signal.aborted) throw new DOMException('Aborted', 'AbortError');
-        };
-        const checkChunkBudget = (value) => {
-            totalBytes += value.byteLength;
-            if (totalBytes > API.SSE_MAX_RESPONSE_BYTES) throw limitError();
-            let start = 0, end;
-            while ((end = value.indexOf(10, start)) !== -1) {
-                lineBytes += end - start;
-                if (lineBytes > API.SSE_MAX_LINE_BYTES) throw limitError();
-                lineBytes = 0;
-                start = end + 1;
-            }
-            lineBytes += value.byteLength - start;
-            if (lineBytes > API.SSE_MAX_LINE_BYTES) throw limitError();
-        };
-        const processSSELine = (line) => {
-            if (!line.startsWith("data: ")) return;
-            let data;
-            try {
-                data = JSON.parse(line.slice(6));
-            } catch (_) {
-                console.warn("[SSE] 解析事件失败");
-                return;
-            }
-            if (!data || typeof data !== "object" || Array.isArray(data)) {
-                console.warn("[SSE] 忽略非对象事件");
-                return;
-            }
-            if (data.status === "success" || data.status === "error") {
-                // 先保存最终结果，UI 更新回调即使异常也不能丢失服务端结果。
-                finalResult = data;
-                currentIdleTimeout = IDLE_TIMEOUT_GRACE;
-            }
-            try {
-                onProgress?.(data);
-            } catch (callbackError) {
-                console.warn("[SSE] 进度回调失败");
-            }
-        };
-        const processSSEText = async (text, flush = false) => {
-            let start = 0, end;
-            while ((end = text.indexOf("\n", start)) !== -1) {
-                if (++lineCount > API.SSE_MAX_LINES) throw limitError();
-                appendLinePart(text.slice(start, end));
-                processSSELine(takeLine());
-                start = end + 1;
-                workLines++;
-                await yieldIfNeeded();
-            }
-            appendLinePart(text.slice(start));
-            if (flush && lineParts.length) {
-                if (++lineCount > API.SSE_MAX_LINES) throw limitError();
-                processSSELine(takeLine());
-            }
-        };
-        while (true) {
-            // 使用 Promise.race 实现空闲超时：reader.read() 与空闲定时器竞争
-            const idlePromise = new Promise((_, reject) => {
-                idleTimer = setTimeout(() => reject(new Error("SSE_IDLE_TIMEOUT")), currentIdleTimeout);
-            });
-
-            let readResult;
-            try {
-                readResult = await Promise.race([
-                    reader.read(),
-                    idlePromise
-                ]);
-            } catch (e) {
-                clearIdleTimer();
-                if (e.message === "SSE_IDLE_TIMEOUT") {
-                    controller.abort();
-                    // 如果已收到 finalResult，优先返回它（服务器只是没正确关闭连接）
-                    if (finalResult) return finalResult;
-                    // 否则返回空闲超时错误
-                    return { status: "error", outcomeUnknown: true, message: t('feedback.stream_idle_timeout') };
-                }
-                throw e;
-            }
-            clearIdleTimer();
-
-            const { done, value } = readResult;
-            if (done) {
-                await processSSEText(decodeSSEChunk(), true);
-                break;
-            }
-
-            checkChunkBudget(value);
-            workBytes += value.byteLength;
-            workChunks++;
-            await processSSEText(decodeSSEChunk(value, { stream: true }));
-            await yieldIfNeeded();
-        }
-
-        return finalResult || { status: "error", outcomeUnknown: true, message: t('feedback.stream_missing_final') };
-    } catch (err) {
-        // 已收到最终事件时，后续连接关闭错误不应覆盖操作结果或触发重复提交。
-        if (finalResult) return finalResult;
-        if (err.name === "AbortError") {
-            return {
-                status: "error",
-                outcomeUnknown: true,
-                cancelRequested: !!externalSignal?.aborted,
-                message: externalSignal?.aborted ? t('feedback.request_cancelled') : t('feedback.stream_timeout_unconfirmed')
-            };
-        }
-        throw err;
-    } finally {
-        clearTimeout(globalTimer);
-        clearIdleTimer();
-        externalSignal?.removeEventListener("abort", abortFromCaller);
-        try { controller.abort(); } catch (_) {}
-        if (streamReader) {
-            try { Promise.resolve(streamReader.cancel()).catch(() => {}); } catch (_) {}
-            try { streamReader.releaseLock(); } catch (_) {}
-            streamReader = null;
-        }
-    }
-}
-
-// 导出给外部使用
-export { requestCancelManager, invalidateRelatedCache, request };
-export default request;
+                return _cachedResponse(proxyFn4(fallback.value), source);  // 返回过期缓存数据
+            }
+        }
+        // 仍无缓存，才抛异常
+        throw lastError || new Error(t('feedback.error'));
+    })();
+    
+    if (privateEntry) requestPromise.finally(() => activePrivateReads.delete(privateEntry)).catch(() => {});
+
+    if (trackCacheOwner) {
+        cacheReadOwners.set(cacheKey, requestPromise);
+        requestPromise.finally(() => {
+            if (cacheReadOwners.get(cacheKey) === requestPromise) cacheReadOwners.delete(cacheKey);
+        }).catch(() => {});
+    }
+
+    // 记录进行中的请求
+    if (trackPendingRequest) {
+        pendingRequests.set(cacheKey, requestPromise);
+        pendingRequestGuards.set(requestPromise, isRequestCacheCurrent);
+    }
+    
+    // 确保请求完成后清除去重记录
+    // 🔧 补 .catch 空处理：finally 会派生出一个新的 Promise，而它从未被返回也无人接收，
+    // 一旦请求失败（含主动撤销）就会在控制台抛 Uncaught (in promise)。
+    // 原始 requestPromise 仍在下方正常返回给调用方处理，此处只是吞掉这份重复的拒绝
+    if (trackPendingRequest) {
+        requestPromise.finally(() => {
+            if (pendingRequests.get(cacheKey) === requestPromise) pendingRequests.delete(cacheKey);
+        }).catch(() => {});
+    }
+    
+    return requestPromise;
+}
+
+// ==========================================
+// 📡 SSE 流式请求（用于安装进度等长时间操作）
+// ==========================================
+
+/**
+ * 发起 SSE 流式请求（用于安装进度等长时间操作）
+ * @param {string} endpoint - API端点路径（本地ComfyUI路径，如 /community_hub/install_tool_stream）
+ * @param {Object} body - POST请求体
+ * @param {Function} onProgress - 进度回调 ({stage, progress, message, status, data}) => void
+ * @param {Object} [options] - 可选配置 { timeout: 300000 }
+ * @returns {Promise<Object>} 最终结果事件
+ */
+export async function requestSSE(endpoint, body, onProgress, options = {}) {
+    const timeout = options.timeout || 1200000; // 20分钟全局超时（大型工具克隆需要较长时间）
+    const controller = new AbortController();
+    const globalTimer = setTimeout(() => controller.abort(), timeout);
+    const externalSignal = options.signal;
+    const abortFromCaller = () => controller.abort();
+    if (externalSignal?.aborted) controller.abort();
+    else externalSignal?.addEventListener("abort", abortFromCaller, { once: true });
+
+    // ���� 空闲超时检测：长时间无数据视为连接已断
+    const IDLE_TIMEOUT_DEFAULT = 30000;  // 30 秒无数据视为空闲
+    const IDLE_TIMEOUT_GRACE = 5000;     // 收到 finalResult 后的宽限期 5 秒
+    let currentIdleTimeout = options.idleTimeout || IDLE_TIMEOUT_DEFAULT;
+    let idleTimer = null;
+    let finalResult = null;
+    let streamReader = null;
+
+    const clearIdleTimer = () => {
+        if (idleTimer !== null) {
+            clearTimeout(idleTimer);
+            idleTimer = null;
+        }
+    };
+
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal
+        });
+
+        if (!response.ok) {
+            const error = withRequestDiagnostic(new Error(t('feedback.http_request_failed', { status: response.status })), response);
+            error.status = response.status;
+            // 仅当流式路由明确不存在/不接受该方法时，调用方可安全回退到旧端点。
+            // 网络错误、超时和服务端错误都可能发生在操作已开始后，不可自动重发。
+            error.fallbackSafe = response.status === 404 || response.status === 405;
+            throw error;
+        }
+
+        const reader = streamReader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8', { fatal: true });
+        const decodeSSEChunk = (value, options) => {
+            try {
+                return decoder.decode(value, options);
+            } catch (_) {
+                const error = new Error(t('feedback.stream_invalid_encoding'));
+                error.code = 'invalid_stream_encoding';
+                error.outcomeUnknown = true;
+                throw error;
+            }
+        };
+        let totalBytes = 0, lineBytes = 0, lineCount = 0;
+        let workBytes = 0, workLines = 0, workChunks = 0;
+        const lineParts = [];
+        const limitError = () => {
+            const error = new Error(t('feedback.stream_limit_exceeded'));
+            error.code = 'stream_limit_exceeded';
+            error.outcomeUnknown = true;
+            return error;
+        };
+        const appendLinePart = (part) => {
+            if (!part) return;
+            let level = 0;
+            while (lineParts[level] !== undefined) {
+                part = lineParts[level] + part;
+                lineParts[level++] = undefined;
+            }
+            lineParts[level] = part;
+        };
+        const takeLine = () => {
+            const line = lineParts.slice().reverse().filter(part => part !== undefined).join('');
+            lineParts.length = 0;
+            return line;
+        };
+        const yieldIfNeeded = async () => {
+            if (workBytes >= API.SSE_YIELD_BYTES || workLines >= API.SSE_YIELD_LINES || workChunks >= API.SSE_YIELD_CHUNKS) {
+                workBytes = workLines = workChunks = 0;
+                await new Promise(resolve => setTimeout(resolve, 0));
+            }
+            if (controller.signal.aborted) throw new DOMException('Aborted', 'AbortError');
+        };
+        const checkChunkBudget = (value) => {
+            totalBytes += value.byteLength;
+            if (totalBytes > API.SSE_MAX_RESPONSE_BYTES) throw limitError();
+            let start = 0, end;
+            while ((end = value.indexOf(10, start)) !== -1) {
+                lineBytes += end - start;
+                if (lineBytes > API.SSE_MAX_LINE_BYTES) throw limitError();
+                lineBytes = 0;
+                start = end + 1;
+            }
+            lineBytes += value.byteLength - start;
+            if (lineBytes > API.SSE_MAX_LINE_BYTES) throw limitError();
+        };
+        const processSSELine = (line) => {
+            if (!line.startsWith("data: ")) return;
+            let data;
+            try {
+                data = JSON.parse(line.slice(6));
+            } catch (_) {
+                console.warn("[SSE] 解析事件失败");
+                return;
+            }
+            if (!data || typeof data !== "object" || Array.isArray(data)) {
+                console.warn("[SSE] 忽略非对象事件");
+                return;
+            }
+            if (data.status === "success" || data.status === "error") {
+                // 先保存最终结果，UI 更新回调即使异常也不能丢失服务端结果。
+                finalResult = data;
+                currentIdleTimeout = IDLE_TIMEOUT_GRACE;
+            }
+            try {
+                onProgress?.(data);
+            } catch (callbackError) {
+                console.warn("[SSE] 进度回调失败");
+            }
+        };
+        const processSSEText = async (text, flush = false) => {
+            let start = 0, end;
+            while ((end = text.indexOf("\n", start)) !== -1) {
+                if (++lineCount > API.SSE_MAX_LINES) throw limitError();
+                appendLinePart(text.slice(start, end));
+                processSSELine(takeLine());
+                start = end + 1;
+                workLines++;
+                await yieldIfNeeded();
+            }
+            appendLinePart(text.slice(start));
+            if (flush && lineParts.length) {
+                if (++lineCount > API.SSE_MAX_LINES) throw limitError();
+                processSSELine(takeLine());
+            }
+        };
+        while (true) {
+            // 使用 Promise.race 实现空闲超时：reader.read() 与空闲定时器竞争
+            const idlePromise = new Promise((_, reject) => {
+                idleTimer = setTimeout(() => reject(new Error("SSE_IDLE_TIMEOUT")), currentIdleTimeout);
+            });
+
+            let readResult;
+            try {
+                readResult = await Promise.race([
+                    reader.read(),
+                    idlePromise
+                ]);
+            } catch (e) {
+                clearIdleTimer();
+                if (e.message === "SSE_IDLE_TIMEOUT") {
+                    controller.abort();
+                    // 如果已收到 finalResult，优先返回它（服务器只是没正确关闭连接）
+                    if (finalResult) return finalResult;
+                    // 否则返回空闲超时错误
+                    return { status: "error", outcomeUnknown: true, message: t('feedback.stream_idle_timeout') };
+                }
+                throw e;
+            }
+            clearIdleTimer();
+
+            const { done, value } = readResult;
+            if (done) {
+                await processSSEText(decodeSSEChunk(), true);
+                break;
+            }
+
+            checkChunkBudget(value);
+            workBytes += value.byteLength;
+            workChunks++;
+            await processSSEText(decodeSSEChunk(value, { stream: true }));
+            await yieldIfNeeded();
+        }
+
+        return finalResult || { status: "error", outcomeUnknown: true, message: t('feedback.stream_missing_final') };
+    } catch (err) {
+        // 已收到最终事件时，后续连接关闭错误不应覆盖操作结果或触发重复提交。
+        if (finalResult) return finalResult;
+        if (err.name === "AbortError") {
+            return {
+                status: "error",
+                outcomeUnknown: true,
+                cancelRequested: !!externalSignal?.aborted,
+                message: externalSignal?.aborted ? t('feedback.request_cancelled') : t('feedback.stream_timeout_unconfirmed')
+            };
+        }
+        throw err;
+    } finally {
+        clearTimeout(globalTimer);
+        clearIdleTimer();
+        externalSignal?.removeEventListener("abort", abortFromCaller);
+        try { controller.abort(); } catch (_) {}
+        if (streamReader) {
+            try { Promise.resolve(streamReader.cancel()).catch(() => {}); } catch (_) {}
+            try { streamReader.releaseLock(); } catch (_) {}
+            streamReader = null;
+        }
+    }
+}
+
+// 导出给外部使用
+export { requestCancelManager, invalidateRelatedCache, request };
+export default request;

前端页面/core/网络请求_缓存管理.js

@@ -9,7 +9,7 @@
 //   - 性能优化工具.js (重导出缓存函数，保持向后兼容)
 // ==========================================
 
-import { API, CACHE } from "./全局配置.js";
+import { API, CACHE, getSidebarListCacheKey } from "./全局配置.js";
 
 // ==========================================
 // 📦 缓存底层实现
@@ -33,6 +33,53 @@ const memoryCache = new Map();
 const memoryCacheOrder = []; // LRU 顺序追踪
 const memoryOnlyEntries = new WeakSet();
 
+let cacheClearToken = {};
+const cacheWriteScopes = [
+    ...[...CACHE.RESOURCE_LIST_PREFIXES, getSidebarListCacheKey('creators', '')].map(prefix =>
+        ({ prefix, matches: key => key.startsWith(prefix), token: {} })),
+    ...API.PUBLIC_CONDITIONAL_GET_PATHS.map(path => {
+        const prefix = `api_${path}`;
+        return { prefix, matches: key => key.split(/[?#]/)[0] === prefix, token: {} };
+    })
+];
+
+function _cacheScopeKey(key) {
+    return typeof key === 'string' && key.startsWith(CACHE_PREFIX) ? key.slice(CACHE_PREFIX.length) : key;
+}
+
+export function captureCacheWrite(key) {
+    const normalized = key;
+    const scope = typeof normalized === 'string' ? cacheWriteScopes.find(item => item.matches(normalized)) : null;
+    const token = scope?.token, clearToken = cacheClearToken;
+    return () => cacheClearToken === clearToken && (!scope || scope.token === token);
+}
+
+function _revokeCacheWrites(keys, prefix = false) {
+    const normalized = (prefix ? keys.map(_cacheScopeKey) : keys).filter(key => typeof key === 'string' && key.length > 0);
+    for (const scope of cacheWriteScopes) {
+        if (normalized.some(key => scope.matches(key) || (prefix && scope.prefix.startsWith(key)))) scope.token = {};
+    }
+}
+
+export function captureCacheSource(key) {
+    const fk = _fullKey(key), cached = memoryCache.get(fk);
+    if (!_isValidCacheEntry(cached)) return null;
+    const isAvailable = () => memoryCache.get(fk) === cached && _isValidCacheEntry(cached);
+    const isFresh = () => isAvailable() && !_isExpired(cached);
+    return {
+        isAvailable,
+        isFresh,
+        copyTo(targetKey, value) {
+            const normalized = targetKey;
+            if (!isFresh() || typeof normalized !== 'string' ||
+                    !CACHE.RESOURCE_LIST_PREFIXES.concat(getSidebarListCacheKey('creators', '')).some(prefix => normalized.startsWith(prefix))) return false;
+            _storeCache(normalized, value, cached.expireAt, true, {});
+            return true;
+        }
+    };
+}
+
+
 /**
  * 生成完整缓存键（带前缀）
  * @param {string} key - 原始键
@@ -116,8 +163,11 @@ function _safeStorageWrite(fullKey, jsonStr) {
  * @param {{etag?: string}} metadata - 可选的正文验证器，与value一同失效
  */
 export function setCache(key, value, ttl = DEFAULT_TTL, persist = true, metadata = {}) {
+    _storeCache(key, value, Date.now() + ttl, persist, metadata);
+}
+
+function _storeCache(key, value, expireAt, persist, metadata) {
     const fk = _fullKey(key);
-    const expireAt = Date.now() + ttl;
     const cacheData = { schemaVersion: CACHE_SCHEMA_VERSION, value, expireAt, lastAccessAt: Date.now() };
     memoryOnlyEntries.add(cacheData);
     if (typeof metadata?.etag === "string" && API.CONDITIONAL_ETAG_PATTERN.test(metadata.etag)) cacheData.etag = metadata.etag;
@@ -378,6 +428,7 @@ function _enforceStorageBudget(protectedKey = null) {
  * @param {string} key - 缓存键
  */
 export function removeCache(key) {
+    _revokeCacheWrites([key]);
     const fk = _fullKey(key);
     _deleteMemoryEntry(fk);
     try {
@@ -403,6 +454,7 @@ export function removeCacheByPrefix(prefix) {
 }
 
 function _removeCacheByPrefixes(prefixes) {
+    _revokeCacheWrites(prefixes, true);
     const candidates = [...new Set(prefixes.flatMap(prefix =>
         prefix.startsWith(CACHE_PREFIX) ? [prefix] : [_fullKey(prefix), prefix]))];
     const isMatch = (key) => candidates.some(p => key.startsWith(p));
@@ -437,6 +489,7 @@ function _removeCacheByPrefixes(prefixes) {
  * 清除所有缓存
  */
 export function clearAllCache() {
+    cacheClearToken = {};
     memoryCache.clear();
     memoryCacheOrder.length = 0;
     storageUsageBytes = null;

前端页面/market/Skill安装流程.js

@@ -194,11 +194,11 @@ export async function runSkillInstall({ target, credentials, scope, confirm, onP
         let result;
         try { result = await stream('commit'); }
         catch (error) {
-            if (error?.fallbackSafe) return { status: 'error', error_code: 'local_update_required', outcomeUnknown: false };
+            if (error?.fallbackSafe) return { status: 'error', error_code: 'local_update_required', outcomeUnknown: false, plan_id: plan };
         }
-        if (confirmed(result, ready.installed_version)) return result;
+        if (confirmed(result, ready.installed_version)) return { ...result, plan_id: plan };
         if (object(result) && result.status === 'error' && result.outcomeUnknown === false
-                && typeof result.error_code === 'string') return result;
+                && typeof result.error_code === 'string') return { ...result, plan_id: plan };
         if (scope.isCurrent() && !signal.aborted) {
             try {
                 onProgress?.({ stage: 'validate', progress: 99, skillAction: 'status' });
@@ -207,7 +207,7 @@ export async function runSkillInstall({ target, credentials, scope, confirm, onP
                         && confirmed(receipt, ready.installed_version)) return receipt;
             } catch {}
         }
-        return { status: 'error', outcomeUnknown: true };
+        return { status: 'error', outcomeUnknown: true, plan_id: plan };
     } catch (error) {
         throw failure(error?.fallbackSafe ? 'local_update_required' : error?.code || 'install_failed');
     } finally {

前端页面/market/发布内容_提交引擎.js

@@ -1,311 +1,311 @@
-import { processImageCore as _processImageCore } from "./有界图片处理.js";
-import { validateImageFile } from "./图片文件检查.js";
-import { IMAGE_PROCESS, TYPE_RULES } from "../core/全局配置.js";
-// 前端页面/market/发布内容_提交引擎.js
-import { createPublishSubmissionScope } from "./发布提交生命周期.js";
-import { api } from "../core/网络请求API.js";
-import { showToast } from "../components/UI交互提示组件.js";
-import { t } from "../components/用户体验增强.js";
-import { removeCache, removeCacheByPrefix } from "../components/性能优化工具.js";
-
-/**
- * 📋 获取指定主类型的提交规则（校验与字段组装统一读取，与 UI 显隐同源）
- * @param {string} mainType - 主类型: tool/skill/app/recommend
- */
-function getSubmitRules(mainType) {
-    return TYPE_RULES[mainType] || TYPE_RULES.tool;
-}
-
-/**
- * 🟢 根据发布类型清除对应缓存（精确清除，不影响其他页面）
- * @param {string} type - 发布类型: tool/skill/app/recommend/recommend_tool/recommend_skill/recommend_app/recommend_link
- */
-function clearItemCacheByType(type) {
-    // 确定当前类型对应的 tab
-    let tab = 'recommends';
-    if (type === 'tool' || type === 'recommend_tool') {
-        tab = 'tools';
-    } else if (type === 'skill' || type === 'recommend_skill') {
-        tab = 'skills';
-    } else if (type === 'app' || type === 'recommend_app') {
-        tab = 'apps';
-    }
-    
-    // 清除 API 缓存
-    // 🔧 修复：API 层缓存键总是带完整查询串（api_/api/items?type=tool&sort=time&limit=200），
-    // 而 removeCache 是精确键删除，原先这几个调用一个也命中不到（no-op），发布成功后
-    // request() 仍会从缓存直接返回旧列表、看不到刚发布的内容。改用前缀删除，
-    // 一次覆盖全部 type/sort/limit 组合（原先按 type 单独删的那行已被本前缀覆盖，属冗余）
-    removeCacheByPrefix('api_/api/items');
-    removeCacheByPrefix('api_/api/creators');  // 创作者列表也需要刷新
-    
-    // 清除侧边栏数据引擎缓存（只清除对应类型）
-    const sorts = ['time', 'downloads', 'likes', 'favorites', 'tips', 'views', 'daily_views', 'rating'];
-    for (const sort of sorts) {
-        removeCache(`ListCache_${tab}_${sort}`);
-        removeCache(`ListCache_creators_${sort}`);  // 创作者列表
-    }
-    
-    console.log(`🗑️ 已清除 [${tab}] 类型的列表缓存`);
-}
-
-/**
- * 🟢 利用 HTML5 Canvas 纯前端裁剪并压缩头像
- * 功能：强制 1:1 比例中心裁剪，缩放到 512x512，转换为 JPG 格式。
- */
-function processAvatar(file) {
-    return _processImageCore(file, {
-        cropToSquare: true,
-        maxFileSize: IMAGE_PROCESS.AVATAR_MAX_BYTES,
-        targetSize: IMAGE_PROCESS.AVATAR_SIZE,
-        quality: 0.85,
-        suffix: '_cropped.jpg'
-    }).then(processedFile => {
-        console.log(`✅ 头像处理完成：原始 ${(file.size/1024).toFixed(1)}KB -> 压缩后 ${(processedFile.size/1024).toFixed(1)}KB`);
-        return processedFile;
-    });
-}
-
-/**
- * 上传前图片压缩处理
- * - 转为 JPG 格式
- * - 最长边至多4096并保持比例；质量压缩后仍超过5MB则拒绝
- * @param {File} file - 原始图片文件
- * @returns {Promise<File>} - 处理后的文件
- */
-export async function compressImageForUpload(file) {
-    // 如果不是图片文件，直接返回
-    if (!file.type || !file.type.startsWith('image/')) {
-        return file;
-    }
-
-    if (!Number.isFinite(file.size) || file.size < 0 || file.size > IMAGE_PROCESS.MAX_INPUT_BYTES) {
-        throw new Error('Image exceeds upload budget');
-    }
-    // 动图保持原格式；不由Canvas变为静态图片。
-    if (file.type === 'image/gif') { await validateImageFile(file); return file; }
-    return _processImageCore(file, {
-        quality: 0.92, fillBackground: '#FFFFFF', maxFileSize: IMAGE_PROCESS.MAX_OUTPUT_BYTES,
-        skipIfSmallJpeg: true, suffix: '.jpg'
-    });
-}
-
-/**
- * 🟢 新增：全局统一的文件上传包装器（供个人设置等其它组件调用）
- * 会在上传前自动拦截并处理头像图片
- */
-export async function uploadFile(file, file_type, options = {}) {
-    const current = options.isCurrent || (() => true);
-    const feedback = (message, level) => { if (!options.silent && current()) showToast(message, level); };
-    if (!current()) return null;
-    try {
-        let fileToUpload = file;
-        
-        // 拦截点：如果是头像，就在纯内存中先进行裁剪、缩放、压缩
-        if (file_type === "avatar" && file.type && file.type.startsWith("image/")) {
-            feedback(`🖼️ ${t('publish.processing_avatar')}`);
-            fileToUpload = await processAvatar(file);
-        }
-
-        feedback(`🌐 ${t('publish.uploading_file', { size: (fileToUpload.size/1024).toFixed(1) })}`);
-        if (!current()) return null;
-        const res = await api.uploadFile(fileToUpload, file_type);
-        
-        if (!current()) return null;
-        if (res.status === "success") {
-            feedback(`✅ ${t('publish.upload_success')}`);
-            return res.url; 
-        } else {
-            feedback(t('publish.upload_failed'), 'error');
-            return null;
-        }
-    } catch (error) {
-        feedback(t('publish.upload_error'), 'error');
-        return null;
-    }
-}
-
-// ==========================================
-// 发布表单提交：原会话范围与保存结果核实
-// ==========================================
-export async function handlePublishSubmit(params) {
-    const {
-        container, currentUser, isEditMode, editItemData,
-        imageFiles, jsonFile, onSuccessCallback, submitBtn, submitBtnText  // 🖼️ imageFiles 替换 coverFile
-    } = params;
-
-    const scope = params.submissionScope || createPublishSubmissionScope(container, submitBtn, currentUser?.account);
-    if (!scope.isCurrent()) return;
-    const expectedRevision = isEditMode ? (editItemData?.edit_revision === undefined ? 0 : editItemData.edit_revision) : null;
-    if (isEditMode && (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0)) {
-        showToast(t('common.operation_failed'), 'error'); return;
-    }
-    const selectedImages = Array.from(imageFiles || []);
-    const typeSelect = container.querySelector("#pub-type");
-    const recommendTypeSelect = container.querySelector("#pub-recommend-type");
-    const resTypeSelect = container.querySelector("#pub-resource-type");
-    const boxPrivateRepo = container.querySelector("#private-repo-settings");
-    const isPrivateCheck = container.querySelector("#pub-is-private");
-    const inputLink = container.querySelector("#pub-link");
-    const inputNetdiskLink = container.querySelector("#pub-netdisk-link");  // ☁️ 网盘链接
-    const inputNetdiskPassword = container.querySelector("#pub-netdisk-password");  // 🔐 网盘密码
-
-    const mainType = typeSelect.value;
-    const rules = getSubmitRules(mainType);  // 📋 本次提交的声明式规则
-    let type = mainType;
-    if (mainType === "recommend") type = recommendTypeSelect.value;
-    
-    const title = container.querySelector("#pub-title").value.trim();
-    const shortDesc = container.querySelector("#pub-short").value.trim();
-    const fullDesc = container.querySelector("#pub-full").value.trim();
-    const price = rules.price ? Number(container.querySelector("#pub-price").value) : 0;
-    if (!Number.isSafeInteger(price) || price < 0) return showToast(t('common.operation_failed'), "warning");
-    
-    let finalLink = inputLink.value.trim();
-    let isJsonUpload = (resTypeSelect.value === "json") || (type === "recommend_app");
-    let isNetdisk = (resTypeSelect.value === "netdisk");  // ☁️ 是否网盘模式
-    
-    // ☁️ 网盘模式下使用网盘链接
-    if (isNetdisk) {
-        finalLink = inputNetdiskLink.value.trim();
-    }
-
-    if (isEditMode && isJsonUpload && !jsonFile && editItemData.link) finalLink = editItemData.link;
-
-    // ☁️ 网盘密码（加密存储，仅购买后解密显示）
-    let netdisk_password = null;
-    if (isNetdisk && inputNetdiskPassword.value.trim()) {
-        netdisk_password = inputNetdiskPassword.value.trim();
-    }
-
-    let github_token = null;
-    // 📋 仅规则允许私有仓库且该区可见、已勾选时才收集 token
-    if (rules.privateRepoWhenLink && boxPrivateRepo.style.display !== "none" && isPrivateCheck.checked) {
-        github_token = container.querySelector("#pub-github-token").value.trim();
-        if (!github_token) {
-            const hasExistingToken = isEditMode && !!(editItemData?.github_token || editItemData?.has_private_token);
-            if (isEditMode && hasExistingToken) {
-                // 编辑模式下已有密钥，留空表示保留原值，不发送 github_token 字段
-                github_token = null;
-            } else {
-                return showToast(t('publish.pat_required'), "warning");
-            }
-        }
-    }
-
-    if (!title || !shortDesc) return showToast(t('publish.name_desc_required'), "warning");
-    if (type === "recommend_link" && !finalLink) return showToast(t('publish.link_required'), "warning");
-    if ((type === "tool" || type === "skill" || type === "recommend_tool" || type === "recommend_skill") && !isJsonUpload && !isNetdisk && !finalLink) return showToast(t('publish.git_required'), "warning");
-    if (isJsonUpload && !jsonFile && !finalLink) return showToast(t('publish.json_required'), "warning");
-    if (isNetdisk && !finalLink) return showToast(t('publish.netdisk_required'), "warning");  // ☁️
-    
-    // 🎨 规则要求原创强制的类型必须勾选原创
-    const isOriginalCheckbox = container.querySelector("#is-original-checkbox");
-    const isOriginal = isOriginalCheckbox?.checked || false;
-    if (rules.originalRequired && !isOriginal) {
-        return showToast(t('publish.original_required_toast'), "warning");
-    }
-
-    // 💸 是否支持退款 (仅规则允许的类型提交)
-    const allowRefundCheckbox = container.querySelector("#allow-refund-checkbox");
-    const allowRefund = rules.refund ? (allowRefundCheckbox?.checked ?? true) : null;
-
-    if (!scope.begin()) return;
-    let committed = false, saveAttempted = false, outcomeUnknown = false;
-    submitBtn.innerHTML = `⏳ ${t('publish.connecting')}`;
-    submitBtn.disabled = true; 
-
-    try {
-        if (isJsonUpload && jsonFile) {
-            submitBtn.innerHTML = `⏳ ${t('publish.uploading_secure')}`;
-            const uploadType = type.includes("app") ? "app" : (type.includes("tool") || type === "skill" ? "tool" : "recommend");
-            const jsonUploadRes = await api.uploadFile(jsonFile, uploadType);
-            if (!scope.isCurrent()) return;
-            if (jsonUploadRes?.status !== "success" || typeof jsonUploadRes.url !== "string" || !jsonUploadRes.url.trim()) throw new Error("Invalid upload result");
-            finalLink = jsonUploadRes.url; 
-        }
-
-        // 🖼️ 上传多张效果展示图
-        let coverUrl = isEditMode ? editItemData.coverUrl : null;
-        let imageUrls = isEditMode ? (editItemData.imageUrls || []) : [];
-        
-        if (selectedImages.length > 0) {
-            submitBtn.innerHTML = `⏳ ${t('publish.uploading_images', { current: 0, total: selectedImages.length })}`;
-            const uploadedUrls = [];
-            
-            for (let i = 0; i < selectedImages.length; i++) {
-                submitBtn.innerHTML = `⏳ ${t('publish.uploading_images', { current: i + 1, total: selectedImages.length })}`;
-                // 上传前压缩：转JPG，超5MB压缩
-                const processedFile = await compressImageForUpload(selectedImages[i]);
-                if (!scope.isCurrent()) return;
-                const uploadRes = await api.uploadFile(processedFile, "cover");
-                if (!scope.isCurrent()) return;
-                if (uploadRes?.status === "success" && typeof uploadRes.url === "string" && uploadRes.url.trim()) {
-                    uploadedUrls.push(uploadRes.url);
-                } else {
-                    throw new Error("Invalid image upload result");
-                }
-            }
-            
-            coverUrl = uploadedUrls[0];  // 第一张作为封面
-            imageUrls = uploadedUrls;     // 全部图片URL
-        }
-
-        if (!scope.isCurrent()) return;
-        submitBtn.innerHTML = `⏳ ${t('publish.syncing')}`;
-        // 🖼️ 统一封面逻辑：第一张图片始终作为封面（兑容拖拽排序后的顺序变化）
-        if (imageUrls && imageUrls.length > 0) {
-            coverUrl = imageUrls[0];
-        }
-        const submitData = {
-            ...(!isEditMode && scope.publicationId ? { request_id: scope.publicationId } : {}),
-            ...(isEditMode ? { expected_revision: expectedRevision } : {}),
-            type, title, shortDesc, fullDesc, price, link: finalLink, coverUrl, imageUrls,  // 🖼️ 添加 imageUrls
-            author: currentUser.account, github_token,
-            netdisk_password,  // ☁️ 网盘密码（后端加密存储）
-            is_netdisk: isNetdisk,  // ☁️ 标记为网盘资源
-            is_original: isOriginal  // 🎨 标记为原创作品
-        };
-
-        // 💸 仅 tool/skill/app 类型提交 allow_refund 字段
-        if (allowRefund !== null) {
-            submitData.allow_refund = allowRefund;
-        }
-
-        saveAttempted = true;
-        const result = isEditMode
-            ? await api.updateItem(editItemData.id, currentUser.account, submitData)
-            : await api.publishItem(submitData);
-        if (!scope.isCurrent()) return;
-        if (result?.status !== "success") throw new Error("Invalid save result");
-        committed = true;
-        showToast(isEditMode ? `✅ ${t('publish.save_success')}` : `🎉 ${t('publish.publish_success')}`, "success");
-        // 主保存已确认；派生缓存或界面回调异常不重新开放提交。
-        try { clearItemCacheByType(type); } catch (_) {}
-        if (scope.isCurrent() && onSuccessCallback) {
-            try { await onSuccessCallback(); } catch (_) {}
-        }
-    } catch (err) {
-        if (!scope.isCurrent() || committed) return;
-        if (isEditMode && err?.status === 409 && err?.code === 'resource_revision_conflict') {
-            outcomeUnknown = true; // 保持入口锁，要求重开取得新版本；不自动覆盖。
-            showToast(t('publish.edit_conflict'), 'warning');
-            submitBtn.disabled = true; submitBtn.innerHTML = t('publish.edit_reopen');
-            return;
-        }
-        // 已发出的保存可能在服务端提交；仅已知前置拒绝允许原表单重试。
-        const rejected = (err?.requestBodyRejected === true || [400, 401, 403, 404, 409, 422, 429].includes(err?.status));
-        outcomeUnknown = saveAttempted && !rejected;
-        if (outcomeUnknown) {
-            showToast(t('publish.save_unconfirmed'), "warning");
-            submitBtn.disabled = true;
-            submitBtn.innerHTML = t('publish.result_pending');
-            return;
-        }
-        showToast(t('common.operation_failed'), "error");
-        submitBtn.disabled = false;
-        submitBtn.innerHTML = submitBtnText;
-    } finally {
-        scope.finish(committed, outcomeUnknown);
-    }
-}
+import { processImageCore as _processImageCore } from "./有界图片处理.js";
+import { validateImageFile } from "./图片文件检查.js";
+import { IMAGE_PROCESS, TYPE_RULES, getSidebarListCacheKey } from "../core/全局配置.js";
+// 前端页面/market/发布内容_提交引擎.js
+import { createPublishSubmissionScope } from "./发布提交生命周期.js";
+import { api } from "../core/网络请求API.js";
+import { showToast } from "../components/UI交互提示组件.js";
+import { t } from "../components/用户体验增强.js";
+import { removeCache, removeCacheByPrefix } from "../components/性能优化工具.js";
+
+/**
+ * 📋 获取指定主类型的提交规则（校验与字段组装统一读取，与 UI 显隐同源）
+ * @param {string} mainType - 主类型: tool/skill/app/recommend
+ */
+function getSubmitRules(mainType) {
+    return TYPE_RULES[mainType] || TYPE_RULES.tool;
+}
+
+/**
+ * 🟢 根据发布类型清除对应缓存（精确清除，不影响其他页面）
+ * @param {string} type - 发布类型: tool/skill/app/recommend/recommend_tool/recommend_skill/recommend_app/recommend_link
+ */
+function clearItemCacheByType(type) {
+    // 确定当前类型对应的 tab
+    let tab = 'recommends';
+    if (type === 'tool' || type === 'recommend_tool') {
+        tab = 'tools';
+    } else if (type === 'skill' || type === 'recommend_skill') {
+        tab = 'skills';
+    } else if (type === 'app' || type === 'recommend_app') {
+        tab = 'apps';
+    }
+    
+    // 清除 API 缓存
+    // 🔧 修复：API 层缓存键总是带完整查询串（api_/api/items?type=tool&sort=time&limit=200），
+    // 而 removeCache 是精确键删除，原先这几个调用一个也命中不到（no-op），发布成功后
+    // request() 仍会从缓存直接返回旧列表、看不到刚发布的内容。改用前缀删除，
+    // 一次覆盖全部 type/sort/limit 组合（原先按 type 单独删的那行已被本前缀覆盖，属冗余）
+    removeCacheByPrefix('api_/api/items');
+    removeCacheByPrefix('api_/api/creators');  // 创作者列表也需要刷新
+    
+    // 清除侧边栏数据引擎缓存（只清除对应类型）
+    const sorts = ['time', 'downloads', 'likes', 'favorites', 'tips', 'views', 'daily_views', 'rating'];
+    for (const sort of sorts) {
+        removeCache(getSidebarListCacheKey(tab, sort));
+        removeCache(getSidebarListCacheKey('creators', sort));  // 创作者列表
+    }
+    
+    console.log(`🗑️ 已清除 [${tab}] 类型的列表缓存`);
+}
+
+/**
+ * 🟢 利用 HTML5 Canvas 纯前端裁剪并压缩头像
+ * 功能：强制 1:1 比例中心裁剪，缩放到 512x512，转换为 JPG 格式。
+ */
+function processAvatar(file) {
+    return _processImageCore(file, {
+        cropToSquare: true,
+        maxFileSize: IMAGE_PROCESS.AVATAR_MAX_BYTES,
+        targetSize: IMAGE_PROCESS.AVATAR_SIZE,
+        quality: 0.85,
+        suffix: '_cropped.jpg'
+    }).then(processedFile => {
+        console.log(`✅ 头像处理完成：原始 ${(file.size/1024).toFixed(1)}KB -> 压缩后 ${(processedFile.size/1024).toFixed(1)}KB`);
+        return processedFile;
+    });
+}
+
+/**
+ * 上传前图片压缩处理
+ * - 转为 JPG 格式
+ * - 最长边至多4096并保持比例；质量压缩后仍超过5MB则拒绝
+ * @param {File} file - 原始图片文件
+ * @returns {Promise<File>} - 处理后的文件
+ */
+export async function compressImageForUpload(file) {
+    // 如果不是图片文件，直接返回
+    if (!file.type || !file.type.startsWith('image/')) {
+        return file;
+    }
+
+    if (!Number.isFinite(file.size) || file.size < 0 || file.size > IMAGE_PROCESS.MAX_INPUT_BYTES) {
+        throw new Error('Image exceeds upload budget');
+    }
+    // 动图保持原格式；不由Canvas变为静态图片。
+    if (file.type === 'image/gif') { await validateImageFile(file); return file; }
+    return _processImageCore(file, {
+        quality: 0.92, fillBackground: '#FFFFFF', maxFileSize: IMAGE_PROCESS.MAX_OUTPUT_BYTES,
+        skipIfSmallJpeg: true, suffix: '.jpg'
+    });
+}
+
+/**
+ * 🟢 新增：全局统一的文件上传包装器（供个人设置等其它组件调用）
+ * 会在上传前自动拦截并处理头像图片
+ */
+export async function uploadFile(file, file_type, options = {}) {
+    const current = options.isCurrent || (() => true);
+    const feedback = (message, level) => { if (!options.silent && current()) showToast(message, level); };
+    if (!current()) return null;
+    try {
+        let fileToUpload = file;
+        
+        // 拦截点：如果是头像，就在纯内存中先进行裁剪、缩放、压缩
+        if (file_type === "avatar" && file.type && file.type.startsWith("image/")) {
+            feedback(`🖼️ ${t('publish.processing_avatar')}`);
+            fileToUpload = await processAvatar(file);
+        }
+
+        feedback(`🌐 ${t('publish.uploading_file', { size: (fileToUpload.size/1024).toFixed(1) })}`);
+        if (!current()) return null;
+        const res = await api.uploadFile(fileToUpload, file_type);
+        
+        if (!current()) return null;
+        if (res.status === "success") {
+            feedback(`✅ ${t('publish.upload_success')}`);
+            return res.url; 
+        } else {
+            feedback(t('publish.upload_failed'), 'error');
+            return null;
+        }
+    } catch (error) {
+        feedback(t('publish.upload_error'), 'error');
+        return null;
+    }
+}
+
+// ==========================================
+// 发布表单提交：原会话范围与保存结果核实
+// ==========================================
+export async function handlePublishSubmit(params) {
+    const {
+        container, currentUser, isEditMode, editItemData,
+        imageFiles, jsonFile, onSuccessCallback, submitBtn, submitBtnText  // 🖼️ imageFiles 替换 coverFile
+    } = params;
+
+    const scope = params.submissionScope || createPublishSubmissionScope(container, submitBtn, currentUser?.account);
+    if (!scope.isCurrent()) return;
+    const expectedRevision = isEditMode ? (editItemData?.edit_revision === undefined ? 0 : editItemData.edit_revision) : null;
+    if (isEditMode && (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0)) {
+        showToast(t('common.operation_failed'), 'error'); return;
+    }
+    const selectedImages = Array.from(imageFiles || []);
+    const typeSelect = container.querySelector("#pub-type");
+    const recommendTypeSelect = container.querySelector("#pub-recommend-type");
+    const resTypeSelect = container.querySelector("#pub-resource-type");
+    const boxPrivateRepo = container.querySelector("#private-repo-settings");
+    const isPrivateCheck = container.querySelector("#pub-is-private");
+    const inputLink = container.querySelector("#pub-link");
+    const inputNetdiskLink = container.querySelector("#pub-netdisk-link");  // ☁️ 网盘链接
+    const inputNetdiskPassword = container.querySelector("#pub-netdisk-password");  // 🔐 网盘密码
+
+    const mainType = typeSelect.value;
+    const rules = getSubmitRules(mainType);  // 📋 本次提交的声明式规则
+    let type = mainType;
+    if (mainType === "recommend") type = recommendTypeSelect.value;
+    
+    const title = container.querySelector("#pub-title").value.trim();
+    const shortDesc = container.querySelector("#pub-short").value.trim();
+    const fullDesc = container.querySelector("#pub-full").value.trim();
+    const price = rules.price ? Number(container.querySelector("#pub-price").value) : 0;
+    if (!Number.isSafeInteger(price) || price < 0) return showToast(t('common.operation_failed'), "warning");
+    
+    let finalLink = inputLink.value.trim();
+    let isJsonUpload = (resTypeSelect.value === "json") || (type === "recommend_app");
+    let isNetdisk = (resTypeSelect.value === "netdisk");  // ☁️ 是否网盘模式
+    
+    // ☁️ 网盘模式下使用网盘链接
+    if (isNetdisk) {
+        finalLink = inputNetdiskLink.value.trim();
+    }
+
+    if (isEditMode && isJsonUpload && !jsonFile && editItemData.link) finalLink = editItemData.link;
+
+    // ☁️ 网盘密码（加密存储，仅购买后解密显示）
+    let netdisk_password = null;
+    if (isNetdisk && inputNetdiskPassword.value.trim()) {
+        netdisk_password = inputNetdiskPassword.value.trim();
+    }
+
+    let github_token = null;
+    // 📋 仅规则允许私有仓库且该区可见、已勾选时才收集 token
+    if (rules.privateRepoWhenLink && boxPrivateRepo.style.display !== "none" && isPrivateCheck.checked) {
+        github_token = container.querySelector("#pub-github-token").value.trim();
+        if (!github_token) {
+            const hasExistingToken = isEditMode && !!(editItemData?.github_token || editItemData?.has_private_token);
+            if (isEditMode && hasExistingToken) {
+                // 编辑模式下已有密钥，留空表示保留原值，不发送 github_token 字段
+                github_token = null;
+            } else {
+                return showToast(t('publish.pat_required'), "warning");
+            }
+        }
+    }
+
+    if (!title || !shortDesc) return showToast(t('publish.name_desc_required'), "warning");
+    if (type === "recommend_link" && !finalLink) return showToast(t('publish.link_required'), "warning");
+    if ((type === "tool" || type === "skill" || type === "recommend_tool" || type === "recommend_skill") && !isJsonUpload && !isNetdisk && !finalLink) return showToast(t('publish.git_required'), "warning");
+    if (isJsonUpload && !jsonFile && !finalLink) return showToast(t('publish.json_required'), "warning");
+    if (isNetdisk && !finalLink) return showToast(t('publish.netdisk_required'), "warning");  // ☁️
+    
+    // 🎨 规则要求原创强制的类型必须勾选原创
+    const isOriginalCheckbox = container.querySelector("#is-original-checkbox");
+    const isOriginal = isOriginalCheckbox?.checked || false;
+    if (rules.originalRequired && !isOriginal) {
+        return showToast(t('publish.original_required_toast'), "warning");
+    }
+
+    // 💸 是否支持退款 (仅规则允许的类型提交)
+    const allowRefundCheckbox = container.querySelector("#allow-refund-checkbox");
+    const allowRefund = rules.refund ? (allowRefundCheckbox?.checked ?? true) : null;
+
+    if (!scope.begin()) return;
+    let committed = false, saveAttempted = false, outcomeUnknown = false;
+    submitBtn.innerHTML = `⏳ ${t('publish.connecting')}`;
+    submitBtn.disabled = true; 
+
+    try {
+        if (isJsonUpload && jsonFile) {
+            submitBtn.innerHTML = `⏳ ${t('publish.uploading_secure')}`;
+            const uploadType = type.includes("app") ? "app" : (type.includes("tool") || type === "skill" ? "tool" : "recommend");
+            const jsonUploadRes = await api.uploadFile(jsonFile, uploadType);
+            if (!scope.isCurrent()) return;
+            if (jsonUploadRes?.status !== "success" || typeof jsonUploadRes.url !== "string" || !jsonUploadRes.url.trim()) throw new Error("Invalid upload result");
+            finalLink = jsonUploadRes.url; 
+        }
+
+        // 🖼️ 上传多张效果展示图
+        let coverUrl = isEditMode ? editItemData.coverUrl : null;
+        let imageUrls = isEditMode ? (editItemData.imageUrls || []) : [];
+        
+        if (selectedImages.length > 0) {
+            submitBtn.innerHTML = `⏳ ${t('publish.uploading_images', { current: 0, total: selectedImages.length })}`;
+            const uploadedUrls = [];
+            
+            for (let i = 0; i < selectedImages.length; i++) {
+                submitBtn.innerHTML = `⏳ ${t('publish.uploading_images', { current: i + 1, total: selectedImages.length })}`;
+                // 上传前压缩：转JPG，超5MB压缩
+                const processedFile = await compressImageForUpload(selectedImages[i]);
+                if (!scope.isCurrent()) return;
+                const uploadRes = await api.uploadFile(processedFile, "cover");
+                if (!scope.isCurrent()) return;
+                if (uploadRes?.status === "success" && typeof uploadRes.url === "string" && uploadRes.url.trim()) {
+                    uploadedUrls.push(uploadRes.url);
+                } else {
+                    throw new Error("Invalid image upload result");
+                }
+            }
+            
+            coverUrl = uploadedUrls[0];  // 第一张作为封面
+            imageUrls = uploadedUrls;     // 全部图片URL
+        }
+
+        if (!scope.isCurrent()) return;
+        submitBtn.innerHTML = `⏳ ${t('publish.syncing')}`;
+        // 🖼️ 统一封面逻辑：第一张图片始终作为封面（兑容拖拽排序后的顺序变化）
+        if (imageUrls && imageUrls.length > 0) {
+            coverUrl = imageUrls[0];
+        }
+        const submitData = {
+            ...(!isEditMode && scope.publicationId ? { request_id: scope.publicationId } : {}),
+            ...(isEditMode ? { expected_revision: expectedRevision } : {}),
+            type, title, shortDesc, fullDesc, price, link: finalLink, coverUrl, imageUrls,  // 🖼️ 添加 imageUrls
+            author: currentUser.account, github_token,
+            netdisk_password,  // ☁️ 网盘密码（后端加密存储）
+            is_netdisk: isNetdisk,  // ☁️ 标记为网盘资源
+            is_original: isOriginal  // 🎨 标记为原创作品
+        };
+
+        // 💸 仅 tool/skill/app 类型提交 allow_refund 字段
+        if (allowRefund !== null) {
+            submitData.allow_refund = allowRefund;
+        }
+
+        saveAttempted = true;
+        const result = isEditMode
+            ? await api.updateItem(editItemData.id, currentUser.account, submitData)
+            : await api.publishItem(submitData);
+        if (!scope.isCurrent()) return;
+        if (result?.status !== "success") throw new Error("Invalid save result");
+        committed = true;
+        showToast(isEditMode ? `✅ ${t('publish.save_success')}` : `🎉 ${t('publish.publish_success')}`, "success");
+        // 主保存已确认；派生缓存或界面回调异常不重新开放提交。
+        try { clearItemCacheByType(type); } catch (_) {}
+        if (scope.isCurrent() && onSuccessCallback) {
+            try { await onSuccessCallback(); } catch (_) {}
+        }
+    } catch (err) {
+        if (!scope.isCurrent() || committed) return;
+        if (isEditMode && err?.status === 409 && err?.code === 'resource_revision_conflict') {
+            outcomeUnknown = true; // 保持入口锁，要求重开取得新版本；不自动覆盖。
+            showToast(t('publish.edit_conflict'), 'warning');
+            submitBtn.disabled = true; submitBtn.innerHTML = t('publish.edit_reopen');
+            return;
+        }
+        // 已发出的保存可能在服务端提交；仅已知前置拒绝允许原表单重试。
+        const rejected = (err?.requestBodyRejected === true || [400, 401, 403, 404, 409, 422, 429].includes(err?.status));
+        outcomeUnknown = saveAttempted && !rejected;
+        if (outcomeUnknown) {
+            showToast(t('publish.save_unconfirmed'), "warning");
+            submitBtn.disabled = true;
+            submitBtn.innerHTML = t('publish.result_pending');
+            return;
+        }
+        showToast(t('common.operation_failed'), "error");
+        submitBtn.disabled = false;
+        submitBtn.innerHTML = submitBtnText;
+    } finally {
+        scope.finish(committed, outcomeUnknown);
+    }
+}

前端页面/market/安装目录.js

@@ -0,0 +1,72 @@
+import { LOCAL_INSTALL_DIRECTORY, SKILL_INSTALL } from '../core/全局配置.js';
+import { readLocalJSON } from '../core/本机请求读取.js';
+import { t } from '../components/用户体验_国际化.js';
+
+const mounted = new WeakMap();
+const errors = Object.freeze({
+    invalid_target: () => t('install.directory_unavailable'), target_changed: () => t('install.directory_unavailable'),
+    invalid_repository: () => t('install.error_invalid_repository'), invalid_plan: () => t('skill.plan_invalid'),
+    plan_expired: () => t('skill.plan_invalid'), plan_owner_mismatch: () => t('skill.identity_changed'),
+    auth_failed: () => t('skill.identity_changed'), install_queue_full: () => t('install.error_queue_full'),
+    install_queue_timeout: () => t('install.error_queue_timeout'),
+    directory_open_unavailable: () => t('install.directory_failed'), directory_open_failed: () => t('install.directory_failed')
+});
+
+export function attachInstallDirectory(container, body, scope, { skill = false } = {}) {
+    mounted.get(container)?.();
+    if (!scope.isCurrent() || !container.isConnected) return;
+    const payload = JSON.stringify(skill ? { ...body, action: 'open' } : body);
+    const host = document.createElement('div'); host.className = 'resource-install__directory';
+    const button = document.createElement('button'); button.type = 'button'; button.className = 'resource-install__button';
+    const label = t(skill ? 'install.open_receiver' : 'install.open_directory'); button.textContent = label;
+    const notice = document.createElement('div'); notice.className = 'resource-install__note';
+    notice.setAttribute('role', 'status'); notice.setAttribute('aria-live', 'polite');
+    let disposed = false, controller, busy = false, release = () => {};
+    const current = () => !disposed && scope.isCurrent() && host.isConnected;
+    const cleanup = () => {
+        if (disposed) return;
+        disposed = true; controller?.abort(); button.removeEventListener('click', open); host.remove(); release();
+        if (mounted.get(container) === cleanup) mounted.delete(container);
+    };
+    async function open(event) {
+        event.stopPropagation();
+        if (busy || !current()) return;
+        const hadFocus = document.activeElement === button;
+        busy = true; button.disabled = true; button.setAttribute('aria-busy', 'true');
+        button.textContent = t('common.loading'); notice.textContent = '';
+        controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), LOCAL_INSTALL_DIRECTORY.TIMEOUT);
+        try {
+            const response = await fetch(skill ? SKILL_INSTALL.PATH : LOCAL_INSTALL_DIRECTORY.PATH, {
+                method: 'POST', headers: { 'Content-Type': 'application/json' }, body: payload,
+                cache: 'no-store', signal: controller.signal
+            });
+            if (!current()) return;
+            if (response.status === 404 || response.status === 405) {
+                notice.textContent = t('skill.local_update_required'); return;
+            }
+            const result = await readLocalJSON(response, controller, LOCAL_INSTALL_DIRECTORY.RESPONSE_MAX_BYTES);
+            if (!current()) return;
+            if (response.ok && result && !Array.isArray(result) && result.status === 'success'
+                    && result.phase === 'opened' && result.opened === true && result.installed === false
+                    && !Object.hasOwn(result, 'error') && !Object.hasOwn(result, 'error_code')) {
+                notice.textContent = t('install.directory_requested');
+            } else {
+                notice.textContent = result && Object.hasOwn(errors, result.error_code) ? errors[result.error_code]()
+                    : response.ok ? t('install.directory_uncertain') : t('install.directory_failed');
+            }
+        } catch {
+            if (current()) notice.textContent = t('install.directory_uncertain');
+        } finally {
+            clearTimeout(timer); controller?.abort();
+            if (current()) {
+                busy = false; button.disabled = false; button.removeAttribute('aria-busy'); button.textContent = label;
+                if (hadFocus && document.hasFocus() && document.activeElement === document.body) button.focus();
+            }
+        }
+    }
+    button.addEventListener('click', open); host.append(button, notice); container.append(host);
+    mounted.set(container, cleanup); release = scope.addCleanup(cleanup, host);
+    if (!current()) cleanup();
+    return cleanup;
+}

前端页面/market/资源安装引擎.js

@@ -3,10 +3,11 @@ import { showToast, showConfirm, createInstallProgress } from "../components/UI
 import { api } from "../core/网络请求API.js";
 import { requestSSE, request } from "../core/网络请求_基础设施.js";
 import { openUserProfileModal } from "../profile/个人中心视图.js";
-import { API, CACHE, SKILL_INSTALL, UI, IS_WEB_MODE, escapeHtml } from "../core/全局配置.js";
+import { API, CACHE, SKILL_INSTALL, UI, IS_WEB_MODE, escapeHtml, getSidebarListCacheKey } from "../core/全局配置.js";
 import { t } from "../components/用户体验增强.js";
 import { createResourceOperationScope } from "./资源操作生命周期.js";
 import { describeInstallSource } from "./安装来源.js";
+import { attachInstallDirectory } from "./安装目录.js";
 import { isValidPurchaseStatus } from "./购买状态生命周期.js";
 import { saveAcquiredItem } from "./资源获取记录.js";
 export { getAcquiredItems } from "./资源获取记录.js";
@@ -43,7 +44,7 @@ function clearUsesCache() {
     const sorts = ['time', 'downloads', 'likes', 'favorites', 'tips', 'views', 'daily_views', 'rating'];
     for (const tab of tabs) {
         for (const sort of sorts) {
-            removeCache(`ListCache_${tab}_${sort}`);
+            removeCache(getSidebarListCacheKey(tab, sort));
         }
     }
     console.log('📊 使用量缓存已清除');
@@ -550,6 +551,7 @@ export function setupResourceInstall(btnUse, itemData, currentUser, inlineStatus
                 const controller = new AbortController();
                 const removeCancel = scope.addCleanup(() => controller.abort());
                 progress.addCancelButton(t('install.cancel_in_progress'), () => controller.abort());
+                let directoryPlan;
                 try {
                     const result = await skillFlow.runSkillInstall({
                         target: skillTarget, credentials: { account, token, item_id: String(itemData.id) }, scope,
@@ -565,6 +567,7 @@ export function setupResourceInstall(btnUse, itemData, currentUser, inlineStatus
                     });
                     if (!isCurrent()) return;
                     if (result.status === 'cancelled') { restoreFocus = true; progress.error(t('skill.cancelled')); return; }
+                    if (typeof result.plan_id === 'string' && /^[a-f0-9]{32}$/.test(result.plan_id)) directoryPlan = result.plan_id;
                     if (result.outcomeUnknown) {
                         phase = 'unknown'; btnUse.removeAttribute('aria-busy');
                         progress.error(t('skill.outcome_unknown')); return;
@@ -582,6 +585,11 @@ export function setupResourceInstall(btnUse, itemData, currentUser, inlineStatus
                     if (isCurrent()) progress.error(controller.signal.aborted ? t('skill.cancelled') : skillFlow.skillErrorMessage(error));
                 } finally {
                     removeCancel(); controller.abort();
+                    try {
+                        if (directoryPlan && isCurrent()) attachInstallDirectory(inlineStatusBox, {
+                            plan_id: directoryPlan, account, token, item_id: String(itemData.id)
+                        }, scope, { skill: true });
+                    } catch {}
                     if (phase === 'install') phase = 'idle';
                     releaseButton();
                 }
@@ -683,6 +691,7 @@ export function setupResourceInstall(btnUse, itemData, currentUser, inlineStatus
                 confirmInstallButton.onclick = async () => {
                     if (!isCurrent() || phase !== "confirm") return;
                     phase = "install";
+                    let directoryAttempted = false;
                     try {
                         removeInstallEscapeHandler();
                         confirmInstallButton.disabled = true;
@@ -723,6 +732,7 @@ export function setupResourceInstall(btnUse, itemData, currentUser, inlineStatus
                             ? "/community_hub/install_tool"
                             : "/community_hub/install_private_tool";
 
+                        directoryAttempted = true;
                         const progress = trackProgress();
                         const cancelController = new AbortController();
                         progress.addCancelButton(t('install.cancel_in_progress'), () => cancelController.abort());
@@ -879,7 +889,10 @@ export function setupResourceInstall(btnUse, itemData, currentUser, inlineStatus
                         }
                     } catch (_) {
                         if (isCurrent()) { phase = "unknown"; btnUse.removeAttribute("aria-busy"); inlineStatusBox.textContent = t('install.connection_uncertain'); }
-                    } finally { if (phase === "install") phase = "idle"; releaseButton(); }
+                    } finally {
+                        try { if (directoryAttempted && isCurrent()) attachInstallDirectory(inlineStatusBox, { url: itemData.link }, scope); } catch {}
+                        if (phase === "install") phase = "idle"; releaseButton();
+                    }
                 };
             } else if (isApp) {
                 const progress = trackProgress();

前端页面/market/资源操作生命周期.js

@@ -1,52 +1,62 @@
-// 安装与交付入口共用原账号/节点范围；已经提交的购买和安装不自动重放。
-import { captureRequestSession, requestCancelManager } from "../core/网络请求API.js";
-import { API, CACHE } from "../core/全局配置.js";
-import { getUser, eventBus, EVENTS } from "../core/状态管理.js";
-import { createTaskViewScope, subscribeTaskSessionChanges } from "../task/任务视图生命周期.js";
-
-const scopes = new WeakMap();
-let sequence = 0;
-export function createResourceOperationScope(button, statusBox, account, options = {}) {
-    scopes.get(button)?.dispose();
-    const matches = captureRequestSession(), componentId = `resource-operation-${++sequence}`;
-    const confirmation = new AbortController(), cleanups = new Set();
-    let inner, observer, disposed = false;
-    const cleanup = () => {
-        if (disposed) return;
-        disposed = true;
-        observer?.disconnect(); confirmation.abort();
-        button.disabled = true; button.removeAttribute("aria-busy");
-        statusBox.replaceChildren(); statusBox.style.display = "none";
-        for (const callback of cleanups) { try { callback(); } catch (_) {} }
-        cleanups.clear();
-    };
-    const scope = {
-        readOptions: { noCache: true, componentId, timeout: API.BACKGROUND_TIMEOUT, retries: API.BACKGROUND_RETRIES },
-        confirmationSignal: confirmation.signal,
-        dispose() { if (inner) inner.dispose(); else cleanup(); },
-        addCleanup(callback) {
-            if (disposed) { callback(); return () => {}; }
-            cleanups.add(callback); return () => cleanups.delete(callback);
-        },
-        isCurrent() {
-            if (disposed) return false;
-            // 只有实际操作过的卡片订阅身份/DOM变化，避免整个榜单逐卡安装全局监听。
-            if (!inner) {
-                inner = createTaskViewScope({
-                    sessionMatches: () => matches() && getUser()?.account === account,
-                    connected: () => button.isConnected && statusBox.isConnected
-                        && (!options.isCurrent || options.isCurrent()),
-                    subscribe: notify => subscribeTaskSessionChanges(notify, { target: window, eventBus, events: EVENTS,
-                        userKey: CACHE.LEGACY_KEYS.USER, tokenKey: CACHE.LEGACY_KEYS.TOKEN }),
-                    cancelReads: () => requestCancelManager.cancelAll(componentId), invalidate: () => {}
-                });
-                inner.addCleanup(cleanup);
-                observer = new MutationObserver(() => { scope.isCurrent(); });
-                observer.observe(document.body, { childList: true, subtree: true });
-            }
-            return inner.isCurrent();
-        }
-    };
-    button._cleanup = () => scope.dispose(); scopes.set(button, scope);
-    return scope;
-}
+// 安装与交付入口共用原账号/节点范围；已经提交的购买和安装不自动重放。
+import { captureRequestSession, requestCancelManager } from "../core/网络请求API.js";
+import { API, CACHE } from "../core/全局配置.js";
+import { getUser, eventBus, EVENTS } from "../core/状态管理.js";
+import { createTaskViewScope, subscribeTaskSessionChanges } from "../task/任务视图生命周期.js";
+
+const scopes = new WeakMap();
+let sequence = 0;
+export function createResourceOperationScope(button, statusBox, account, options = {}) {
+    scopes.get(button)?.dispose();
+    const matches = captureRequestSession(), componentId = `resource-operation-${++sequence}`;
+    const confirmation = new AbortController(), cleanups = new Set(), cleanupNodes = new Map();
+    let inner, observer, disposed = false;
+    const cleanup = () => {
+        if (disposed) return;
+        disposed = true;
+        observer?.disconnect(); confirmation.abort();
+        button.disabled = true; button.removeAttribute("aria-busy");
+        statusBox.replaceChildren(); statusBox.style.display = "none";
+        for (const callback of cleanups) { try { callback(); } catch (_) {} }
+        cleanups.clear(); cleanupNodes.clear();
+    };
+    const scope = {
+        readOptions: { noCache: true, componentId, timeout: API.BACKGROUND_TIMEOUT, retries: API.BACKGROUND_RETRIES },
+        confirmationSignal: confirmation.signal,
+        dispose() { if (inner) inner.dispose(); else cleanup(); },
+        addCleanup(callback, node = null) {
+            if (disposed || node && !node.isConnected) { callback(); return () => {}; }
+            cleanups.add(callback);
+            if (node) cleanupNodes.set(callback, node);
+            return () => { cleanupNodes.delete(callback); return cleanups.delete(callback); };
+        },
+        isCurrent() {
+            if (disposed) return false;
+            // 只有实际操作过的卡片订阅身份/DOM变化，避免整个榜单逐卡安装全局监听。
+            if (!inner) {
+                inner = createTaskViewScope({
+                    sessionMatches: () => matches() && getUser()?.account === account,
+                    connected: () => button.isConnected && statusBox.isConnected
+                        && (!options.isCurrent || options.isCurrent()),
+                    subscribe: notify => subscribeTaskSessionChanges(notify, { target: window, eventBus, events: EVENTS,
+                        userKey: CACHE.LEGACY_KEYS.USER, tokenKey: CACHE.LEGACY_KEYS.TOKEN }),
+                    cancelReads: () => requestCancelManager.cancelAll(componentId), invalidate: () => {}
+                });
+                inner.addCleanup(cleanup);
+                observer = new MutationObserver(() => {
+                    if (!scope.isCurrent()) return;
+                    for (const [callback, node] of cleanupNodes) {
+                        if (!node.isConnected) {
+                            cleanupNodes.delete(callback); cleanups.delete(callback);
+                            try { callback(); } catch (_) {}
+                        }
+                    }
+                });
+                observer.observe(document.body, { childList: true, subtree: true });
+            }
+            return inner.isCurrent();
+        }
+    };
+    button._cleanup = () => scope.dispose(); scopes.set(button, scope);
+    return scope;
+}