dsh-folia 2.5.0 → 2.7.0

package/lib/client.js

@@ -16231,33 +16231,237 @@ window.__ModuleLoader__.load({
 				}
 
 				/**
-				 * 把一套皮肤的样式**当场**挂进文档：`<link id="folia-skin-hot">` 追加到 `<head>` 末尾。
+				 * 把一套皮肤的样式**当场**挂进文档。
 				 *
-				 * 为什么不用"刷新页面"：皮肤中心只在页面加载时应用皮肤，而桌面壳里 `location.reload()`
-				 * 常常被吞掉（用户看到的就是"点了没反应"）。直接注入 CSS 不依赖它 —— 后加载的规则
-				 * 覆盖先前的，于是不刷新也能换肤。代价：皮肤自带的 `hooks.mjs`（粒子等动效）不会跑，
-				 * 那部分仍然只有整页重载/重启才会生效；这一点在下方的提示里如实写明。
+				 * 为什么是 `<style>` 而不是 `<link>`：
+				 *   · `<link rel=stylesheet>` 是**异步**的，加载完成的时机不定，容易输给皮肤中心随后
+				 *     重新注入的那份；
+				 *   · `<style>` 一赋值就参与样式计算，且追加到 `<body>` **末尾** ⇒ 文档顺序最后，
+				 *     同等特异性下后写的赢。这是"不刷新换肤"能真正看见的关键。
+				 *
+				 * 仍然不跑 `hooks.mjs`（粒子等动效），那部分只有整页重载才生效。
 				 *
 				 * @param {string} id 皮肤 id
+				 * @returns {Promise<{ bytes: number, rules: number }>}
+				 */
+				async function applySkinCss(id) {
+				  const resp = await apiFetch("/skins/css?id=" + encodeURIComponent(id) + "&t=" + Date.now(), {
+				    parse: false,
+				    cache: "no-store",
+				  });
+				  if (!resp || !resp.ok || !resp.response) throw new Error("css-http-" + ((resp && resp.status) || 0));
+				  const css = await resp.response.text();
+				  if (!css || !css.trim()) throw new Error("css-empty");
+				  let el = document.getElementById("folia-skin-hot");
+				  if (!el) {
+				    el = document.createElement("style");
+				    el.id = "folia-skin-hot";
+				    // 挂 body 末尾（不是 head）：文档顺序最后 ⇒ 同等特异性下覆盖先前的规则。
+				    (document.body || document.head).appendChild(el);
+				  }
+				  el.textContent = css;
+				  let rules = 0;
+				  try { rules = (el.sheet && el.sheet.cssRules && el.sheet.cssRules.length) || 0; } catch { /* 读不到就报 0 */ }
+				  return { bytes: css.length, rules };
+				}
+
+				/**
+				 * 搭出皮肤的**背景层**：`body > [data-dsh-skin-layer="background"]`，z-index -2，
+				 * 里面放 `<video>`/`<img>`（object-fit: cover）+ 一层 scrim 渐变。
+				 *
+				 * 为什么必须自己搭：背景不在 CSS 里，而是 `contributes.backgroundMedia`；皮肤中心只在
+				 * 启动时建这个元素。热切换时没人建 ⇒ 只剩下配色变了、背景还是一片空 ——
+				 * 用户看到的"水墨丹青没有背景动画"就是这个（它是一段 21 MB 的循环视频）。
+				 * 元素契约（z-index -2、媒体作直接子元素）从各皮肤 CSS 反推：
+				 * `future-window` 写 `[data-dsh-skin-layer="background"] > img`，
+				 * `ice-princess` 的注释直接写明"挂在 z-index -2 这层上"。
+				 *
+				 * @param {string} id 皮肤 id
+				 * @returns {Promise<{ kind: string }>}
+				 */
+				async function applySkinBackground(id) {
+				  const resp = await apiJson("/skins/manifest?id=" + encodeURIComponent(id));
+				  const doc = (resp && resp.data) || null;
+				  const media = doc && doc.backgroundMedia;
+				  let dark = false;
+				  try { dark = Boolean(document.body && document.body.hasAttribute("data-ds-dark-theme")); } catch { /* 取不到按浅色 */ }
+				  const pick = media ? (dark ? (media.dark || media.light) : (media.light || media.dark)) : null;
+
+				  const existing = document.querySelector('[data-dsh-skin-layer="background"]');
+				  if (!pick || !pick.url) {
+				    // 这套皮肤没有背景媒体：把上一次留下的层清掉，别串味。
+				    if (existing) existing.remove();
+				    return { kind: "none" };
+				  }
+
+				  let layer = existing;
+				  if (!layer) {
+				    layer = document.createElement("div");
+				    layer.setAttribute("data-dsh-skin-layer", "background");
+				    layer.style.cssText = "position:fixed;inset:0;z-index:-2;pointer-events:none;overflow:hidden;";
+				    (document.body || document.documentElement).insertBefore(layer, document.body.firstChild);
+				  }
+				  layer.innerHTML = "";
+
+				  let el;
+				  if (pick.type === "video") {
+				    el = document.createElement("video");
+				    el.autoplay = true;
+				    el.muted = true;
+				    el.loop = true;
+				    el.setAttribute("muted", "");
+				    el.setAttribute("playsinline", "");
+				    el.setAttribute("autoplay", "");
+				    el.setAttribute("loop", "");
+				  } else {
+				    el = document.createElement("img");
+				    el.alt = "";
+				    el.setAttribute("draggable", "false");
+				  }
+				  el.src = pick.url;
+				  // 皮肤 CSS 通过 `> img` / `> video` 选中它 ⇒ 必须是**直接子元素**。
+				  el.style.cssText = "position:absolute;inset:0;width:100%;height:100%;object-fit:cover;";
+				  layer.appendChild(el);
+
+				  if (pick.scrim) {
+				    const scrim = document.createElement("div");
+				    scrim.style.cssText = "position:absolute;inset:0;pointer-events:none;background-image:" + pick.scrim + ";";
+				    layer.appendChild(scrim);
+				  }
+
+				  if (pick.type === "video") {
+				    const kick = () => { try { const p = el.play(); if (p && typeof p.catch === "function") p.catch(() => {}); } catch { /* 自动播放被拒就静帧 */ } };
+				    el.addEventListener("loadeddata", kick, { once: true });
+				    kick();
+				  }
+				  return { kind: pick.type };
+				}
+
+				/* ── 热切换运行时：作用域属性 + 六个装饰层 + hooks ───────────────────────────────
+				 *
+				 * 皮肤不是"一份 CSS"。它有三层，缺一层就"显示不全"：
+				 *   ① 样式：`stylesheet` + `patches`
+				 *   ② 背景：`contributes.backgroundMedia`
+				 *   ③ 作用域与装饰层：`html[data-dsh-skin="<id>"]` + 六个 `[data-dsh-skin-layer=...]`
+				 *
+				 * 第 ③ 项是"大部分皮肤看起来没生效"的真正原因 —— 65 套里有 **30 套**把规则整段挂在
+				 * `html[data-dsh-skin]` 下面，属性不设，那些规则一条都不匹配；另有 **28 套**带
+				 * `hooks.mjs`（粒子/交互），契约见皮肤中心 `contracts/hooks-api.d.ts`：
+				 *   apply({ skinId, scopeAttr, assetBase, layers{...}, theme{get,subscribe}, onCleanup })
+				 * 所以这里补齐作用域属性、六个层，并按契约跑 hooks（失败只降级）。
 				 */
-				function applySkinCss(id) {
+
+				const SKIN_LAYER_NAMES = ["background", "ambient", "bottom", "sidebar", "top", "foreground"];
+				/** 本次激活注册的清理函数（切换皮肤时逐个跑掉，幂等）。 */
+				let skinHotCleanups = [];
+
+				function skinThemeNow() {
 				  try {
-				    const href = apiUrl("/skins/css?id=" + encodeURIComponent(id) + "&t=" + Date.now());
-				    let el = document.getElementById("folia-skin-hot");
+				    return (document.body && document.body.hasAttribute("data-ds-dark-theme")) ? "dark" : "light";
+				  } catch {
+				    return "light";
+				  }
+				}
+
+				/** 建立/复用六个装饰层，返回契约里那个 `layers` 对象。 */
+				function ensureSkinLayers() {
+				  const host = document.body || document.documentElement;
+				  const out = {};
+				  for (const name of SKIN_LAYER_NAMES) {
+				    let el = null;
+				    try { el = document.querySelector('[data-dsh-skin-layer="' + name + '"]'); } catch { el = null; }
 				    if (!el) {
-				      el = document.createElement("link");
-				      el.id = "folia-skin-hot";
-				      el.rel = "stylesheet";
-				      document.head.appendChild(el);
+				      el = document.createElement("div");
+				      el.setAttribute("data-dsh-skin-layer", name);
+				      // 只给最必要的几何 + 不吃事件；层级交给皮肤自己的 CSS
+				      //（`background` 是契约里明写 z-index -2 的那层，其余留 auto）。
+				      el.style.cssText = "position:fixed;inset:0;pointer-events:none;"
+				        + (name === "background" ? "z-index:-2;" : "");
+				      host.appendChild(el);
 				    }
-				    el.href = href;   // 带时间戳：绕过缓存，换皮肤立刻拿到新样式
-				    return true;
-				  } catch {
-				    return false;
+				    out[name] = el;
+				  }
+				  return out;
+				}
+
+				/**
+				 * 按契约跑一套皮肤的 hooks。失败**只降级**（返回原因），绝不打断样式/背景。
+				 * @returns {Promise<{ ran: boolean, reason?: string }>}
+				 */
+				async function applySkinHooks(id) {
+				  const resp = await apiJson("/skins/manifest?id=" + encodeURIComponent(id));
+				  const doc = (resp && resp.data) || null;
+				  const rel = doc && doc.hooks;
+				  if (!rel) return { ran: false, reason: "no-hooks" };
+
+				  const encoded = String(rel).split("/").map(encodeURIComponent).join("/");
+				  const r = await apiFetch("/skins/files/" + encodeURIComponent(id) + "/" + encoded, {
+				    parse: false,
+				    cache: "no-store",
+				  });
+				  if (!r || !r.ok || !r.response) return { ran: false, reason: "hooks-http-" + ((r && r.status) || 0) };
+				  const source = await r.response.text();
+				  if (!source || !source.trim()) return { ran: false, reason: "hooks-empty" };
+
+				  const blobUrl = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+				  try {
+				    const mod = await import(blobUrl);
+				    const factory = mod && typeof mod.default === "function" ? mod.default : null;
+				    if (!factory) return { ran: false, reason: "no-default-export" };
+				    const hooks = factory();
+				    if (!hooks || typeof hooks.apply !== "function") return { ran: false, reason: "no-apply" };
+
+				    const layers = ensureSkinLayers();
+				    const unsubs = [];
+				    const ctx = {
+				      skinId: id,
+				      scopeAttr: id,
+				      assetBase: apiUrl("/skins/files/" + encodeURIComponent(id) + "/"),
+				      layers,
+				      theme: {
+				        get: skinThemeNow,
+				        subscribe(listener) {
+				          try {
+				            const obs = new MutationObserver(() => {
+				              try { listener(skinThemeNow()); } catch { /* 监听方出错不影响别人 */ }
+				            });
+				            obs.observe(document.body, { attributes: true, attributeFilter: ["data-ds-dark-theme"] });
+				            const off = () => { try { obs.disconnect(); } catch { /* ignore */ } };
+				            unsubs.push(off);
+				            return off;
+				          } catch {
+				            return () => {};
+				          }
+				        },
+				      },
+				      onCleanup(fn) { if (typeof fn === "function") skinHotCleanups.push(fn); },
+				    };
+				    hooks.apply(ctx);
+				    if (typeof hooks.dispose === "function") {
+				      skinHotCleanups.push(() => { try { hooks.dispose(); } catch { /* 幂等 */ } });
+				    }
+				    skinHotCleanups.push(() => { for (const off of unsubs) { try { off(); } catch { /* ignore */ } } });
+				    return { ran: true };
+				  } finally {
+				    setTimeout(() => { try { URL.revokeObjectURL(blobUrl); } catch { /* ignore */ } }, 10000);
 				  }
 				}
 
-				function SkinsTabPanel() {
+				/** 撤掉上一次热切换留下的东西（清理函数 + 注入样式）。作用域属性由下一次直接覆盖。 */
+				function clearSkinHot() {
+				  for (const fn of skinHotCleanups.splice(0).reverse()) {
+				    try { fn(); } catch { /* 清理幂等，单个失败不影响其余 */ }
+				  }
+				  try {
+				    const el = document.getElementById("folia-skin-hot");
+				    if (el) el.remove();
+				  } catch { /* ignore */ }
+				}
+
+				function SkinsTabPanel(props) {
+				  // 壁纸让位：挂载点（设置页 / 首页抽屉）各自把"清掉当前壁纸"的回调传进来 ——
+				  // 皮肤和壁纸都在铺背景，必须二选一。本组件不直接碰设置，只调用传进来的入口。
+				  const onClearWallpaper = props && props.onClearWallpaper;
 				  const [list, setList] = React.useState([]);
 				  const [active, setActive] = React.useState(null);
 				  const [loading, setLoading] = React.useState(true);
@@ -16319,15 +16523,52 @@ window.__ModuleLoader__.load({
 				          setNote({ kind: "ok", text: weT("已安装：") + label });
 				          await load(true);
 				        } else if (kind === "activate") {
-				          // **当场换肤**：把皮肤样式直接注入文档，不刷新、不重启。
-				          // （背景：皮肤中心只在页面加载时应用皮肤，而桌面壳会吞掉 location.reload。）
-				          const applied = applySkinCss(id);
+				          // **当场换肤**：把皮肤样式同步注入文档，不刷新、不重启。
+				          // 注入结果直接写进提示里（字节数 / 规则条数）：万一样式还是没盖住皮肤中心，
+				          // 这一行就是判断"是没注入"还是"注入了但被压住"的依据，不用再猜。
+				          let info = null;
+				          let applyErr = "";
+				          let bgKind = "none";
+				          let hooksInfo = { ran: false, reason: "skipped" };
+				          try {
+				            // ① 先清掉上一次热切换留下的清理函数与注入样式（避免两套皮肤叠加）
+				            clearSkinHot();
+				            // ② 作用域属性：30/65 套皮肤的规则整段挂在 html[data-dsh-skin="<id>"] 下，
+				            //    不设这个属性，那些规则一条都不匹配 —— 这是"显示不全"的最大来源。
+				            try { document.documentElement.setAttribute("data-dsh-skin", id); } catch { /* ignore */ }
+				            // ③ 六个装饰层（hooks 与部分皮肤 CSS 都要用）
+				            ensureSkinLayers();
+				            // ④ 样式、⑤ 背景、⑥ hooks
+				            info = await applySkinCss(id);
+				            const bg = await applySkinBackground(id);
+				            bgKind = bg.kind;
+				            try {
+				              hooksInfo = await applySkinHooks(id);
+				            } catch (e) {
+				              hooksInfo = { ran: false, reason: String((e && e.message) || e) };
+				            }
+				          } catch (e) {
+				            applyErr = String((e && e.message) || e);
+				          }
+				          // ⑦ 壁纸让位：皮肤和壁纸都在铺背景，必须互斥。清掉 `id` 之后壁纸层会自己撤下
+				          //    （同时 `data-we-wallpaper` 标记消失，皮肤中心也不会再扣住皮肤）。
+				          let wallpaperCleared = false;
+				          try {
+				            if (typeof onClearWallpaper === "function") {
+				              await Promise.resolve(onClearWallpaper());
+				              wallpaperCleared = true;
+				            }
+				          } catch { /* 清壁纸失败不影响换肤本身 */ }
 				          setNote({
-				            kind: "ok",
-				            text: applied
-				              ? weT("已切换到「") + label + weT("」—— 样式已即时应用")
-				              : weT("已切换为「") + label + weT("」，但样式注入失败，请重启 DSH"),
-				            // hooks（粒子等动效）只有整页重载才会跑：给一个可选入口，不强制。
+				            kind: applyErr ? "err" : "ok",
+				            text: applyErr
+				              ? weT("已切换为「") + label + weT("」，但样式注入失败：") + applyErr
+				              : weT("已切换到「") + label + weT("」—— 样式 ")
+				                + Math.round(info.bytes / 1024) + " KB / " + info.rules + weT(" 条规则")
+				                + (bgKind === "none" ? weT("，无背景媒体") : weT("，背景：") + bgKind)
+				                + (hooksInfo.ran ? weT("，动效已启动") : (hooksInfo.reason === "no-hooks" ? weT("，无动效") : weT("，动效未启动(") + hooksInfo.reason + ")"))
+				                + (wallpaperCleared ? weT("，壁纸已关闭") : ""),
+				            // hooks 已经跑过了；这里只作为"整页重载"的可选入口（极少数皮肤依赖启动期布局）
 				            reload: true,
 				          });
 				          // 不再整表重拉：本地标记已经对了，省掉那 600 ms 的"没反应"窗口。
@@ -16528,8 +16769,6 @@ window.__ModuleLoader__.load({
 				            : React.createElement("div", { style: SKINS_STYLE.thumb }),
 				          React.createElement("div", { style: SKINS_STYLE.body },
 				            React.createElement("div", { style: SKINS_STYLE.title }, s.name || s.id),
-				            React.createElement("div", { style: SKINS_STYLE.meta },
-				              (s.author ? s.author : weT("未知作者")) + " · " + skinsFmtBytes(s.zipBytes)),
 				            s.tagline ? React.createElement("div", { style: SKINS_STYLE.meta }, s.tagline) : null,
 				            (s.tags || []).length
 				              ? React.createElement("div", { style: SKINS_STYLE.tags },
@@ -16544,9 +16783,13 @@ window.__ModuleLoader__.load({
 				  return React.createElement(React.Fragment, null, children);
 				}
 
-				/** 页签薄包装：`renderActiveTab` 只认这个签名（与别的 `render*Tab(ctx)` 一致）。 */
-				function renderSkinsTab(ctx) {
-				  return React.createElement(SkinsTabPanel, null);
+				/**
+				 * 页签薄包装：`renderActiveTab` 只认这个签名（与别的 `render*Tab(ctx)` 一致）。
+				 * 传进来的 `props` 原样转交给组件 —— 目前只有 `onClearWallpaper`（皮肤与壁纸互斥，
+				 * 由挂载点提供"清掉当前壁纸"的入口；本文件不直接碰设置）。
+				 */
+				function renderSkinsTab(props) {
+				  return React.createElement(SkinsTabPanel, props || null);
 				}
 
 				// ── 内联模块：src/picker-model.js —— 选择器模型层：过滤判定 + 派生数据 + 分页切片（纯函数 / 显式入参 / 零 DOM）（构建期注入；勿手改本段）──
@@ -18155,7 +18398,7 @@ window.__ModuleLoader__.load({
 				            ? qpRenderPlaybackPane(sel, switchQpTab)
 				            // 皮肤包：直接挂设置页那个同一个组件（它自己管列表/下载/激活状态）。
 				            : qpTab === "skins"
-				              ? React.createElement(SkinsTabPanel, null)
+				              ? React.createElement(SkinsTabPanel, { onClearWallpaper: () => setSetting("id", "") })
 				              : null),
 				        !(qpTab === "wallpaper" && userPropsPanelOpen() && propsAvailable) && qpTab === "wallpaper" && React.createElement(React.Fragment, null,
 				                // ── 壁纸列表（搜索 + 视图切换 + 快切）──
@@ -29773,7 +30016,7 @@ window.__ModuleLoader__.load({
 		    if (activeTab === "extensions") return renderExtensionsTab(extensionCtx());
 		    // 「皮肤包」自带异步状态（列表 / 下载中 / 错误），所以它是一个**真组件**而不是
 		    // 纯渲染函数 —— 薄包装只负责挂上去（理由见 src/panel-tabs-skins.js 文件头）。
-		    if (activeTab === "skins") return renderSkinsTab();
+		    if (activeTab === "skins") return renderSkinsTab({ onClearWallpaper: () => setSetting("id", "") });
 		    if (activeTab === "appearance") return renderAppearanceTab({
 		      setSetting, setTransient,
 		      fontSet: fontSetCtx(),

package/lib/routes/skins.js

@@ -544,12 +544,62 @@ export function registerSkinRoutes(webServer, c) {
     '.webp': 'image/webp',
     '.gif': 'image/gif',
     '.avif': 'image/avif',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
     '.woff': 'font/woff',
     '.woff2': 'font/woff2',
     '.ttf': 'font/ttf',
     '.otf': 'font/otf',
   };
 
+  /* ── 背景层数据 ────────────────────────────────────────────────────────────
+   * 一套皮肤的"背景"不在 CSS 里，而是 `contributes.backgroundMedia`：
+   *   { light: { type: 'video'|'image', src: 'assets/x.mp4', scrim: '<css 渐变>' }, dark: {...} }
+   * 皮肤中心负责把这层画出来；它的 DOM 契约（从各皮肤 CSS 反推）是
+   *   `body [data-dsh-skin-layer='background']`，z-index -2，视频/图片作为子元素
+   *（`future-window` 直接写 `> img`，`frutiger-aero` 用 `::after` 叠气泡）。
+   * 热切换时没人建这层 ⇒ 背景全空（"水墨丹青没有背景动画"就是这个原因）。
+   */
+  disposers.push(webServer.register({
+    kind: 'exact',
+    path: `${base}/skins/manifest`,
+    handler: async (req, res) => {
+      const url = new URL(req.url || '/', 'http://x');
+      const id = url.searchParams.get('id') || '';
+      if (!ID_RE.test(id)) { sendJson(res, 400, { ok: false, error: 'bad-id' }); return; }
+      const harness = harnessRoot();
+      if (!harness) { sendJson(res, 503, { ok: false, error: 'harness-not-found' }); return; }
+      const dir = join(harness, SKINS_DIR_NAME, id);
+      let doc;
+      try {
+        doc = JSON.parse(readFileSync(join(dir, 'skin.json'), 'utf8'));
+      } catch {
+        sendJson(res, 404, { ok: false, error: 'no-manifest' });
+        return;
+      }
+      const c = (doc && doc.contributes) || {};
+      const media = c.backgroundMedia && typeof c.backgroundMedia === 'object' ? c.backgroundMedia : null;
+      /** `src` 相对路径 → 我们的素材路由（浏览器只认这条）。 */
+      const abs = (rel) => {
+        if (typeof rel !== 'string' || !rel) return '';
+        if (/^(?:[a-z]+:|\/)/i.test(rel)) return rel;
+        return `${base}/skins/asset?id=${encodeURIComponent(id)}&p=${encodeURIComponent(rel)}`;
+      };
+      const shape = (m) => (m && typeof m === 'object' ? {
+        type: m.type === 'video' ? 'video' : 'image',
+        url: abs(m.src),
+        scrim: typeof m.scrim === 'string' ? m.scrim : '',
+      } : null);
+      sendJson(res, 200, {
+        ok: true,
+        id,
+        name: typeof doc.name === 'string' ? doc.name : id,
+        backgroundMedia: media ? { light: shape(media.light), dark: shape(media.dark) } : null,
+        hooks: typeof c.hooks === 'string' ? c.hooks : '',
+      });
+    },
+  }));
+
   disposers.push(webServer.register({
     kind: 'exact',
     path: `${base}/skins/css`,
@@ -596,6 +646,40 @@ export function registerSkinRoutes(webServer, c) {
     },
   }));
 
+  /* ── 路径式素材路由 ────────────────────────────────────────────────────────
+   * 皮肤的 hooks 契约（`contracts/hooks-api.d.ts`）给的是 `assetBase`：一个**同源 URL
+   * 前缀**，hooks 里自己拼 `assetBase + 'assets/x.webp'`。`?id=&p=` 这种查询式前缀拼不出
+   * 合法地址，所以这里再提供一条路径式：`/skins/files/<id>/<相对路径>`。
+   * 与 asset 完全同一套安全校验（id 白名单 + 路径段 + 越界检查）。
+   */
+  disposers.push(webServer.register({
+    kind: 'prefix',
+    path: `${base}/skins/files`,
+    handler: async (req, res) => {
+      let pathname = '/';
+      try { pathname = new URL(req.url || '/', 'http://x').pathname; } catch { res.statusCode = 400; res.end(); return; }
+      const prefix = `${base}/skins/files/`;
+      if (!pathname.startsWith(prefix)) { res.statusCode = 404; res.end(); return; }
+      const rest = decodeURIComponent(pathname.slice(prefix.length));
+      const slash = rest.indexOf('/');
+      const id = slash < 0 ? rest : rest.slice(0, slash);
+      const rel = slash < 0 ? '' : rest.slice(slash + 1);
+      if (!ID_RE.test(id)) { res.statusCode = 400; res.end(); return; }
+      const segs = safeRelPath(rel);
+      if (!segs || segs.includes('..')) { res.statusCode = 400; res.end(); return; }
+      const harness = harnessRoot();
+      if (!harness) { res.statusCode = 503; res.end(); return; }
+      const root = join(harness, SKINS_DIR_NAME, id);
+      const file = join(root, ...segs);
+      if (!resolve(file).startsWith(resolve(root) + sep)) { res.statusCode = 400; res.end(); return; }
+      if (!existsSync(file) || !statSync(file).isFile()) { res.statusCode = 404; res.end(); return; }
+      const ext = (file.slice(file.lastIndexOf('.')).toLowerCase() || '');
+      res.setHeader('Content-Type', ASSET_TYPES[ext] || 'application/octet-stream');
+      res.setHeader('Cache-Control', 'public, max-age=300');
+      res.end(readFileSync(file));
+    },
+  }));
+
   disposers.push(webServer.register({
     kind: 'exact',
     path: `${base}/skins/asset`,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "dsh-folia",
-    "version":  "2.5.0",
+    "version":  "2.7.0",
     "description":  "Folia 壁纸引擎：把本机 Wallpaper Engine 壁纸搬进 DSH 界面（场景实时渲染 / 视频 / 网页），内置液态玻璃与 Folia 吉祥物，并可从自建站点拉取壁纸。单包形态（组件已合并）。",
     "type":  "module",
     "engines":  {