dsh-folia 3.9.1 → 4.0.0

package/lib/client.js

@@ -7217,6 +7217,8 @@ window.__ModuleLoader__.load({
 				  contentRatingFilter: "everyone",
 				  // Wallpaper-type filter (all / video / web / image / scene). "all" disables it.
 				  typeFilter: "all",
+				  // 壁纸来源：all / local（本机 Wallpaper Engine 库 + 上传）/ site（我们站点）
+				  sourceFilter: "all",
 				  // Thumbnail-card style: "classic" (WE's original aspect-ratio 16/9 cards —
 				  // the CD-like look the author liked; can overlap in older browsers) or
 				  // "fixed" (fixed-height cards that never overlap). The vinyl
@@ -7661,6 +7663,7 @@ window.__ModuleLoader__.load({
 				  objectFit: { kind: 'enum', values: OBJECT_FIT_VALUES },
 				  contentRatingFilter: { kind: 'enum', values: RATING_VALUES },
 				  typeFilter: { kind: 'enum', values: TYPE_VALUES },
+				  sourceFilter: { kind: 'enum', values: ['all', 'local', 'site'] },
 				  pickerLayout: { kind: 'enum', values: PICKER_LAYOUT_VALUES },
 				  edgeCompat: { kind: 'boolTrue' },
 				  accent: { kind: 'hex' },
@@ -7912,7 +7915,7 @@ window.__ModuleLoader__.load({
 				  library: [
 				    'switchTransition', 'switchTransitionDir', 'switchTransitionSpeed',
 				    'rotationEnabled', 'rotationGroupId', 'rotationGroups', 'rotationSeeded',
-				    'contentRatingFilter', 'typeFilter', 'pickerLayout',
+				    'contentRatingFilter', 'typeFilter', 'sourceFilter', 'pickerLayout',
 				  ],
 				  // 外观：玻璃 / 侧栏与四角 / 标题栏 / 思考块 / 浮层 / 主题预设 / 字体 / UI 配色。
 				  appearance: [
@@ -8547,7 +8550,7 @@ window.__ModuleLoader__.load({
 				    'id', 'hiddenIds', 'rotationEnabled', 'rotationGroupId', 'rotationGroups', 'rotationSeeded',
 				    'playbackRate', 'videoVolume', 'videoAudioEnabled', 'fpsCap', 'sceneLive', 'sceneLiveFps',
 				    'liveBootDelay', 'sceneLiveFailures', 'pauseOnHidden', 'pauseOnBlur', 'pauseOnBattery',
-				    'flip', 'objectFit', 'contentRatingFilter', 'typeFilter', 'pickerLayout', 'edgeCompat',
+				    'flip', 'objectFit', 'contentRatingFilter', 'typeFilter', 'sourceFilter', 'pickerLayout', 'edgeCompat',
 				    'userProps', 'noticeSeen', 'layerPositionX', 'layerPositionY', 'layerScale',
 				  ],
 				  // 玻璃 / 材质 / 侧栏 / 过渡（`accent`、`glassMode` 与皮肤让路之外的整套玻璃登记表都在这里）
@@ -16168,382 +16171,6 @@ window.__ModuleLoader__.load({
 				    );
 				  }
 
-				// ── 内联模块：src/panel-tabs-skins.js —— 「皮肤包」页签：从自建站列皮肤包 → 下载 → 装到 harness/skins → 激活（宿主端 /skins 族）（构建期注入；勿手改本段）──
-				/**
-				 * panel-tabs-skins.js — 「皮肤包」页签：**管理器**，不是渲染器。
-				 *
-				 * ══ 为什么只做管理 ══════════════════════════════════════════════════════════
-				 *
-				 * 皮肤的**渲染**只能由皮肤中心（@linxin666/dsh-client-ui-skin-center）完成：
-				 * 它读 `harness/skins/<id>/`，注入强制作用域化的 CSS、建六个装饰层、跑 hooks、
-				 * 铺背景媒体 —— 而且**只在页面加载时**做一次。它的控制器 `activate(id)` 没有导出，
-				 * 外部无法调用。
-				 *
-				 * 我们曾经试图"复刻"这套渲染（约 600 行：作用域化 CSS / 六层 / hooks / 背景 / 仲裁），
-				 * 结果是：怎么补都差一层，而且**能把整个界面画成空白**（2026-10-28 事故）。
-				 * 所以现在明确分工：
-				 *
-				 *   本页签：列表 · 预览 · 下载安装 · 删除 · 选中（写 active）
-				 *   皮肤中心：真正把皮肤画出来（在它自己的 设置 → 皮肤 页面点「应用」）
-				 *
-				 * 纪律（每一条都对应一次真实事故）：
-				 *   · **绝不**注入 CSS / 造装饰层 / 跑 hooks / 改 html 属性；
-				 *   · **绝不**尝试刷新页面（桌面壳里 location.reload 被吞过）；
-				 *   · 选中之后只写 active，然后**告诉用户下一步去哪点**；
-				 *   · 不碰 patch 行、不碰 generation、不跑 pnpm。
-				 */
-
-				function skinsFmtBytes(n) {
-				  const v = Number(n) || 0;
-				  if (v >= 1024 * 1024) return (v / 1024 / 1024).toFixed(1) + " MB";
-				  if (v >= 1024) return Math.round(v / 1024) + " KB";
-				  return v + " B";
-				}
-
-				/** 当前是深色还是浅色主题（决定卡片显示哪张预览图）。 */
-				function skinsThemeIsDark() {
-				  try {
-				    return Boolean(document.body && document.body.hasAttribute("data-ds-dark-theme"));
-				  } catch {
-				    return false;
-				  }
-				}
-
-				function skinsErrText(code) {
-				  if (!code) return "";
-				  if (code === "disabled") return weT("站点数据源已关闭（DSH_FOLIA_SKINS_SITE=off）");
-				  if (code === "timeout") return weT("站点超时，点「刷新」重试");
-				  if (code === "tls") return weT("站点证书校验失败");
-				  if (code === "network") return weT("连不上站点（网络或域名问题）");
-				  if (/^http-/.test(code)) return weT("站点返回错误：") + code.slice(5);
-				  if (code === "json") return weT("站点索引格式不对");
-				  return code;
-				}
-
-				/** 卡片网格与卡片本体样式：内联，不为一个页签去动全局样式表。 */
-				const SKINS_STYLE = {
-				  grid: { display: "grid", gridTemplateColumns: "repeat(auto-fill, minmax(168px, 1fr))", gap: "10px", marginTop: "10px" },
-				  card: {
-				    display: "flex", flexDirection: "column", overflow: "hidden",
-				    border: "1px solid rgba(255,255,255,0.12)", borderRadius: "10px", background: "rgba(255,255,255,0.04)",
-				  },
-				  thumb: { width: "100%", aspectRatio: "4 / 3", objectFit: "cover", display: "block", background: "rgba(0,0,0,0.35)" },
-				  body: { padding: "8px 9px 9px", display: "flex", flexDirection: "column", gap: "4px", flex: "1 1 auto" },
-				  title: { fontSize: "12.5px", fontWeight: 600, lineHeight: 1.3 },
-				  meta: { fontSize: "11px", opacity: 0.62, lineHeight: 1.3 },
-				  tags: { display: "flex", flexWrap: "wrap", gap: "3px", marginTop: "2px" },
-				  tag: { fontSize: "10px", padding: "1px 5px", borderRadius: "999px", background: "rgba(255,255,255,0.09)", opacity: 0.75 },
-				  actions: { display: "flex", gap: "6px", marginTop: "6px" },
-				};
-
-				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);
-				  const [error, setError] = React.useState(null);
-				  const [harnessFound, setHarnessFound] = React.useState(true);
-				  const [skinCenter, setSkinCenter] = React.useState(false);
-				  const [providers, setProviders] = React.useState([]);
-				  const [busy, setBusy] = React.useState("");
-				  const [note, setNote] = React.useState(null);
-				  const [q, setQ] = React.useState("");
-
-				  const load = React.useCallback(async (force) => {
-				    setLoading(true);
-				    setError(null);
-				    try {
-				      // apiJson 返回 { ok, status, data, error } 包装对象，不是响应体本身。
-				      const resp = await apiJson("/skins" + (force ? "?refresh=1" : ""), { parse: "always" });
-				      const r = (resp && resp.data) || null;
-				      setList((r && r.skins) || []);
-				      setActive((r && r.active) || null);
-				      setError((r && r.error) || (resp && resp.error) || null);
-				      setHarnessFound(!r || r.harnessFound !== false);
-				      setSkinCenter(Boolean(r && r.skinCenter));
-				      setProviders(Array.isArray(r && r.skinCenterProviders) ? r.skinCenterProviders : []);
-				    } catch (e) {
-				      setError("network");
-				      setList([]);
-				    } finally {
-				      setLoading(false);
-				    }
-				  }, []);
-
-				  React.useEffect(() => { load(false); }, [load]);
-
-				  // 轮询验证的清理（组件卸载/重新选中时别留下定时器）。
-				  const pollRef = React.useRef(null);
-				  React.useEffect(() => () => {
-				    if (pollRef.current !== null) { clearInterval(pollRef.current); pollRef.current = null; }
-				  }, []);
-
-				  /**
-				   * 写 active 之后**验证皮肤中心有没有真的应用**。
-				   *
-				   * 为什么不需要刷新页面：皮肤中心的客户端运行时自带轮询 ——
-				   *
-				   *   const SELECTION_POLL_MS = 2e3;
-				   *   function watchPersistedSelection(store, intervalMs = SELECTION_POLL_MS) {
-				   *     const tick = async () => {
-				   *       const next = await readPersistedSelection(store);      // GET /api/skin-center/v2/active
-				   *       if (next === undefined || next === applied) return;
-				   *       applied = next;
-				   *       await convergeOnSelection(store, next);                // ← 自动应用
-				   *     };
-				   *     store.window.setInterval(tick, intervalMs);               // 注意是 store.window.setInterval
-				   *   }
-				   *
-				   * 那个 `/active` 读的就是我们刚写的 `skin-center-active.json`。所以写完之后它会在
-				   * 2 秒内自己收敛过去 —— 之前"必须刷新"的假象，是我们自己的热注入在覆盖它的结果。
-				   *
-				   * 它的收敛成功标志很明确：`<html data-dsh-skin="<id>">`。我们就盯这个属性：
-				   * 出现了 = 真的应用了；5 次（约 6 秒）还没出现 = 没应用，如实说。
-				   */
-				  function verifyApplied(id, label) {
-				    if (pollRef.current !== null) { clearInterval(pollRef.current); pollRef.current = null; }
-				    let tries = 0;
-				    pollRef.current = setInterval(() => {
-				      tries += 1;
-				      let stamped = null;
-				      try { stamped = document.documentElement.getAttribute("data-dsh-skin"); } catch { stamped = null; }
-				      if (stamped === id) {
-				        clearInterval(pollRef.current); pollRef.current = null;
-				        setNote({ kind: "ok", text: weT("已应用：「") + label + weT("」—— 皮肤中心已收敛（无需刷新）") });
-				        return;
-				      }
-				      if (tries >= 9) {   // 约 11 秒：host 会先写 null 再写目标 id（900ms），引擎每 2s 轮询一次
-				        clearInterval(pollRef.current); pollRef.current = null;
-				        setNote({
-				          kind: "err",
-				          text: weT("已写入「") + label + weT("」，但皮肤中心没有应用。可能原因：壁纸仍在台（皮肤会被抑制）或这套皮肤校验未通过。可到「设置 → 皮肤」点「应用」确认。"),
-				        });
-				      }
-				    }, 1200);
-				  }
-
-				  /**
-				   * 执行一个动作。
-				   * · install / remove：宿主真正干活（下载解压 / 删目录）。
-				   * · activate：**只写 active**（`skin-center-active.json`）—— 不注入任何样式，
-				   *   应用由皮肤中心自己轮询完成，我们只负责验证结果。
-				   */
-				  async function act(kind, id, label) {
-				    if (busy) return;
-				    setBusy(id);
-				    setNote(null);
-				    try {
-				      const resp = await apiPostJson("/skins/" + kind, { id }, { parse: "always" });
-				      const r = (resp && resp.data) || null;
-				      if (resp && resp.ok && r && r.ok) {
-				        if (kind === "install") {
-				          setNote({ kind: "ok", text: weT("已安装：") + label });
-				          await load(true);
-				        } else if (kind === "activate") {
-				          setActive(id);
-				          setList((prev) => prev.map((x) => ({ ...x, active: x.id === id })));
-				          // 皮肤与壁纸都在铺背景，必须互斥：皮肤中心在壁纸在台时会**主动抑制皮肤**，
-				          // 所以这一步不是"顺手"，而是"应用能否成功"的前提。
-				          try {
-				            if (typeof onClearWallpaper === "function") await Promise.resolve(onClearWallpaper());
-				          } catch { /* 清壁纸失败不影响选中本身 */ }
-				          if (skinCenter) {
-				            setNote({ kind: "ok", text: weT("已选中「") + label + weT("」，等待皮肤中心应用（约 2 秒）…") });
-				            verifyApplied(id, label);
-				          } else {
-				            setNote({
-				              kind: "err",
-				              text: weT("已写入「") + label + weT("」，但本机没有皮肤中心，无法渲染。请安装 @linxin666/dsh-client-ui-skin-center 后重启。"),
-				            });
-				          }
-				        } else if (kind === "remove") {
-				          setNote({ kind: "ok", text: weT("已删除：") + label });
-				          await load(true);
-				        }
-				      } else {
-				        const code = (r && r.error) || "failed";
-				        const detail = (r && r.detail) ? "（" + r.detail + "）" : "";
-				        setNote({ kind: "err", text: weT("操作失败：") + code + detail });
-				      }
-				    } catch (e) {
-				      setNote({ kind: "err", text: weT("请求失败：") + (e && e.message ? e.message : weT("网络错误")) });
-				    } finally {
-				      setBusy("");
-				    }
-				  }
-
-				  const needle = q.trim().toLowerCase();
-				  const shown = needle
-				    ? list.filter((s) => (s.name + " " + s.nameEn + " " + s.id + " " + (s.tags || []).join(" "))
-				      .toLowerCase().indexOf(needle) !== -1)
-				    : list;
-				  const installedCount = list.filter((s) => s.installed).length;
-
-				  const header = React.createElement("div", { className: "we-picker__section-head" },
-				    React.createElement("span", { className: "we-picker__section-label" },
-				      weT("🎨 皮肤包") + (list.length ? "  ·  " + list.length : "")),
-				    React.createElement("button", {
-				      type: "button",
-				      className: "we-picker__btn",
-				      style: { marginLeft: "auto" },
-				      disabled: loading,
-				      onClick: () => load(true),
-				      title: weT("重新从站点拉取列表"),
-				    }, loading ? weT("加载中…") : weT("刷新")),
-				  );
-
-				  if (!harnessFound) {
-				    return React.createElement(React.Fragment, null,
-				      React.createElement("div", { className: "we-picker__section" }, header,
-				        React.createElement("div", { className: "we-picker__empty" },
-				          React.createElement("span", { className: "we-picker__empty-title" }, weT("找不到 DSH 的 skins 目录")),
-				          React.createElement("span", { className: "we-picker__hint" },
-				            weT("皮肤包要装到 DSH 的 harness/skins 下。可用环境变量 DSH_FOLIA_HARNESS 指定该目录")))));
-				  }
-
-				  const children = [React.createElement("div", { className: "we-picker__section", key: "sec" }, header)];
-
-				  // 重复挂载警示：我们的 patch 只有一行（folia），正常不会出现；
-				  // 但用户可能自己加了行，这里如实报出来。
-				  if (providers.length > 1) {
-				    children.push(React.createElement("div", {
-				      key: "dup",
-				      className: "we-picker__hint",
-				      style: {
-				        margin: "4px 0 10px", padding: "7px 10px", borderRadius: "8px",
-				        background: "rgba(255,120,120,0.14)", color: "#ff9a9a", lineHeight: 1.5,
-				      },
-				    }, weT("⚠️ 检测到 ") + providers.length + weT(" 处挂载了皮肤中心（")
-				      + providers.map((p) => p.bundle).join(" / ")
-				      + weT("）。请只保留一处，否则会重复挂载。")));
-				  }
-
-				  // 分工常驻说明：让用户一开始就知道"应用"在哪一步。
-				  if (list.length > 0) {
-				    children.push(React.createElement("div", {
-				      key: "division",
-				      className: "we-picker__hint",
-				      style: { margin: "2px 0 8px", opacity: 0.8 },
-				    }, skinCenter
-				      ? weT("这里负责下载与管理。选中后请到「设置 → 皮肤」点「应用」完成渲染。")
-				      : weT("未检测到皮肤中心：可以下载/管理皮肤包，但无法渲染。请安装 @linxin666/dsh-client-ui-skin-center 并重启。")));
-				  }
-
-				  // 当前选中（只是"选中"，不是"已应用"）
-				  if (active) {
-				    const activeName = (list.find((x) => x.id === active) || {}).name || active;
-				    children.push(React.createElement("div", {
-				      key: "active",
-				      className: "we-picker__hint",
-				      style: { margin: "4px 0 8px", display: "flex", gap: "8px", alignItems: "center", flexWrap: "wrap" },
-				    },
-				    React.createElement("span", null, weT("已选中：") + activeName),
-				    React.createElement("span", {
-				      style: { fontSize: "11px", padding: "1px 6px", borderRadius: "999px", background: "rgba(255,196,120,0.16)", color: "#ffd08a" },
-				    }, weT("需在皮肤中心点「应用」")),
-				    ));
-				  }
-
-				  if (error) {
-				    children.push(React.createElement("div", {
-				      key: "err",
-				      className: "we-picker__hint",
-				      style: { color: "#ff9a9a", margin: "6px 0 10px" },
-				    }, skinsErrText(error)));
-				  }
-				  if (note) {
-				    children.push(React.createElement("div", {
-				      key: "note",
-				      className: "we-picker__hint",
-				      style: { color: note.kind === "err" ? "#ff9a9a" : "#8ee6a8", margin: "6px 0 10px", lineHeight: 1.5 },
-				    }, note.text));
-				  }
-
-				  children.push(React.createElement("div", {
-				    key: "search",
-				    style: { display: "flex", gap: "8px", alignItems: "center", margin: "2px 0 4px" },
-				  },
-				  React.createElement("input", {
-				    type: "text",
-				    value: q,
-				    placeholder: weT("搜索名称 / 作者 / 标签"),
-				    className: "we-picker__search",
-				    onChange: (e) => setQ(e.target.value),
-				    style: { flex: "1 1 auto" },
-				  }),
-				  React.createElement("span", { className: "we-picker__hint" }, weT("已装 ") + installedCount + " / " + list.length),
-				  ));
-
-				  if (loading && list.length === 0) {
-				    children.push(React.createElement("div", { key: "loading", className: "we-picker__empty" },
-				      React.createElement("span", { className: "we-picker__empty-title" }, weT("正在从站点拉取皮肤包…"))));
-				  } else if (!error && shown.length === 0) {
-				    children.push(React.createElement("div", { key: "empty", className: "we-picker__empty" },
-				      React.createElement("span", { className: "we-picker__empty-title" }, weT("没有匹配的皮肤包")),
-				      React.createElement("span", { className: "we-picker__hint" }, weT("换个关键词，或点「刷新」重新拉取"))));
-				  }
-
-				  if (shown.length > 0) {
-				    const darkNow = skinsThemeIsDark();
-				    children.push(React.createElement("div", { key: "grid", style: SKINS_STYLE.grid },
-				      shown.map((s) => {
-				        const previewRel = (darkNow
-				          ? (s.previewDark || s.previewLight)
-				          : (s.previewLight || s.previewDark)) || "";
-				        const previewSrc = previewRel
-				          ? apiUrl("/skins/preview?p=" + encodeURIComponent(previewRel))
-				          : "";
-				        const isBusy = busy === s.id;
-				        const btn = (label, onClick, disabled, primary) => React.createElement("button", {
-				          type: "button",
-				          className: "we-picker__btn" + (primary ? " we-picker__btn--primary" : ""),
-				          style: { flex: "1 1 0", fontSize: "11.5px", padding: "4px 6px" },
-				          disabled: Boolean(disabled) || Boolean(busy),
-				          onClick,
-				        }, label);
-
-				        const actions = [];
-				        if (!s.installed) {
-				          actions.push(btn(isBusy ? weT("安装中…") : weT("下载安装"), () => act("install", s.id, s.name), false, true));
-				        } else if (!s.active) {
-				          actions.push(btn(isBusy ? weT("选中中…") : weT("选择"), () => act("activate", s.id, s.name), false, true));
-				          actions.push(btn(weT("删除"), () => act("remove", s.id, s.name), isBusy, false));
-				        } else {
-				          actions.push(btn(weT("已选中"), () => {}, true, false));
-				        }
-
-				        return React.createElement("div", { key: s.id, style: SKINS_STYLE.card },
-				          previewSrc
-				            ? React.createElement("img", {
-				              src: previewSrc, alt: s.name, loading: "lazy", draggable: false, style: SKINS_STYLE.thumb,
-				            })
-				            : 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),
-				            s.tagline ? React.createElement("div", { style: SKINS_STYLE.meta }, s.tagline) : null,
-				            (s.tags || []).length
-				              ? React.createElement("div", { style: SKINS_STYLE.tags },
-				                s.tags.slice(0, 4).map((t) => React.createElement("span", { key: t, style: SKINS_STYLE.tag }, t)))
-				              : null,
-				            React.createElement("div", { style: SKINS_STYLE.actions }, actions),
-				          ),
-				        );
-				      })));
-				  }
-
-				  return React.createElement(React.Fragment, null, children);
-				}
-
-				/**
-				 * 页签薄包装：`renderActiveTab` 只认这个签名（与别的 `render*Tab(ctx)` 一致）。
-				 * 传进来的 props 原样转交（目前只有 `onClearWallpaper`）。
-				 */
-				function renderSkinsTab(props) {
-				  return React.createElement(SkinsTabPanel, props || null);
-				}
-
 				// ── 内联模块：src/picker-model.js —— 选择器模型层：过滤判定 + 派生数据 + 分页切片（纯函数 / 显式入参 / 零 DOM）（构建期注入；勿手改本段）──
 				/**
 				 * picker-model.js — 壁纸选择器的**模型层**：过滤判定 + 派生数据 + 分页切片。
@@ -16648,8 +16275,25 @@ window.__ModuleLoader__.load({
 				  return w.type === "scene" && Boolean(w.frameUrl);
 				}
 
-				function isRotatableWallpaper(w, ratingFilter, typeFilter) {
-				  return isPlayableType(w) && matchesRatingFilter(w, ratingFilter) && matchesTypeFilter(w, typeFilter);
+				/**
+				 * 壁纸来源：`site` = 从我们站点拉下来的（inventory 里带 `source: "folia"`），
+				 * 其余一律算 `local`（本机 Wallpaper Engine 库 / 用户上传 —— 它们都没有那个标记）。
+				 *
+				 * 为什么不给本机条目补一个 `source`：那要动宿主侧的 inventory 产出，而客户端只靠
+				 * “有没有 folia 标记”就能判对，改面更小。
+				 */
+				function sourceOf(w) {
+				  return w && w.source === "folia" ? "site" : "local";
+				}
+
+				function matchesSourceFilter(w, sourceFilter) {
+				  if (!sourceFilter || sourceFilter === "all") return true;
+				  return sourceOf(w) === sourceFilter;
+				}
+
+				function isRotatableWallpaper(w, ratingFilter, typeFilter, sourceFilter) {
+				  return isPlayableType(w) && matchesRatingFilter(w, ratingFilter)
+				    && matchesTypeFilter(w, typeFilter) && matchesSourceFilter(w, sourceFilter);
 				}
 
 				// 「正在应用的壁纸可以继续播」判据：可播放 ∧ 分级闸门，**不过滤类型**。过滤档分两种
@@ -16673,9 +16317,9 @@ window.__ModuleLoader__.load({
 				}
 
 				/** 可轮换列表：可播放类型 ∧ 命中两级过滤 ∧ 未隐藏（网格与轮换编辑器共用的那份）。 */
-				function playableWallpapers(wallpapers, ratingFilter, typeFilter, hiddenIds) {
+				function playableWallpapers(wallpapers, ratingFilter, typeFilter, hiddenIds, sourceFilter) {
 				  return wallpapers.filter(
-				    (w) => isRotatableWallpaper(w, ratingFilter, typeFilter) && !isHiddenWallpaper(w.id, hiddenIds),
+				    (w) => isRotatableWallpaper(w, ratingFilter, typeFilter, sourceFilter) && !isHiddenWallpaper(w.id, hiddenIds),
 				  );
 				}
 
@@ -16689,15 +16333,19 @@ window.__ModuleLoader__.load({
 				  const hiddenIds = input.hiddenIds || [];
 				  const ratingFilter = input.ratingFilter;
 				  const typeFilter = input.typeFilter;
+				  const sourceFilter = input.sourceFilter;
 				  // 标题搜索（选择器模态框）：在两级过滤之上再收窄可播放网格。大小写不敏感的**子串**匹配。
 				  const query = (input.search || "").trim().toLowerCase();
 				  // 只有可播放的 Video/Web/Image 才进网格 —— Scene/Application 不能嵌进 web UI，
 				  // 隐掉它们网格才有用。已隐藏（软删除）的壁纸离开这里去「已隐藏」区；两级过滤再收窄。
 				  const playableList = list.filter((w) =>
-				    isRotatableWallpaper(w, ratingFilter, typeFilter) && !isHiddenWallpaper(w.id, hiddenIds)
+				    isRotatableWallpaper(w, ratingFilter, typeFilter, sourceFilter) && !isHiddenWallpaper(w.id, hiddenIds)
 				    && (!query || String(w.title || "").toLowerCase().indexOf(query) !== -1));
 				  // 两个过滤下拉的分档计数（可播放、未隐藏）：反映实际可用量，与当前生效的过滤无关。
 				  const basePlayable = list.filter((w) => isPlayableType(w) && !isHiddenWallpaper(w.id, hiddenIds));
+				  // 来源分档计数（可播放、未隐藏、**不受来源过滤影响** —— 它要能反映“切过去有多少张”）。
+				  const sourceCounts = { local: 0, site: 0 };
+				  for (const w of basePlayable) sourceCounts[sourceOf(w)] += 1;
 				  // 单遍聚合 —— 分档计数各刷一遍 basePlayable 是 10 次 O(n)（5 个分级档 + 5 个类型档）。
 				  const ratingCounts = { everyone: 0, pg13: 0, mature: 0, unrated: 0 };
 				  const typeCounts = { video: 0, web: 0, image: 0, scene: 0 };
@@ -16706,7 +16354,7 @@ window.__ModuleLoader__.load({
 				    ratingCounts[r] = (ratingCounts[r] || 0) + 1;
 				    typeCounts[w.type] = (typeCounts[w.type] || 0) + 1;
 				  }
-				  const editorList = playableWallpapers(list, ratingFilter, typeFilter, hiddenIds);
+				  const editorList = playableWallpapers(list, ratingFilter, typeFilter, hiddenIds, sourceFilter);
 				  const hiddenList = hiddenWallpapers(list, hiddenIds);
 				  return {
 				    query,
@@ -16716,6 +16364,7 @@ window.__ModuleLoader__.load({
 				    typeCounts,
 				    editorList,
 				    hiddenList,
+				    sourceCounts,
 				    normalPage: pageSlice(playableList, input.page),
 				    hiddenPageView: pageSlice(hiddenList, input.hiddenPage),
 				    editorPageView: pageSlice(editorList, input.editorPage),
@@ -17088,7 +16737,7 @@ window.__ModuleLoader__.load({
 				  }
 
 				  function renderPickerFilterRow(ctx) {
-				    const { sel, basePlayable, ratingCounts, typeCounts, onSearchInput, onRatingFilterChange, onTypeFilterChange } = ctx;
+				    const { sel, basePlayable, ratingCounts, typeCounts, sourceCounts, onSearchInput, onRatingFilterChange, onTypeFilterChange, onSourceFilterChange } = ctx;
 				    return React.createElement("div", { className: "we-picker__row we-picker__filter-row" },
 				      // 标题搜索：几百上千张壁纸时最快的定位方式。输入即过滤，与分级/类型过滤叠加。
 				      React.createElement("input", {
@@ -17098,6 +16747,20 @@ window.__ModuleLoader__.load({
 				        "aria-label": weT("搜索壁纸标题"),
 				        onInput: onSearchInput,
 				      }),
+				      // 来源：本机 Wallpaper Engine 库 vs 我们站点。放在最前面 —— 它是最粗的一刀，
+				      // 用户常常只想看其中一边（本机几十张 vs 站点几条，混在一起没法挑）。
+				      React.createElement("span", { className: "we-picker__hint we-picker__label" }, weT("来源")),
+				      React.createElement("select", {
+				        className: "we-picker__playlist-select",
+				        value: sel.sourceFilter || "all",
+				        onChange: onSourceFilterChange,
+				        "aria-label": weT("来源"),
+				        title: weT("按来源过滤：本机 Wallpaper Engine 库，还是从我们站点拉下来的壁纸"),
+				      },
+				      React.createElement("option", { value: "all" }, weT("全部（{n}）", { n: basePlayable.length })),
+				      React.createElement("option", { value: "local" }, weT("本机 Wallpaper Engine（{n}）", { n: (sourceCounts && sourceCounts.local) || 0 })),
+				      React.createElement("option", { value: "site" }, weT("站点壁纸（{n}）", { n: (sourceCounts && sourceCounts.site) || 0 })),
+				      ),
 				      React.createElement("span", { className: "we-picker__hint we-picker__label" }, weT("内容分级")),
 				      React.createElement("select", {
 				        className: "we-picker__playlist-select",
@@ -17289,6 +16952,226 @@ window.__ModuleLoader__.load({
 				    return React.createElement("div", { key: p.name, className: "we-picker__props-row" }, label, control);
 				  }
 
+				// ── 内联模块：src/panel-tabs-boot.js —— 「开机动画」页签：候选/下载/选择/开关。播放不在前端 —— 启动那一刻应用还没挂载，由宿主注入的脚本负责（构建期注入；勿手改本段）──
+				/**
+				 * panel-tabs-boot.js — 「开机动画」页签（放在「壁纸」左侧）。
+				 *
+				 * 它只做四件事：看候选、下载、选一个、开关。**播放不在这里** —— 播放发生在启动那一刻，
+				 * 由宿主注入的脚本完成（`lib/boot/index.js` 的 BOOT_SCREEN_SOURCE），因为那时候应用
+				 * 还没挂载，任何 React 组件都还不存在。
+				 *
+				 * 数据全部来自宿主（`/folia/boot/*`），浏览器不直连站点：
+				 *   GET  /folia/boot/list      候选 + 本地状态
+				 *   POST /folia/boot/download  下一条到本地
+				 *   POST /folia/boot/select    选中并启用
+				 *   POST /folia/boot/toggle    开/关
+				 *   POST /folia/boot/settings  淡出/最短显示/最长停留
+				 *   POST /folia/boot/remove    删本地
+				 */
+
+				function bootFmtBytes(n) {
+				  const v = Number(n) || 0;
+				  if (v >= 1024 * 1024) return (v / 1024 / 1024).toFixed(1) + " MB";
+				  if (v >= 1024) return Math.round(v / 1024) + " KB";
+				  return v + " B";
+				}
+
+				const BOOT_STYLE = {
+				  grid: { display: "grid", gridTemplateColumns: "repeat(auto-fill, minmax(180px, 1fr))", gap: "10px", marginTop: "8px" },
+				  card: {
+				    display: "flex", flexDirection: "column", gap: "6px", padding: "9px 10px",
+				    border: "1px solid rgba(255,255,255,0.12)", borderRadius: "10px", background: "rgba(255,255,255,0.04)",
+				  },
+				  title: { fontSize: "12.5px", fontWeight: 600 },
+				  meta: { fontSize: "11px", opacity: 0.62 },
+				  row: { display: "flex", gap: "6px", alignItems: "center" },
+				};
+
+				function BootTabPanel() {
+				  const [state, setState] = React.useState(null);
+				  const [busy, setBusy] = React.useState("");
+				  const [note, setNote] = React.useState(null);
+				  // 下载没有进度通道（宿主一次性 fetch 完才返回），但等待必须"看得见"：
+				  // 每秒 +1 的秒表足以让用户知道它没卡死。
+				  const [tick, setTick] = React.useState(0);
+
+				  const load = React.useCallback(async (force) => {
+				    try {
+				      const resp = await apiJson("/boot/list" + (force ? "?refresh=1" : ""), { parse: "always" });
+				      const r = (resp && resp.data) || null;
+				      setState(r || { ok: false, clips: [], error: "network" });
+				    } catch (e) {
+				      setState({ ok: false, clips: [], error: "network" });
+				    }
+				  }, []);
+
+				  React.useEffect(() => { load(false); }, [load]);
+
+				  React.useEffect(() => {
+				    if (!busy) return undefined;
+				    const t = setInterval(() => setTick((n) => n + 1), 1000);
+				    return () => clearInterval(t);
+				  }, [busy]);
+
+				  async function act(kind, payload, label) {
+				    if (busy) return;
+				    setBusy(payload && payload.id ? payload.id : kind);
+				    setTick(0);
+				    setNote(null);
+				    try {
+				      const resp = await apiPostJson("/boot/" + kind, payload || {}, { parse: "always" });
+				      const r = (resp && resp.data) || null;
+				      if (resp && resp.ok && r && r.ok) {
+				        if (kind === "download") setNote({ ok: true, text: weT("已下载：") + label });
+				        if (kind === "select") setNote({ ok: true, text: weT("已选中「") + label + weT("」，下次启动生效") });
+				        if (kind === "remove") setNote({ ok: true, text: weT("已删除：") + label });
+				        if (kind === "toggle") setNote({ ok: true, text: payload.enabled ? weT("开机动画已开启") : weT("开机动画已关闭") });
+				        if (kind === "settings") setNote({ ok: true, text: weT("已保存") });
+				        await load(true);
+				      } else {
+				        const code = (r && r.error) || "failed";
+				        setNote({ ok: false, text: weT("操作失败：") + code + (r && r.detail ? "（" + r.detail + "）" : "") });
+				      }
+				    } catch (e) {
+				      setNote({ ok: false, text: weT("请求失败：") + (e && e.message ? e.message : weT("网络错误")) });
+				    } finally {
+				      setBusy("");
+				    }
+				  }
+
+				  const clips = (state && state.clips) || [];
+				  const enabled = Boolean(state && state.enabled);
+				  const activeId = (state && state.clipId) || "";
+				  const installedCount = clips.filter((c) => c.installed).length;
+
+				  const children = [];
+
+				  children.push(React.createElement("div", { className: "we-picker__section-head", key: "head" },
+				    React.createElement("span", { className: "we-picker__section-label" }, weT("🎬 开机动画") + (clips.length ? "  ·  " + clips.length : "")),
+				    React.createElement("button", {
+				      type: "button", className: "we-picker__btn", style: { marginLeft: "auto" },
+				      disabled: Boolean(busy), onClick: () => load(true),
+				    }, weT("刷新")),
+				  ));
+
+				  // 开关 + 当前选择
+				  children.push(React.createElement("div", {
+				    key: "switch", style: { ...BOOT_STYLE.row, margin: "6px 0 2px", flexWrap: "wrap" },
+				  },
+				  React.createElement("label", { style: { display: "flex", gap: "6px", alignItems: "center", fontSize: "12px" } },
+				    React.createElement("input", {
+				      type: "checkbox", checked: enabled, disabled: Boolean(busy) || !activeId,
+				      onChange: (e) => act("toggle", { enabled: e.target.checked }, ""),
+				    }),
+				    weT("启用（下次启动播放）"),
+				  ),
+				  React.createElement("span", { className: "we-picker__hint" },
+				    activeId ? weT("当前：") + ((clips.find((c) => c.id === activeId) || {}).title || activeId) : weT("未选择")),
+				  ));
+
+				  children.push(React.createElement("div", { key: "hint", className: "we-picker__hint", style: { margin: "2px 0 6px", opacity: 0.75 } },
+				    weT("下载一条并「使用」后，每次启动都会先播它；默认播完才淡出进入界面。点击或按 Esc 可立即跳过。「带声音」若被浏览器的自动播放策略拦下，会自动退回静音播放。")));
+
+				  if (state && state.error && !clips.length) {
+				    children.push(React.createElement("div", { key: "err", className: "we-picker__hint", style: { color: "#ff9a9a" } },
+				      weT("候选清单读不到：") + state.error));
+				  }
+
+				  if (note) {
+				    children.push(React.createElement("div", { key: "note", className: "we-picker__hint", style: { color: note.ok ? "#8ee6a8" : "#ff9a9a", margin: "4px 0 8px" } }, note.text));
+				  }
+
+				  // 淡出 / 停留
+				  if (state) {
+				    const opt = (label, key, list) => React.createElement("label", { style: { display: "flex", gap: "4px", alignItems: "center", fontSize: "12px" } },
+				      label,
+				      React.createElement("select", {
+				        className: "we-picker__playlist-select",
+				        value: String(state[key]),
+				        disabled: Boolean(busy),
+				        onChange: (e) => act("settings", { [key]: Number(e.target.value) }, ""),
+				      }, list.map(([v, t]) => React.createElement("option", { key: v, value: String(v) }, t))),
+				    );
+				    children.push(React.createElement("div", { key: "opts", style: { ...BOOT_STYLE.row, gap: "14px", flexWrap: "wrap", margin: "2px 0 8px" } },
+				      // 进入方式：默认「播完再进」——之前只有「就绪即进」，15 秒的片子 1.2 秒就被掐掉。
+				      React.createElement("label", { style: { display: "flex", gap: "4px", alignItems: "center", fontSize: "12px" } },
+				        weT("进入方式"),
+				        React.createElement("select", {
+				          className: "we-picker__playlist-select",
+				          value: String(state.enterMode || "tail"),
+				          disabled: Boolean(busy),
+				          onChange: (e) => act("settings", { enterMode: e.target.value }, ""),
+				        },
+				        React.createElement("option", { value: "tail" }, weT("播完再进（默认）")),
+				        React.createElement("option", { value: "ready" }, weT("界面就绪就进")),
+				        React.createElement("option", { value: "click" }, weT("点一下才进")),
+				        ),
+				      ),
+				      opt(weT("淡出时长"), "fadeMs", [[400, "0.4 秒"], [600, "0.6 秒"], [900, "0.9 秒"], [1200, "1.2 秒"], [1600, "1.6 秒"]]),
+				      // 声音：默认关（带声音的自动播放会被浏览器策略拦）。打开后若仍被拦，
+				      // 脚本会自动退回静音播放 —— 画面优先，不会黑屏。
+				      React.createElement("label", { style: { display: "flex", gap: "6px", alignItems: "center", fontSize: "12px" } },
+				        React.createElement("input", {
+				          type: "checkbox",
+				          checked: Boolean(state.sound),
+				          disabled: Boolean(busy),
+				          onChange: (e) => act("settings", { sound: e.target.checked }, ""),
+				        }),
+				        weT("带声音"),
+				      ),
+				      opt(weT("最短显示"), "minShowMs", [[0, "不限制"], [600, "0.6 秒"], [1200, "1.2 秒"], [2000, "2 秒"]]),
+				      opt(weT("最长停留"), "maxHoldMs", [[10000, "10 秒"], [20000, "20 秒（默认）"], [30000, "30 秒"], [60000, "60 秒"]]),
+				    ));
+				  }
+
+				  children.push(React.createElement("div", { key: "count", className: "we-picker__hint", style: { margin: "2px 0 4px" } },
+				    weT("已下载 ") + installedCount + " / " + clips.length));
+
+				  if (clips.length) {
+				    children.push(React.createElement("div", { key: "grid", style: BOOT_STYLE.grid },
+				      clips.map((c) => {
+				        const isBusy = busy === c.id;
+				        const isActive = c.id === activeId;
+				        const btn = (label, onClick, disabled, primary) => React.createElement("button", {
+				          type: "button",
+				          className: "we-picker__btn" + (primary ? " we-picker__btn--primary" : ""),
+				          style: { flex: "1 1 0", fontSize: "11.5px", padding: "4px 6px" },
+				          disabled: Boolean(disabled) || Boolean(busy),
+				          onClick,
+				        }, label);
+				        const actions = [];
+				        if (!c.installed) {
+				          actions.push(btn(isBusy ? (weT("下载中… ") + tick + "s") : weT("下载"), () => act("download", { id: c.id }, c.title), false, true));
+				        } else if (!isActive) {
+				          actions.push(btn(weT("使用"), () => act("select", { id: c.id }, c.title), false, true));
+				          actions.push(btn(weT("删除"), () => act("remove", { id: c.id }, c.title), isBusy, false));
+				        } else {
+				          actions.push(btn(weT("使用中"), () => {}, true, false));
+				        }
+				        return React.createElement("div", { key: c.id, style: BOOT_STYLE.card },
+				          React.createElement("div", { style: BOOT_STYLE.title }, c.title || c.id),
+				          React.createElement("div", { style: BOOT_STYLE.meta },
+				            [c.durationSec ? Number(c.durationSec).toFixed(1) + "s" : null,
+				             bootFmtBytes(c.localBytes || c.bytes)].filter(Boolean).join(" · ")),
+				          c.faststart === false
+				            ? React.createElement("div", { style: { ...BOOT_STYLE.meta, color: "#ffd08a" } }, weT("未做 faststart，播放可能更慢"))
+				            : null,
+				          React.createElement("div", { style: { ...BOOT_STYLE.row, marginTop: "4px" } }, actions),
+				        );
+				      })));
+				  } else if (state) {
+				    children.push(React.createElement("div", { key: "empty", className: "we-picker__empty" },
+				      React.createElement("span", { className: "we-picker__empty-title" }, weT("没有可用的开机动画")),
+				      React.createElement("span", { className: "we-picker__hint" }, weT("素材来自站点；站点不可达时这里为空，但不影响启动"))));
+				  }
+
+				  return React.createElement(React.Fragment, null, children);
+				}
+
+				function renderBootTab() {
+				  return React.createElement(BootTabPanel, null);
+				}
+
 				// ── 内联模块：src/quick-panel.js —— 快捷播放面板（官方侧栏 tab 与低版本抽屉共用同一份内容）：当前壁纸 + 轮播 + 列表快切 + 声音 + 设置入口。列表虚拟滚动（spacer + 可视窗口）（构建期注入；勿手改本段）──
 				/**
 				 * quick-panel.js — 快捷播放面板（侧边栏的**唯一**内容）：当前壁纸 + 轮播 + 三档页签
@@ -17459,10 +17342,9 @@ window.__ModuleLoader__.load({
 				  // 对照很常见）。与设置页的页签表（PICKER_TABS）是两件事 —— 这里只镜像用户点名要的
 				  // 两页，外加壁纸页。
 				  const QP_TABS = [
+				    // 开机动画放在「壁纸」左边：它和壁纸是并列的两种"开机时看到什么"，不是壁纸的子功能。
+				    { id: "boot", get label() { return weT("开机动画"); } },
 				    { id: "wallpaper", get label() { return weT("壁纸"); } },
-				    // 「皮肤包」与设置页那个页签是**同一个组件**（SkinsTabPanel）：首页这里只是把它挂进抽屉，
-				    // 不另写一份列表逻辑 —— 两份实现迟早会漂移。
-				    { id: "skins", get label() { return weT("皮肤包"); } },
 				    { id: "appearance", get label() { return weT("外观"); } },
 				    { id: "playback", get label() { return weT("播放"); } },
 				  ];
@@ -17590,7 +17472,7 @@ window.__ModuleLoader__.load({
 				      React.createElement("span", { className: "we-qp__item-thumb" },
 				        w.preview
 				          ? React.createElement("img", {
-				              src: w.preview, alt: "", loading: "lazy",
+				              src: w.preview, alt: "", loading: "lazy", decoding: "async",
 				              onError: (e) => { e.target.style.display = "none"; },
 				              onLoad: (e) => { e.target.style.opacity = "1"; },
 				            })
@@ -17618,7 +17500,7 @@ window.__ModuleLoader__.load({
 				    },
 				      w.preview
 				        ? React.createElement("img", {
-				            src: w.preview, alt: "", loading: "lazy",
+				            src: w.preview, alt: "", loading: "lazy", decoding: "async",
 				            onError: (e) => { e.target.style.display = "none"; },
 				            onLoad: (e) => { e.target.style.opacity = "1"; },
 				          })
@@ -17827,7 +17709,17 @@ window.__ModuleLoader__.load({
 				      );
 				  }
 
-				  function qpRenderViewBar(sel, view, typeFilter, ratingFilter, switchView) {
+				  // 来源档（本机 Wallpaper Engine 库 / 我们站点）：与设置页同一个键 `sourceFilter`，
+				  // 同样"两处同步"——这里切，设置页跟着变，反之亦然。只筛列表，不拦正在播的壁纸。
+				  function qpSources() {
+				    return [
+				      { id: "all", label: weT("全部来源") },
+				      { id: "local", label: weT("本机") },
+				      { id: "site", label: weT("站点") },
+				    ];
+				  }
+
+				  function qpRenderViewBar(sel, view, typeFilter, ratingFilter, switchView, sourceFilter) {
 				    return React.createElement("div", { className: "we-qp__viewbar" },
 				      React.createElement("input", {
 				        className: "we-picker__text we-qp__search", type: "text",
@@ -17861,6 +17753,16 @@ window.__ModuleLoader__.load({
 				      },
 				      ...qpTypes().map((t) => React.createElement("option", { key: t.id, value: t.id }, t.label)),
 				      ),
+				      // 来源筛选：本机 Wallpaper Engine 库 vs 我们站点（与设置页同一个键）。
+				      React.createElement("select", {
+				        className: "we-picker__select we-qp__source",
+				        value: sourceFilter,
+				        onChange: (e) => { setSetting("sourceFilter", e.target.value); emit(); },
+				        "aria-label": weT("来源筛选"),
+				        title: weT("按来源筛选：本机 Wallpaper Engine 库，还是从我们站点拉下来的壁纸"),
+				      },
+				      ...qpSources().map((s) => React.createElement("option", { key: s.id, value: s.id }, s.label)),
+				      ),
 				      // 列表 / 卡片：标签式切换（滑动胶囊做激活指示、无分段底 —— 样式见
 				      // .we-qp__viewtabs），偏好记 localStorage（QP_VIEW_KEY），两个壳共用一份。
 				      // 语义仍是开关（role=group + aria-pressed），只是外观走标签形态。
@@ -17926,7 +17828,7 @@ window.__ModuleLoader__.load({
 				    );
 				  }
 
-				  function qpRenderLibrarySection(sel, view, typeFilter, ratingFilter, listRef, rows, cardsView, vTopH, vBtmH, q, switchView) {
+				  function qpRenderLibrarySection(sel, view, typeFilter, ratingFilter, listRef, rows, cardsView, vTopH, vBtmH, q, switchView, sourceFilter) {
 				    return React.createElement("div", { className: "we-qp__section we-qp__library" },
 				      !sel.loaded
 				        ? React.createElement("span", { className: "we-picker__hint" }, weT("扫描 Wallpaper Engine…"))
@@ -17940,7 +17842,7 @@ window.__ModuleLoader__.load({
 				              }, weT(sel.loading ? "刷新中…" : "重试")),
 				            )
 				          : React.createElement(React.Fragment, null,
-				      qpRenderViewBar(sel, view, typeFilter, ratingFilter, switchView),
+				      qpRenderViewBar(sel, view, typeFilter, ratingFilter, switchView, sourceFilter),
 				      qpRenderList(listRef, rows, view, cardsView, vTopH, vBtmH, q, ratingFilter, typeFilter, sel),
 				    ),
 				  );
@@ -18060,8 +17962,11 @@ window.__ModuleLoader__.load({
 				    const ratingFilter = qpRatings().some((r) => r.id === sel.contentRatingFilter)
 				      ? sel.contentRatingFilter : "all";
 				    const playable = playableInventory();
+				    const sourceFilter = qpSources().some((s) => s.id === sel.sourceFilter) ? sel.sourceFilter : "all";
 				    const filtered = playable.filter((w) => {
 				      if (typeFilter !== "all" && w.type !== typeFilter) return false;
+				      // 站点条目带 `source: "folia"`；其余（本机工坊 + 上传）一律算本机。
+				      if (sourceFilter !== "all" && ((w.source === "folia") ? "site" : "local") !== sourceFilter) return false;
 				      if (q && String(w.title || "").toLowerCase().indexOf(q) === -1) return false;
 				      return true;
 				    });
@@ -18096,7 +18001,13 @@ window.__ModuleLoader__.load({
 				    // 设置页同名页签 —— 玻璃详细调节仍只在侧栏（本页，折叠块），设置页那边留玻璃预设、
 				    // 全量配置与**字体节**（三次修订后字体节两档都画）；播放页的出图来源 /
 				    // 实时帧仍住设置页。
-				    const foot = qpTab === "appearance"
+				    const foot = qpTab === "boot"
+				      ? {
+				        label: weT("打开设置 ›"),
+				        target: "",
+				        title: weT("开机动画的全部参数都在侧栏「壁纸引擎」设置里"),
+				      }
+				      : qpTab === "appearance"
 				      ? {
 				        label: weT("更多外观设置 ›"),
 				        target: "appearance",
@@ -18108,17 +18019,11 @@ window.__ModuleLoader__.load({
 				          target: "playback",
 				          title: weT("在设置页打开「播放」页签 —— 出图来源 / 实时帧 / 帧率上限在那里"),
 				        }
-				        : qpTab === "skins"
-				          ? {
-				            label: weT("皮肤包设置 ›"),
-				            target: "skins",
-				            title: weT("在设置页打开「皮肤包」页签 —— 下载 / 切换 / 删除皮肤包"),
-				          }
-				          : {
-				            label: weT("壁纸引擎设置 ›"),
-				            target: "",
-				            title: weT("打开设置对话框的「壁纸引擎」分区（外观 / 播放 / 系统与全部配置）"),
-				          };
+				        : {
+				          label: weT("壁纸引擎设置 ›"),
+				          target: "",
+				          title: weT("打开设置对话框的「壁纸引擎」分区（外观 / 播放 / 系统与全部配置）"),
+				        };
 
 				    return React.createElement("div", { className: "we-qp we-qp--" + dock },
 				      qpRenderCurrent(sel, current, playbackLive),
@@ -18134,7 +18039,9 @@ window.__ModuleLoader__.load({
 				      React.createElement("div", { className: tabBodyClass, ref: qpPaneRef },
 				        qpTab === "wallpaper" && userPropsPanelOpen() && propsAvailable
 				          && React.createElement("div", { className: "we-qp__propsview we-qp__propsview--drill" }, renderUserPropsPanel()),
-				        !(qpTab === "wallpaper" && userPropsPanelOpen() && propsAvailable) && (qpTab === "appearance"
+				        // 开机动画档：整区就是那个面板（它自己管加载/下载/开关）。
+				        qpTab === "boot" && React.createElement(BootTabPanel, null),
+				        !(qpTab === "wallpaper" && userPropsPanelOpen() && propsAvailable) && qpTab !== "boot" && (qpTab === "appearance"
 				          ? qpRenderAppearancePane(sel, {
 				            fontOpen, onToggleFontSection: toggleFontSection,
 				            uiColorOpen, onToggleUiColorSection: toggleUiColorSection,
@@ -18148,15 +18055,12 @@ window.__ModuleLoader__.load({
 				          })
 				          : qpTab === "playback"
 				            ? qpRenderPlaybackPane(sel, switchQpTab)
-				            // 皮肤包：直接挂设置页那个同一个组件（它自己管列表/下载/激活状态）。
-				            : qpTab === "skins"
-				              ? React.createElement(SkinsTabPanel, { onClearWallpaper: () => setSetting("id", "") })
-				              : null),
+				            : null),
 				        !(qpTab === "wallpaper" && userPropsPanelOpen() && propsAvailable) && qpTab === "wallpaper" && React.createElement(React.Fragment, null,
 				                // ── 壁纸列表（搜索 + 视图切换 + 快切）──
 				                // 库还没回来 / 扫描失败：**只有这一页**给一句话 —— 外观 / 播放两页不依赖库，
 				                // 照常可用（不能整块替换掉，那样连外观都进不去）。
-				                qpRenderLibrarySection(sel, view, typeFilter, ratingFilter, listRef, rows, cardsView, vTopH, vBtmH, q, switchView),
+				                qpRenderLibrarySection(sel, view, typeFilter, ratingFilter, listRef, rows, cardsView, vTopH, vBtmH, q, switchView, sourceFilter),
 				                // 声音（与播放页那份同源：同一份渲染器、同一状态）。包一层 .we-qp__section
 				                // 只为保留这一节的分隔线与间距（渲染器自己那份 section 是给设置页排版的）。
 				                React.createElement("div", { className: "we-qp__section" },
@@ -22517,34 +22421,6 @@ window.__ModuleLoader__.load({
 				/** DELETE（多数接口不返回体；需要时传 parse: true）。 */
 				const apiDelete = (path, options) => apiFetch(path, Object.assign({ method: 'DELETE', parse: false }, options));
 
-				/**
-				 * 根相对路径的**原生**请求（**不补 BASE**），返回原始 `Response`（失败给 null）。
-				 *
-				 * 用途：访问**同源其它插件**的路由 —— 典型是皮肤中心的 `/api/skin-center/v2/...`
-				 *（它把皮肤 CSS 做了强制作用域化，只有那条路由给的版本才能压过应用自身规则）。
-				 *
-				 * 为什么必须是**根相对路径**而不是 `location.origin + path`：桌面壳里文档可能跑在
-				 * 自定义协议下（`dsh-app://…`），此时 `location.origin` 是 `"null"`，拼出来的绝对 URL
-				 * 直接作废。`/api/...` 交给浏览器按文档解析，两种协议下都成立 —— 皮肤中心自己的客户端
-				 * 用的也正是这种写法。
-				 *
-				 * @param {string} path 以 `/` 开头的同源路径
-				 * @param {{ method?: string, cache?: string, headers?: object, fetch?: Function }} [options]
-				 * @returns {Promise<Response|null>}
-				 */
-				async function apiRawResponse(path, options) {
-				  const o = options || {};
-				  const doFetch = pickFetch(o.fetch);
-				  if (!doFetch) return null;
-				  const init = { method: o.method || 'GET', cache: o.cache || 'no-store' };
-				  if (o.headers) init.headers = o.headers;
-				  try {
-				    return await doFetch(String(path), init);
-				  } catch {
-				    return null;
-				  }
-				}
-
 				// ── 内联模块：src/occlusion.js —— 遮挡投递：/occlusion 轮询 + 缩放 + postMessage（1Hz，含退避与可见性暂停）（构建期注入；勿手改本段）──
 				/**
 				 * occlusion.js — Linux 壳窗遮挡的**客户端轮询器**：宿主 `/occlusion` 快照 → 画布局部
@@ -25729,38 +25605,6 @@ window.__ModuleLoader__.load({
 		  try { return skinYielded === true; } catch { return false; }
 		}
 
-		/**
-		 * 让路期间把**整张插件样式表**关掉。
-		 *
-		 * 为什么必须关整张：皮肤是一套完整的外观（自己的底色、圆角、字体色、边框）。我们的
-		 * `styles-base.js` 给应用外壳铺透明/玻璃/自定义配色，选择器落在同一批元素上，于是皮肤
-		 * 的规则被我们盖掉 —— 表现就是"皮肤显示不全，关掉插件就完整"。让路态此前只关了玻璃
-		 * 效果族（`data-we-*` 属性门控），**样式表本体一直在**，所以这个洞一直存在。
-		 *
-		 * 用 `sheet.disabled` 而不是摘 `<style>`：摘了再插会触发整页重排；disabled 是零成本开关，
-		 * 退出让路时立刻原样恢复。
-		 */
-		function syncPluginCssForSkin() {
-		  // ⚠️ 默认**不**整表禁用。3.9.0 试过一次"皮肤在台就关掉整张样式表"，代价是：
-		  //    我们的面板失去可读底色，皮肤的底图直接透上来，字全糊 —— 插件等于不能用了。
-		  //    皮肤和壁纸是两个都在重绘整个界面的产品，CSS 层面无法各让一半：整表关掉
-		  //    皮肤完整但我们不可用，整表开着我们可用但皮肤被压。折中只保留"玻璃效果族
-		  //    退场"（它已经由 data-we-* 属性门控），样式表本体始终在 —— 保证可读性优先。
-		  //    需要皮肤完全接管时，用环境变量 DSH_FOLIA_YIELD_CSS=1 显式开启整表让位。
-		  // 前端没有 process.env（那是宿主侧的），开关放在 localStorage：
-		  //   localStorage.setItem("folia.yieldCss", "1") → 刷新后启用整表让位
-		  let want = false;
-		  try { want = window.localStorage.getItem("folia.yieldCss") === "1"; } catch { want = false; }
-		  if (!want) return;
-		  try {
-		    const tag = document.querySelector('style[data-plugin-css="dsh-folia/styles-v3"]');
-		    if (tag === null) return;
-		    const off = skinYieldActive() === true;
-		    if (tag.sheet) tag.sheet.disabled = off;
-		    else tag.disabled = off;
-		  } catch { /* 拿不到 sheet（还在解析 / 被 CSP 拦）就跳过，不影响其它门控 */ }
-		}
-
 		/** 皮肤上台 ⇒ 退场（幂等）。 */
 		function enterSkinYield(reason) {
 		  if (skinYielded) return;
@@ -25775,7 +25619,6 @@ window.__ModuleLoader__.load({
 		  applySelection("");        // 清层：url=null ⇒ syncLayers 摘层 / 遮罩 / data-we-wallpaper
 		  persistSelection();
 		  applyEffects();            // 让路态里玻璃门控整族摘除
-		  syncPluginCssForSkin();    // 连同整张样式表一起让位 —— 否则皮肤被我们的外框盖住（显示不全）
 		  emit();
 		  reportClientDiag("skin-yield", "enter · " + reason + " · restore=" + (skinYieldMemory.id || "-"));
 		}
@@ -25798,7 +25641,6 @@ window.__ModuleLoader__.load({
 		  setSetting("skinYieldRestoreRotation", false);
 		  persistSelection();
 		  applyEffects();
-		  syncPluginCssForSkin();    // 皮肤退场：把我们的样式表原样开回来
 		  emit();
 		  reportClientDiag("skin-yield", "exit · " + reason);
 		}
@@ -25918,7 +25760,6 @@ window.__ModuleLoader__.load({
 		          rotationEnabled: rid ? selection.skinYieldRestoreRotation === true : selection.rotationEnabled === true,
 		        };
 		        applyEffects(); // 认领即刻摘玻璃门控（首次 applyEffects 可能已经跑过）
-		        syncPluginCssForSkin(); // 启动即认领时也要让出样式表：否则一开机皮肤就被外框盖着
 		        reportClientDiag("skin-yield", "adopt · install/dom");
 		      } else if (!document.documentElement.hasAttribute("data-dsh-skin") && !selection.id
 		        && String(selection.skinYieldRestoreId || "")) {
@@ -25940,7 +25781,6 @@ window.__ModuleLoader__.load({
 		    try { unsubAdopt(); } catch { /* ignore */ }
 		    skinYielded = false;
 		    skinYieldMemory = null;
-		    syncPluginCssForSkin(); // 清理后让路态清零 ⇒ 样式表恢复
 		  };
 		}
 
@@ -27211,9 +27051,6 @@ window.__ModuleLoader__.load({
 		const PICKER_TAB_KEY = "dsh-folia:picker-tab";
 		const PICKER_TABS = [
 		  { id: "library", get label() { return weT("壁纸库"); } },
-		  // 「皮肤包」挨着「壁纸库」：两者都是"给背景换东西"，用户心智在同一处。
-		  // 它列的是**自建站**上的皮肤包（宿主端 /skins 族），不是皮肤中心的内置列表。
-		  { id: "skins", get label() { return weT("皮肤包"); } },
 		  { id: "appearance", get label() { return weT("外观"); } },
 		  { id: "playback", get label() { return weT("播放"); } },
 		  { id: "system", get label() { return weT("系统"); } },
@@ -29215,6 +29052,12 @@ window.__ModuleLoader__.load({
 		  setSetting("typeFilter", e.target.value);
 		  revalidateSelection();
 		};
+		// 来源筛选（本机 Wallpaper Engine 库 / 我们站点）：只筛列表与轮播候选，
+		// 与类型档同一个效力 —— 不写进播放闸门，切换不会把正在播的壁纸掐掉。
+		const onSourceFilterChange = (e) => {
+		  setSetting("sourceFilter", e.target.value);
+		  revalidateSelection();
+		};
 		// Card style: classic (CD-rack) vs fixed (overlap-proof).
 		const onLayoutChange = (value) => {
 		  setSetting("pickerLayout", value);
@@ -29759,7 +29602,7 @@ window.__ModuleLoader__.load({
 		  // 标题子串匹配（空查询 = 不过滤），每页 24 张，页号越界自动 clamp。这里只把状态喂
 		  // 进去、把结果取出来 —— 组件体不再就地算这些（分级/类型/隐藏的判定也在那边）。
 		  const {
-		    query, playableList, basePlayable, ratingCounts, typeCounts, hiddenList,
+		    query, playableList, basePlayable, ratingCounts, typeCounts, sourceCounts, hiddenList,
 		    editorPageView,
 		  } = pickerModel({
 		    wallpapers: list,
@@ -29767,6 +29610,7 @@ window.__ModuleLoader__.load({
 		    search: sel.search,
 		    ratingFilter: sel.contentRatingFilter,
 		    typeFilter: sel.typeFilter,
+		    sourceFilter: sel.sourceFilter,
 		    editorPage: sel.editorPage,
 		  });
 		  // CD-rack mode: compact one-page grid (no pagination, no virtualization —
@@ -29830,9 +29674,6 @@ window.__ModuleLoader__.load({
 		      onReopenNotice: () => { noticeReopenRequest = true; emit(); },
 		    });
 		    if (activeTab === "extensions") return renderExtensionsTab(extensionCtx());
-		    // 「皮肤包」自带异步状态（列表 / 下载中 / 错误），所以它是一个**真组件**而不是
-		    // 纯渲染函数 —— 薄包装只负责挂上去（理由见 src/panel-tabs-skins.js 文件头）。
-		    if (activeTab === "skins") return renderSkinsTab({ onClearWallpaper: () => setSetting("id", "") });
 		    if (activeTab === "appearance") return renderAppearanceTab({
 		      setSetting, setTransient,
 		      fontSet: fontSetCtx(),
@@ -29929,10 +29770,10 @@ window.__ModuleLoader__.load({
 		      // 壁纸网格，ESC / 顶部「返回」退出，切页签也会退出（见 switchTab）。
 		      sel.pickerOpen ? renderPickerModal({
 		        sel, closePicker, current, playbackLive, playableList, hiddenList,
-		        cdMode, query, basePlayable, ratingCounts, typeCounts,
+		        cdMode, query, basePlayable, ratingCounts, typeCounts, sourceCounts,
 		        gridRef: pickerGridRef, vwin: pickerVwin,
 		        armedConfirm: sel.armedConfirm, onArmConfirm: armConfirm, onDisarmConfirm: disarmConfirm,
-		        onClear, onRatingFilterChange, onTypeFilterChange,
+		        onClear, onRatingFilterChange, onTypeFilterChange, onSourceFilterChange,
 		        onShowNormalView, onShowHiddenView,
 		        onToggleBatchMode, onArmBatchHide, onBatchHide, onBatchCancel, onSearchInput, onPickCard,
 		      }) : React.createElement(React.Fragment, null,