balance-dsh 2.0.2 → 2.0.3

package/lib/client.js

@@ -36,7 +36,7 @@ window.__ModuleLoader__.load({
    整串按字符切成格子，只有值真正变了的格子才画三层（影子撑尺寸 / 旧字上滑出 / 新字下滑入），
    没变的字符就是普通文本 —— 所以花掉 0.01 只有末位在翻，小数点和高位数字纹丝不动。
    外层 overflow:hidden 把滑动部分裁在字高内，读起来像机械计数器过位。 */
-.balance-footer__roll{display:inline-flex;align-items:baseline;white-space:pre}
+.balance-footer__roll{display:inline-flex;align-items:baseline;white-space:pre;flex:none}
 .balance-footer__dcell{display:inline-block;vertical-align:bottom;white-space:pre}
 .balance-footer__dcell--roll{position:relative;overflow:hidden}
 .balance-footer__dghost{display:block;visibility:hidden;white-space:pre}
@@ -58,7 +58,24 @@ window.__ModuleLoader__.load({
 /* 旧版余额行用到的图标与「余额」二字（footerStyle === "classic" 时才渲染） */
 .balance-footer__icon{display:inline-flex;flex:none;color:var(--dsw-alias-label-primary)}
 .balance-footer__label{flex:none;color:var(--dsw-alias-label-primary)}
-.balance-footer__value{position:relative;z-index:0;isolation:isolate;display:inline-flex;align-items:center;font-variant-numeric:tabular-nums;font-weight:600;font-size:16px;line-height:1;white-space:nowrap;padding:7px 14px;border-radius:999px;corner-shape:round;margin-left:0;margin-right:6px;text-decoration:none;cursor:pointer;transition:transform .15s var(--ds-ease-in-out,.2s);flex:none}
+.balance-footer__value{box-sizing:border-box;position:relative;z-index:0;isolation:isolate;display:inline-flex;align-items:center;justify-content:center;font-variant-numeric:tabular-nums;font-weight:600;font-size:16px;line-height:1;white-space:nowrap;padding:7px 14px;border-radius:999px;corner-shape:round;margin-left:auto;margin-right:4px;text-decoration:none;cursor:pointer;transition:transform .15s var(--ds-ease-in-out,.2s);flex:none;/* 宽度恒定 121px：靠「固定 px + 位数多就缩字号」两条一起实现。
+   ⚠️ 开头的 box-sizing:border-box 是前提，不能省：min-width 默认算的是「内容盒」，
+   少了它 121px 会变成 121 + 左右 padding 28px = 149px 总宽，胶囊凭空胖一圈
+   （用户反馈「我的余额胶囊为什么这么长」，真实客户端实测正是 149px）。DSH 页面上
+   没有全局 border-box，刻度条 / 去充值 / FAB 都各自显式写了，只有这一处漏过。
+   胶囊内容是 total_balance + " " + currency（见 totalText），16px 粗体实测天然宽度：
+     0.00 CNY 105.6 · 10.32 CNY 111.5 · 100.00 CNY 121.4 · 1234.56 CNY 131.3 · 12345.67 CNY 141.1
+   余额 10.32 -> 9.87 少一个整数位就窄 6px，胶囊会跳（用户反馈「从10块掉到9块时
+   余额胶囊宽度变了」）；而四位数以上又会反过来撑宽、把右边挤出容器。
+   所以：0~999.99 用 16px + min-width 撑到 121px；超过四位数自动降字号
+   （--dense 13px / --dense2 11.5px），缩回 121px 以内。两端都恒定。
+   ⚠️ min-width 必须用 px 不能用 em：em 相对自身 font-size，一缩字号锁定宽度也跟着缩，
+   宽度照样跳。也别按「¥14.34 • 空闲」这种臆想格式去量 —— timeline 胶囊里只有
+   金额+货币码，先前按假格式算出 6.6em 恰好等于 0.00 CNY 的天然宽度，对任何值都不生效（踩过）。
+   justify-content:flex-end 让内容靠右，位数少时留白落在左边。 */min-width:112px}
+/* 余额位数多时降档，配合上面的固定宽度，让长金额也收在 121px 内 */
+.balance-footer__value--dense{font-size:13px}
+.balance-footer__value--dense2{font-size:11.5px}
 .balance-footer__value:hover{filter:brightness(.85);transform:scale(1.06)}
 /* 旧版布局：胶囊靠右 —— 这是备份 v1.3.1 里的原始写法（margin-left:auto）。
    不能放到基础规则上，新版 timeline 用 margin:0 auto 居中，会和它打架。 */
@@ -79,18 +96,40 @@ window.__ModuleLoader__.load({
 /* 时段刻度条：色带固定 = 一整天，指针随时刻从左走到右。
    结构：[meta 行(今日/时段/剩余)] + [轨道(边框) → 裁剪层(1px 内缩 → 泛光 + 色带) + 指针]。
    轨道刻意做扁（20px 压到 13px），上方留一行给文字，整块像个"仪表盘"而不是"进度胶囊"。 */
-.balance-footer__timeline{position:relative;z-index:0;display:inline-flex;flex-direction:column;align-items:center;gap:4px;flex:none;white-space:nowrap;margin:0 auto}
-/* meta 行：等宽数字，三项之间用中点分隔感靠 gap 制造 */
-.balance-footer__timeline-meta{display:inline-flex;align-items:center;gap:6px;font-size:11px;line-height:1;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-tertiary,#8a8a8a);margin:0}
+.balance-footer__timeline{position:relative;z-index:0;display:inline-flex;flex-direction:column;align-items:center;gap:4px;flex:1 1 auto;min-width:0;white-space:nowrap;margin:0;overflow:hidden}
+/* meta 行：等宽数字，三项之间用中点分隔感靠 gap 制造。
+   三项都 flex:none、都 nowrap，所以这一行只会随内容变宽、永不主动收缩 ——
+   「今日 ¥1234.56」比「今日 ¥14.34」宽两三个数字位，余额胶囊又同时要宽度，
+   两者硬碰硬时右侧胶囊会被挤出容器裁掉（余额四位数 + 消费四位数就能复现）。
+   所以给它 max-width + flex-wrap：空间不够时三项自己折行，块变高（--stacked 是
+   height:auto，撑得住），而不是把胶囊顶出去。 */
+.balance-footer__timeline-meta{display:inline-flex;align-items:center;gap:6px;row-gap:3px;flex-wrap:wrap;justify-content:center;max-width:100%;font-size:11px;line-height:1;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-tertiary,#8a8a8a);margin:0}
 .balance-footer__timeline-meta-item{flex:none;white-space:nowrap}
+/* 「今日 ¥x」独占第一行（flex-basis:100%），于是下面那行永远是「空闲 剩 3h57m」。
+   不加这条时宽度够就会并成一行，用户看到的顺序就变成「今日 … 空闲 剩 …」，
+   得不到他要的「空闲跟剩余时间一栏」（2026-10-30 指定）。
+   ⚠️ 必须配 text-align:center：占满 100% 之后默认是左对齐，而下面那行 group 是居中的，
+   两行就会错开（2026-10-30 反馈「今日消费位置不对」）。 */
+.balance-footer__timeline-meta-item--today{flex:0 0 100%;text-align:center}
+/* meta 的第二段（时段词 + 剩余时间）作为一个整体不拆开：折行时它整段落到
+   「今日 ¥x」下面那行，于是「空闲」永远和「剩 3h57m」同行。 */
+.balance-footer__timeline-meta-group{display:inline-flex;align-items:center;gap:6px;flex:0 1 auto;min-width:0;white-space:nowrap;max-width:100%}
 /* 时段词单独上色：高峰红、空闲绿（其余两项保持中性灰，避免整行花掉） */
 .balance-footer__timeline-meta-item--peak{font-weight:600;color:var(--dsw-alias-state-error-primary,#e5484d)}
 .balance-footer__timeline-meta-item--offpeak{font-weight:600;color:var(--dsw-alias-state-success-primary,#22c55e)}
-.balance-footer__timeline-track{position:relative;display:inline-block;box-sizing:border-box;width:145px;height:15px;border:2px solid color-mix(in srgb,var(--dsw-alias-label-tertiary,#8a8a8a) 70%,transparent);border-radius:999px;corner-shape:round;flex:none}
+/* ⚠️ 需要「实心彩底 + 白字」的地方一律用硬编码 #4d6bfe，不要用 var(--dsw-alias-brand-primary)。
+   实测（2026-10-30 用户截图）：DSH 暗色主题里这个变量的值是**接近纯白**的 ——
+   官方拿它画 toggle 开关和分组竖条，所以那些地方保持白色才对；
+   但套在「白底 + 白字」的徽标上就彻底看不见（用户反馈「NEW 标签还有 bug」）。 */
+/* 轨道外框 1px（原 2px）：2px 在 15px 高的条上显得笨重，压住里面彩色时段。
+   边框只负责描边，色带与描边之间的空隙由下面 clip 的 1px 内缩提供。 */
+.balance-footer__timeline-track{position:relative;display:block;box-sizing:border-box;width:100%;max-width:100%;height:15px;margin:0;border:1px solid color-mix(in srgb,var(--dsw-alias-label-tertiary,#8a8a8a) 70%,transparent);border-radius:999px;corner-shape:round;flex:none}
 /* 描边统一中性灰：时段已经由 meta 行的「高峰 / 空闲」文字给出，
    轨道再上色就是同一信息说三遍，还会和色带里的红绿抢注意力。
    类名保留（--peak / --offpeak 仍在 JSX 上），将来想恢复彩色描边直接补规则即可。 */
-/* 内嵌裁剪层：四边各让 1px，色带裁在这里，颜色与边框之间留一线空隙 */
+/* 内嵌裁剪层：四边各让 1px，色带裁在这里，颜色与边框之间留一线空隙。
+   注意这 1px 是**独立的视觉空隙**，不是给边框让位 —— 边框改窄（2px→1px）时
+   它必须留着，否则色带会直接贴到描边上，看起来糊成一整块。 */
 .balance-footer__timeline-clip{position:absolute;left:1px;right:1px;top:1px;bottom:1px;overflow:hidden;border-radius:999px;corner-shape:round;isolation:isolate}
 /* 泛光层：同一渐变模糊后叠在色带**上面**，靠模糊边缘往外散光。
    刻意不用 screen 混合、也不把 brightness 拉太高——那会把 #e5484d 推成粉白，
@@ -98,16 +137,20 @@ window.__ModuleLoader__.load({
 .balance-footer__timeline-glow{position:absolute;left:-3px;right:-3px;top:-3px;bottom:-3px;pointer-events:none;filter:blur(3px) saturate(1.5) brightness(1.15);opacity:.45;z-index:2}
 /* 色带本身：不透明 + 轻微提饱和，颜色是主角 */
 .balance-footer__timeline-band{position:absolute;left:0;top:0;right:0;bottom:0;pointer-events:none;filter:saturate(1.25) brightness(1.12);z-index:1}
-.balance-footer__timeline-pointer{position:absolute;top:-1px;bottom:-1px;width:2px;margin-left:-1px;background:var(--dsw-alias-label-primary,#fff);box-shadow:0 0 3px rgba(255,255,255,.7),0 0 2px rgba(0,0,0,.55);pointer-events:none;z-index:2;transition:left 60s linear}
+/* 指针位置由 JS 每 500ms 直接写（见 BalanceFooter 里的 pointerRef effect），刻意不用 transition：
+   一天走完 100%，每分钟才 0.069%（200px 轨道上 0.14px），过渡的连续性完全依赖浏览器
+   是否继续推进动画时钟——后台标签页会把过渡暂停，切回来时指针直接落到终点，那就是
+   用户看到的「瞬移」。逐帧写 left 才是绝对连续的，跨零点也自然回到起点。 */
+.balance-footer__timeline-pointer{position:absolute;top:-1px;bottom:-1px;width:2px;margin-left:-1px;background:var(--dsw-alias-label-primary,#fff);box-shadow:0 0 3px rgba(255,255,255,.7),0 0 2px rgba(0,0,0,.55);pointer-events:none;z-index:2}
 /* ── 侧栏入口的红点 + 未读高亮 ─────────────────────────────────────────── */
 .balance-panel-icon{position:relative;display:inline-flex;align-items:center;justify-content:center}
 /* 未读时图标本身染成品牌色，比周围灰图标更跳 */
-.balance-panel-icon--unread{color:var(--dsw-alias-brand-primary,#4d6bfe)}
+.balance-panel-icon--unread{color:#4d6bfe}
 /* 红点：贴在图标右上角，深色描边保证在任意底色上都看得清 */
 .balance-panel-icon__dot{position:absolute;top:-2px;right:-3px;box-sizing:border-box;width:7px;height:7px;border-radius:50%;corner-shape:round;background:var(--dsw-alias-state-error-primary,#e5484d);box-shadow:0 0 0 1.5px var(--dsw-alias-bg-module-platform,var(--dsw-alias-base,#1b1b1c)),0 0 5px 1px color-mix(in srgb,var(--dsw-alias-state-error-primary,#e5484d) 65%,transparent);animation:balance-dot-pulse 2.2s ease-in-out infinite}
 /* 有新版本时的文字提示：品牌色实心小胶囊，绝对定位压在图标右上，
    视觉上落在「余额与用量」几个字的上方。不做脉冲 —— 那是红点的语言，且静止更醒目。 */
-.balance-panel-icon__new{position:absolute;left:10px;top:-10px;box-sizing:border-box;padding:1px 4px;border-radius:999px;corner-shape:round;background:var(--dsw-alias-brand-primary,#4d6bfe);color:var(--dsw-alias-label-primary-foreground,#fff);font-size:8.5px;line-height:11px;font-weight:600;letter-spacing:.1px;white-space:nowrap;pointer-events:none;box-shadow:0 1px 4px color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 55%,transparent)}
+.balance-panel-icon__new{position:absolute;left:10px;top:-10px;box-sizing:border-box;padding:1px 4px;border-radius:999px;corner-shape:round;background:#4d6bfe;color:var(--dsw-alias-label-primary-foreground,#fff);font-size:8.5px;line-height:11px;font-weight:600;letter-spacing:.1px;white-space:nowrap;pointer-events:none;box-shadow:0 1px 4px color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 55%,transparent)}
 @keyframes balance-dot-pulse{0%,100%{transform:scale(1);opacity:1}50%{transform:scale(.82);opacity:.72}}
 @media (prefers-reduced-motion:reduce){.balance-panel-icon__dot{animation:none}}
 /* ── 侧栏面板页（点左侧「余额与用量」后渲染在主区域） ──────────────────── */
@@ -278,14 +321,16 @@ window.__ModuleLoader__.load({
    先前用的是实心品牌色渐变 + 白字 + 三层强光晕，
    在深色设置页里太刺眼（2026-10-30 反馈「太亮了」）。
    现在：品牌色 18% 薄底 + 6px 弱光晕，呼吸幅度也收窄。 */
-.balance-settings__new-badge{flex:none;box-sizing:border-box;padding:0 5px;border-radius:5px;corner-shape:round;font-size:9px;line-height:14px;font-weight:700;letter-spacing:.4px;text-transform:uppercase;color:color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 62%,#ffffff);background:color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 18%,transparent);animation:balance-new-glow 3.2s ease-in-out infinite}
+/* NEW 徽标：实心品牌蓝 + 白字。原先用 color-mix 调淡（62% 蓝 + 38% 白字、18% 底），
+   实测在客户端里淡到看起来就是一行白字，用户反馈「没颜色」—— 小尺寸下必须给足饱和度。 */
+.balance-settings__new-badge{flex:none;box-sizing:border-box;padding:0 5px;border-radius:5px;corner-shape:round;font-size:9px;line-height:14px;font-weight:700;letter-spacing:.4px;text-transform:uppercase;color:#fff;background:#4d6bfe;animation:balance-new-glow 3.2s ease-in-out infinite}
 /* 呼吸式光晕：只有两层，最大 7px / 32%，足以有「光」的感觉但不刺眼 */
 @keyframes balance-new-glow{
-  0%,100%{box-shadow:0 0 4px color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 18%,transparent),0 0 8px color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 8%,transparent)}
-  50%{box-shadow:0 0 7px color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 32%,transparent),0 0 14px color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 14%,transparent)}
+  0%,100%{box-shadow:0 0 4px color-mix(in srgb,#4d6bfe 22%,transparent),0 0 8px color-mix(in srgb,#4d6bfe 10%,transparent)}
+  50%{box-shadow:0 0 7px color-mix(in srgb,#4d6bfe 40%,transparent),0 0 14px color-mix(in srgb,#4d6bfe 18%,transparent)}
 }
 /* 尊重减少动态效果：不呼吸，保持平均亮度 */
-@media (prefers-reduced-motion:reduce){.balance-settings__new-badge{animation:none;box-shadow:0 0 5px color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 24%,transparent)}}
+@media (prefers-reduced-motion:reduce){.balance-settings__new-badge{animation:none;box-shadow:0 0 5px color-mix(in srgb,#4d6bfe 28%,transparent)}}
 .balance-settings__row{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:11px 0}
 /* 行与行之间用半像素淡线分开，避免几行文字堆成一片 */
 .balance-settings__row + .balance-settings__row{border-top:.5px solid var(--dsw-alias-border-l1,rgba(127,127,127,.12))}
@@ -294,11 +339,24 @@ window.__ModuleLoader__.load({
 .balance-settings__hint{font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}
 .balance-settings__control{display:flex;align-items:center;gap:6px;flex:none}
 .balance-settings__unit{font-size:12px;color:var(--dsw-alias-label-tertiary)}
-.balance-settings__input{box-sizing:border-box;width:96px;height:34px;padding:0 10px;text-align:right;font-variant-numeric:tabular-nums;border:.5px solid var(--dsw-alias-border-l4,rgba(127,127,127,.35));border-radius:var(--dsw-radius-md,8px);background:var(--dsw-alias-bg-layer-3,rgba(127,127,127,.1));color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;font-variant-numeric:tabular-nums;outline:none}
+/* 文本类输入：数字框那套 96px + 右对齐会把「9-12, 14-18」截掉，单独放宽并左对齐 */
+.balance-settings__input--text{width:132px;text-align:left;font-variant-numeric:normal;letter-spacing:.2px}
+.balance-settings__input--text::placeholder{color:var(--dsw-alias-label-tertiary)}/* 输入框底色照抄 DSH 官方设置页（dsh-client-ui-settings-models 的 input 规则）：
+   那边用 --dsw-alias-bg-layer-1，不是 layer-3。深色主题下三层分别是
+   bg-layer-1 #232324 / bg-layer-2 #2c2c2e / bg-layer-3 #353638，页面底 bg-base #151517 —
+   用 layer-3 比底色亮 32 级，在设置卡片里就是一块发闷的灰板（用户反馈「那个框的颜色太灰了」）。
+   layer-1 只亮 14 级，和官方观感一致；浅色主题下 layer-1 = #fff 与底色同色，
+   层次完全靠 .5px 的 border-l4 撑，这也是官方那套的样子。 */
+.balance-settings__input{box-sizing:border-box;width:96px;height:34px;padding:0 10px;text-align:right;font-variant-numeric:tabular-nums;border:.5px solid var(--dsw-alias-border-l4,rgba(127,127,127,.35));border-radius:var(--dsw-radius-md,8px);background:var(--dsw-alias-bg-layer-1,rgba(127,127,127,.06));color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;font-variant-numeric:tabular-nums;outline:none}
 .balance-settings__input:focus-visible{outline:none;border-color:var(--dsw-alias-state-business-primary,#4d6bfe)}
 .balance-settings__input--wide{width:100%;max-width:340px;min-width:0;text-align:left}
 /* 关掉侧边栏入口后的提醒：壳用 DSH 官方 Modal，这里只留正文排版。 */
 .balance-tip-body{margin:0;font-size:13px;line-height:1.7;color:var(--dsw-alias-label-secondary)}
+/* 节假日数据行：右侧是「状态文案 + 立即同步」两段，窄屏时自动换行靠右。 */
+.balance-settings__calendar{display:flex;align-items:center;gap:8px;flex-wrap:wrap;justify-content:flex-end}
+.balance-settings__calendar-note{font-size:11.5px;line-height:17px;color:var(--dsw-alias-label-tertiary);text-align:right;font-variant-numeric:tabular-nums;max-width:200px}
+.balance-settings__calendar-note--warn{color:var(--dsw-alias-state-warn-primary,#d97706)}
+.balance-settings__calendar-note--error{color:var(--dsw-alias-state-error-primary,#e5484d)}
 .balance-tip-ok{padding:5px 14px;border:.5px solid transparent;border-radius:var(--dsw-radius-md,8px);background:var(--dsw-alias-label-primary);color:var(--dsw-alias-bg-layer-3);font:inherit;font-size:13px;line-height:1.5;cursor:pointer}
 .balance-tip-ok:hover{opacity:.88}
 .balance-settings__toggle{position:relative;box-sizing:border-box;flex:none;width:36px;height:20px;padding:2px;border:none;border-radius:999px;corner-shape:round;background:var(--dsw-alias-border-l3,rgba(127,127,127,.35));cursor:pointer;transition:background .12s ease}
@@ -314,13 +372,13 @@ window.__ModuleLoader__.load({
    默认是中性底色，只在「有新版本」时提亮成品牌色、「刚更新完」时转成功色，
    失败不染色（网络波动不该看起来像错误告警）。 */
 .balance-settings__update{margin:0 0 16px;padding:11px 13px;border-radius:var(--dsw-radius-md,8px);border:.5px solid var(--dsw-alias-border-l2,rgba(127,127,127,.22));background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.1))}
-.balance-settings__update--newer{border-color:color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 34%,transparent);background:color-mix(in srgb,var(--dsw-alias-brand-primary,#4d6bfe) 12%,transparent)}
+.balance-settings__update--newer{border-color:color-mix(in srgb,#4d6bfe 42%,transparent);background:color-mix(in srgb,#4d6bfe 14%,transparent)}
 .balance-settings__update--done{border-color:color-mix(in srgb,var(--dsw-alias-state-success-primary,#22c55e) 34%,transparent);background:color-mix(in srgb,var(--dsw-alias-state-success-primary,#22c55e) 11%,transparent)}
 .balance-settings__update-head{display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap}
 .balance-settings__update-title{display:flex;align-items:center;gap:7px;min-width:0;font-size:12.5px;line-height:18px;color:var(--dsw-alias-label-secondary)}
 .balance-settings__update-ver{font-weight:600;color:var(--dsw-alias-label-primary);font-variant-numeric:tabular-nums}
 /* 新版徽标：实心品牌色胶囊，形状必须是正圆角（DSH 全局把圆角改成 superellipse 了） */
-.balance-settings__update-badge{flex:none;padding:1px 7px;border-radius:999px;corner-shape:round;background:var(--dsw-alias-brand-primary,#4d6bfe);color:#fff;font-size:11px;font-weight:600;line-height:16px;white-space:nowrap}
+.balance-settings__update-badge{flex:none;padding:1px 7px;border-radius:999px;corner-shape:round;background:#4d6bfe;color:#fff;font-size:11px;font-weight:600;line-height:16px;white-space:nowrap}
 .balance-settings__update-btns{display:flex;align-items:center;gap:6px;flex:none}
 /* 查询中的进度文案：跟按钮同一行、排在左边，灰一点，不跟主文案抢注意力。 */
 .balance-settings__update-busy{flex:none;font-size:11.5px;line-height:17px;color:var(--dsw-alias-label-tertiary);white-space:nowrap}
@@ -333,7 +391,7 @@ window.__ModuleLoader__.load({
 .balance-settings__status{flex:1;min-width:0;font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}
 .balance-settings__status--error{color:var(--dsw-alias-state-error-primary,#e5484d)}
 .balance-settings__status--ok{color:var(--dsw-alias-state-success-primary,#22c55e)}
-.balance-settings__btn{box-sizing:border-box;flex:none;padding:5px 14px;border:.5px solid var(--dsw-alias-border-l2,rgba(127,127,127,.28));border-radius:var(--dsw-radius-md,8px);background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.1));color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;line-height:1.5;cursor:pointer;transition:background .12s ease,border-color .12s ease,opacity .12s ease}
+.balance-settings__btn{box-sizing:border-box;flex:none;white-space:nowrap;padding:5px 14px;border:.5px solid var(--dsw-alias-border-l2,rgba(127,127,127,.28));border-radius:var(--dsw-radius-md,8px);background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.1));color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;line-height:1.5;cursor:pointer;transition:background .12s ease,border-color .12s ease,opacity .12s ease}
 .balance-settings__btn:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-active,rgba(127,127,127,.18))}
 .balance-settings__btn:disabled{opacity:.4;cursor:default}
 .balance-settings__btn--primary{border-color:transparent;background:var(--dsw-alias-label-primary);color:var(--dsw-alias-bg-layer-3)}
@@ -613,6 +671,37 @@ window.__ModuleLoader__.load({
       { start: 14, end: 18 },
     ];
     const PEAK_WEEKDAYS = [1, 2, 3, 4, 5]; // 1=周一 … 5=周五，0/6=周末
+
+    // 生效中的高峰窗口。默认 = 官方当前口径，但设置里的「高峰时段」一改就换成用户的。
+    // **判定（currentPeriod）和刻度（periodBounds）都必须读 activePeakWindows**，
+    // 直接读 PEAK_WINDOWS 会让改了设置的人看到标签和刻度条对不上。
+    let activePeakWindows = PEAK_WINDOWS;
+
+    /** "9-12, 14-18" → [{start,end}]。与服务端 parsePeakWindowsText 同规则：
+     *  逐段校验，任何一段不合法整串作废（返回 null），宁可回退默认窗口也不错算。 */
+    function parsePeakWindowsText(text) {
+      if (typeof text !== "string") return null;
+      const out = [];
+      for (const chunk of text.split(/[,，;；]/)) {
+        const part = chunk.trim();
+        if (part === "") continue;
+        const m = part.match(/^(\d{1,2})\s*[-~到至]\s*(\d{1,2})$/);
+        if (!m) return null;
+        const start = Number(m[1]);
+        const end = Number(m[2]);
+        if (!Number.isInteger(start) || !Number.isInteger(end)) return null;
+        if (start < 0 || end > 24 || start >= end) return null;
+        out.push({ start, end });
+      }
+      return out.length > 0 ? out : null;
+    }
+
+    /** 应用设置里的窗口文本；解析失败保持当前窗口不动（不因为半截输入把标签打乱）。 */
+    function applyPeakWindowsText(text) {
+      const parsed = parsePeakWindowsText(text);
+      if (parsed !== null) activePeakWindows = parsed;
+      return activePeakWindows;
+    }
     // 中国大陆法定节假日与调休（北京时区）。**必须与 lib/index.js 的 CN_CALENDAR 完全一致**
     // （服务端负责算钱、客户端只负责显示时段标签）。来源：国办发明电〔2025〕7号，每年需补录。
     const CN_CALENDAR = {
@@ -641,23 +730,32 @@ window.__ModuleLoader__.load({
 
     // 节假日自动补录：与 lib/index.js 同源、同逻辑（客户端只用来显示时段标签）。
     // 拉取失败静默 —— 拿不到就继续用上面的内置表。
-    const CN_CALENDAR_SOURCE = "https://cdn.jsdelivr.net/gh/NateScarlet/holiday-cn@master";
+    // 与服务端同一份多源列表：某个 CDN 不通就换下一个。
+const CN_CALENDAR_SOURCES = [
+  "https://fastly.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+  "https://gcore.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+  "https://raw.githubusercontent.com/NateScarlet/holiday-cn/master",
+  "https://cdn.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+];
     const cnCalendarYears = new Set();
     async function ensureCnCalendar(year) {
       if (cnCalendarYears.has(year)) return;
       cnCalendarYears.add(year); // 先占位，避免并发重复请求
-      try {
-        const res = await fetch(CN_CALENDAR_SOURCE + "/" + year + ".json", { signal: AbortSignal.timeout(8000) });
-        if (!res.ok) return;
-        const data = await res.json();
-        if (!Array.isArray(data?.days)) return;
-        for (const item of data.days) {
-          if (item && typeof item.date === "string" && typeof item.isOffDay === "boolean") {
-            CN_CALENDAR[item.date] = item.isOffDay ? "holiday" : "workday";
+      for (const base of CN_CALENDAR_SOURCES) {
+        try {
+          const res = await fetch(base + "/" + year + ".json", { signal: AbortSignal.timeout(6000) });
+          if (!res.ok) continue;
+          const data = await res.json();
+          if (!Array.isArray(data?.days)) continue;
+          for (const item of data.days) {
+            if (item && typeof item.date === "string" && typeof item.isOffDay === "boolean") {
+              CN_CALENDAR[item.date] = item.isOffDay ? "holiday" : "workday";
+            }
           }
+          return;
+        } catch {
+          // 这个源连不上：换下一个；全挂就保留内置表
         }
-      } catch {
-        // 网络不可用：保留内置表
       }
     }
     {
@@ -738,7 +836,7 @@ window.__ModuleLoader__.load({
       const weekday = d.getUTCDay(); // 0=周日 … 6=周六
       // 与服务端 isPeakAt 同口径：官方定价页把「周末及法定节假日全天」都算空闲，
       // 没有调休例外，所以 workday（调休上班的周末）也按周末处理。
-      return PEAK_WEEKDAYS.includes(weekday) && PEAK_WINDOWS.some((w) => hour >= w.start && hour < w.end) ? "peak" : "offpeak";
+      return PEAK_WEEKDAYS.includes(weekday) && activePeakWindows.some((w) => hour >= w.start && hour < w.end) ? "peak" : "offpeak";
     }
     const BEIJING_OFFSET_MS = 8 * 60 * 60 * 1000;
     /** 当前时段的区间与剩余时间（供刻度条上方那行 meta 用）。
@@ -755,7 +853,7 @@ window.__ModuleLoader__.load({
       let end = null;
       if (kind === "peak") {
         const h = (now - dayStart) / HOUR;
-        for (const w of PEAK_WINDOWS) {
+        for (const w of activePeakWindows) {
           if (h >= w.start && h < w.end) {
             start = dayStart + w.start * HOUR;
             end = dayStart + w.end * HOUR;
@@ -792,17 +890,44 @@ window.__ModuleLoader__.load({
       const rh = h % 24;
       return rh === 0 ? d + "d" : d + "d" + rh + "h";
     }
+    /**
+     * 余额位数多时返回降字号用的 class（空串 = 不降）。
+     *
+     * 胶囊的宽度是固定的 121px（.balance-footer__value 的 min-width），正常 16px 字号
+     * 能容纳到「999.99 CNY」（121.4px 天然宽度，实测）。整数位一旦到 4 位，
+     * 天然宽度就超过固定宽度（1234.56 CNY = 131.3px），会把胶囊撑出侧栏右缘 ——
+     * 所以按整数位数降一档字号，让它重新收回 121px 以内。
+     *
+     * 按「整数位数」而不是整串字符数判断：`¥` 前缀、货币码长短、有没有小数都会
+     * 干扰字符数，但整数位数就是金额量级本身，判断最稳。
+     * 负数（理论上不会出现）先剥掉符号再数，免得 "-" 被算成一个数位。
+     */
+    function amountDensity(raw) {
+      const text = String(raw ?? "");
+      const intPart = text.split(".")[0].replace(/\D/g, "");
+      if (intPart.length >= 7) return " balance-footer__value--dense2";
+      if (intPart.length >= 3) return " balance-footer__value--dense";
+      return "";
+    }
     // ─── 时段刻度条：色带固定 = 一整天，指针随时刻从左走到右 ────────────────
     // 轨道铺满当天 00:00 → 次日 00:00 的时段色带（不滚动），指针位置 = 现在时刻在当天的比例。
-    // 指针每 20s 前进一次，CSS transition 补成连续滑动；跨零点时自动跳到新一天的起点。
+    // 指针每秒前进一次（pointerNow 独立节拍），CSS transition:left 1s linear 补成连续滑动；
+    // 跨零点那一帧用 --snap 关掉过渡，直接落到新一天的起点。
     const DAY_MS = 24 * 3600000;
+    /** 当天 00:00（北京时间）的毫秒时间戳。色带、指针、跨零点判定共用同一个基准。 */
+    function dayStartOf(now) {
+      return Math.floor((now + BEIJING_OFFSET_MS) / DAY_MS) * DAY_MS - BEIJING_OFFSET_MS;
+    }
+    /** 此刻在一整天里的百分比位置（0 → 100）。指针每秒调它一次。 */
+    function pointerPercent(now) {
+      return ((now - dayStartOf(now)) / DAY_MS) * 100;
+    }
     /** 生成刻度条：当天色带渐变 + 时段文字 + 指针位置。
      *  @returns {{ gradient: string, pointerPct: number }} */
     function buildTimeline(now) {
       const HOUR = 3600000;
       // 当天 00:00（北京时间）。BEIJING_OFFSET_MS 东为正，先平移到北京再取整到天。
-      const bj = now + BEIJING_OFFSET_MS;
-      const dayStart = Math.floor(bj / DAY_MS) * DAY_MS - BEIJING_OFFSET_MS;
+      const dayStart = dayStartOf(now);
       const dayEnd = dayStart + DAY_MS;
       // 逐小时采样找出切换点（官方时段都在整点切换，1 小时精度足够）
       const stops = [];
@@ -869,6 +994,7 @@ window.__ModuleLoader__.load({
       fabLeft: 44,
       statsSessionLimit: 200,
       statsCacheSec: 300,
+      peakWindowsText: "9-12, 14-18",
       peakMultiplier: 2,
       priceFlash: null,
       pricePro: null,
@@ -878,6 +1004,83 @@ window.__ModuleLoader__.load({
     const settingsListeners = new Set();
     let settingsInFlight = null;
 
+    // 节假日数据（服务端 /balance-api?calendar=1 同步的那份）。
+    // 必须把服务端下发的 days 合进客户端自己的 CN_CALENDAR —— 否则服务端按新公告算钱、
+    // 客户端高峰/空闲标签还按内置表，同一时刻两边口径会打架。
+    // missing = 服务端「连上了但还没公布」的年份（典型：次年放假安排要等国务院年底发）。
+    // 只用于在设置页提示「2027 待公布」，不参与峰谷判定。
+    let calendarCache = { fetchedAt: 0, years: [], missing: [], count: 0, loaded: false };
+    let calendarInFlight = null;
+
+    /** 把服务端的 days 明细（YYYY-MM-DD → holiday/workday）合并进本地日历表。 */
+    function applyCalendarDays(days) {
+      if (!days || typeof days !== "object") return;
+      let merged = 0;
+      for (const [date, kind] of Object.entries(days)) {
+        if (typeof date === "string" && (kind === "holiday" || kind === "workday")) {
+          CN_CALENDAR[date] = kind;
+          merged += 1;
+        }
+      }
+      return merged;
+    }
+
+    function adoptCalendar(data) {
+      calendarCache = {
+        fetchedAt: Number(data.fetchedAt) || 0,
+        years: Array.isArray(data.years) ? data.years.map(Number).filter((y) => Number.isFinite(y)) : [],
+        missing: Array.isArray(data.missing) ? data.missing.map(Number).filter((y) => Number.isFinite(y)) : [],
+        count: Number(data.count) || 0,
+        loaded: true,
+      };
+      applyCalendarDays(data.days);
+      // 峰谷判定变了 → 让订阅者（余额行标签、消耗行、设置卡片）都重画
+      emitSettings();
+      return calendarCache;
+    }
+
+    /** 读服务端节假日状态（并发合并）。失败静默 —— 拿不到就继续用内置表。 */
+    function fetchCalendarStatus() {
+      if (calendarInFlight !== null) return calendarInFlight;
+      calendarInFlight = (async () => {
+        try {
+          const res = await fetch("/balance-api?calendar=1", { headers: { accept: "application/json" } });
+          if (!res.ok) return calendarCache;
+          const data = await res.json();
+          if (!data || data.ok !== true) return calendarCache;
+          return adoptCalendar(data);
+        } catch {
+          return calendarCache;
+        } finally {
+          calendarInFlight = null;
+        }
+      })();
+      return calendarInFlight;
+    }
+
+    /** 手动同步：POST 让服务端去拉当年 ±1 年的国务院公告并落盘。 */
+    async function syncCalendar() {
+      const res = await fetch("/balance-api?calendar=1", {
+        method: "POST",
+        headers: { accept: "application/json" },
+      });
+      const data = await res.json();
+      if (data && data.ok === true) adoptCalendar(data);
+      return data;
+    }
+
+    /** 订阅节假日状态；首次使用时自动去读一次。 */
+    function useCalendar() {
+      const [, force] = react.useState(0);
+      react.useEffect(() => {
+        const listener = () => force((n) => n + 1);
+        settingsListeners.add(listener);
+        if (calendarCache.loaded !== true) void fetchCalendarStatus();
+        return () => settingsListeners.delete(listener);
+      }, []);
+      return calendarCache;
+    }
+
     function emitSettings() {
       for (const listener of settingsListeners) listener();
     }
@@ -896,6 +1099,8 @@ window.__ModuleLoader__.load({
               loaded: true,
               version: typeof data.version === "string" ? data.version : settingsCache.version,
             };
+            // 高峰窗口跟着设置走：判定与刻度都得换，否则标签会和实际计费对不上
+            applyPeakWindowsText(settingsCache.value.peakWindowsText);
           }
         } catch {
           // 服务端不可用：保持默认值，不打扰用户
@@ -922,6 +1127,7 @@ window.__ModuleLoader__.load({
         loaded: true,
         version: typeof data.version === "string" ? data.version : settingsCache.version,
       };
+      applyPeakWindowsText(settingsCache.value.peakWindowsText);
       emitSettings();
       return settingsCache.value;
     }
@@ -1752,6 +1958,23 @@ window.__ModuleLoader__.load({
           }
         };
       }, []);
+      // 指针位置：500ms 一次直接改 DOM 的 left，不经 React state、也不用 CSS transition。
+      // 一天走完 100%，每分钟只有 0.069%（200px 轨道上 0.14px）：
+      //   · 按分钟 tick + 长过渡 —— 静止 59 秒再窜一下，且连续性押在浏览器动画时钟上，
+      //     后台标签页会把过渡暂停，切回来时直接落到终点，那就是用户看到的「瞬移」；
+      //   · 每 500ms 重算一次 —— 相邻两次只差 0.0006%（0.0012px），视觉上就是匀速滑，
+      //     不依赖过渡调度，也不会因为后台暂停而攒成一跳。
+      // 只有 2px 的元素改 left，代价可忽略；不碰 state 就不触发组件重渲染。
+      const pointerRef = react.useRef(null);
+      react.useEffect(() => {
+        const paint = () => {
+          const el = pointerRef.current;
+          if (el) el.style.left = pointerPercent(Date.now()).toFixed(4) + "%";
+        };
+        paint();
+        const timer = setInterval(paint, 500);
+        return () => clearInterval(timer);
+      }, []);
       const clickTimer = react.useRef(null);
       const closeTimer = react.useRef(null);
       const anchorRef = react.useRef(null);
@@ -1973,6 +2196,10 @@ window.__ModuleLoader__.load({
       const depleted = b.is_available === false || !Number.isFinite(total) || total <= 0;
       const currency = b.currency || "CNY";
       const totalText = b.total_balance + " " + currency;
+      // 位数多就降字号：一旦整数位到 4 位，16px 的胶囊会宽过 121px 的固定宽度
+      // （1234.56 CNY 131.3px / 12345.67 CNY 141.1px），把自己撑出容器右缘。
+      // 降一档字号就能收回来，宽度重新恒定 —— 配合 .balance-footer__value 的 min-width。
+      const valueDensity = amountDensity(b.total_balance);
       if (depleted) {
         return withPanel(jsx.jsxs("div", {
           className: "balance-footer",
@@ -2000,55 +2227,74 @@ window.__ModuleLoader__.load({
       // 时段模块：上方一行 meta（今日消耗 · 时段 · 剩余时间）+ 下方扁刻度条。
       // 色带固定 = 当天完整时段，指针 = 此刻在当天的位置。
       const span = periodSpan(timelineNow);
-      const metaItems = [];
+      // meta 分两段：①「今日 ¥x」②「时段词 + 剩余时间」。
+      // 第二段整体不换行（包在 __group 里），所以窄侧栏折行时一定是
+      // 「今日 ¥x」独占上面一行、「空闲 剩 3h57m」落到下面一行 —— 用户 2026-10-30 指定。
+      const metaItem = (text, cls, key) =>
+        jsx.jsx("span", { className: "balance-footer__timeline-meta-item" + (cls || ""), children: text }, key);
+      const tail = [
+        metaItem(period === "peak" ? "高峰" : "空闲", " balance-footer__timeline-meta-item--" + period, "period"),
+      ];
+      if (span !== null) tail.push(metaItem("剩 " + formatRemain(span.remainMs), "", "remain"));
+      const metaChildren = [];
       if (today !== null && Number.isFinite(Number(today.cost))) {
-        metaItems.push({ text: "今日 ¥" + Number(today.cost).toFixed(2), cls: "" });
+        metaChildren.push(
+          jsx.jsx(
+            "span",
+            {
+              className: "balance-footer__timeline-meta-item balance-footer__timeline-meta-item--today",
+              children: "今日 ¥" + Number(today.cost).toFixed(2),
+            },
+            "today",
+          ),
+        );
       }
-      metaItems.push({
-        text: period === "peak" ? "高峰" : "空闲",
-        cls: " balance-footer__timeline-meta-item--" + period,
-      });
-      if (span !== null) metaItems.push({ text: "剩 " + formatRemain(span.remainMs), cls: "" });
+      metaChildren.push(
+        jsx.jsx("span", { className: "balance-footer__timeline-meta-group", children: tail }, "tail"),
+      );
       const metaNode = jsx.jsx("span", {
         className: "balance-footer__timeline-meta",
-        children: metaItems.map((item, i) =>
-          jsx.jsx("span", { className: "balance-footer__timeline-meta-item" + item.cls, children: item.text }, item.text + i)
-        ),
+        children: metaChildren,
       });
       // 新版把「meta 行 + 刻度条」当结构主体，不存在"关掉只剩金额"的形态，
       // 所以这里不看 showPeriodLabel；那个开关只在旧版有意义（见下面的 classic 分支）。
       const timelineBand = buildTimeline(timelineNow);
       // 刷新时不替换时段模块：刻度条保持原样，刷新反馈只落在右侧金额（半透明 + 浪潮）。
+      // 刻度条在 timeline 内部、meta 下方，宽度跟随侧栏（width:100%）：
+      //   [今日 ¥x  /  空闲 剩 3h57m]              [胶囊]
+      //   [==== 刻度条（跟随侧栏宽度）====]
       const periodNode = jsx.jsxs("span", {
-              className: "balance-footer__timeline",
-              children: [
-                metaNode,
-                jsx.jsxs("span", {
-                  className: "balance-footer__timeline-track balance-footer__timeline-track--" + period,
-                  children: [
-                    // 裁剪层让四周各留 1px，颜色不贴边框
-                    jsx.jsxs("span", {
-                      className: "balance-footer__timeline-clip",
-                      children: [
-                        // 泛光：同一渐变模糊后叠在色带上面，靠柔边往外散光
-                        jsx.jsx("span", {
-                          className: "balance-footer__timeline-glow",
-                          style: { background: timelineBand.gradient },
-                        }),
-                        // 色带本体：纯色块，不带任何文字
-                        jsx.jsx("span", {
-                          className: "balance-footer__timeline-band",
-                          style: { background: timelineBand.gradient },
-                        }),
-                      ],
-                    }),
-                    // 指针：位置 = 此刻在当天的比例，随时间从左走到右
-                    jsx.jsx("span", {
-                      className: "balance-footer__timeline-pointer",
-                      style: { left: timelineBand.pointerPct.toFixed(3) + "%" },
-                    }),
-                  ],
-                }),
+        className: "balance-footer__timeline",
+        children: [
+          metaNode,
+          jsx.jsxs("span", {
+            className: "balance-footer__timeline-track balance-footer__timeline-track--" + period,
+            children: [
+              // 裁剪层让四周各留 1px，颜色不贴边框
+              jsx.jsxs("span", {
+                className: "balance-footer__timeline-clip",
+                children: [
+                  // 泛光：同一渐变模糊后叠在色带上面，靠柔边往外散光
+                  jsx.jsx("span", {
+                    className: "balance-footer__timeline-glow",
+                    style: { background: timelineBand.gradient },
+                  }),
+                  // 色带本体：纯色块，不带任何文字
+                  jsx.jsx("span", {
+                    className: "balance-footer__timeline-band",
+                    style: { background: timelineBand.gradient },
+                  }),
+                ],
+              }),
+              // 指针：位置 = 此刻在当天的比例，随时间从左走到右
+              jsx.jsx("span", {
+                className: "balance-footer__timeline-pointer",
+                ref: pointerRef,
+                // 首帧先摆到位（rAF 还没起来），之后由 rAF 每帧接管
+                style: { left: pointerPercent(Date.now()).toFixed(3) + "%" },
+              }),
+            ],
+          }),
         ],
       });
       // 布局：左侧 [meta + 刻度条] 竖排，右侧金额。行高不够时整块自动变高。
@@ -2072,7 +2318,7 @@ window.__ModuleLoader__.load({
             jsx.jsx("span", { className: "balance-footer__icon", children: jsx.jsx(WalletIcon, {}) }),
             jsx.jsx("span", { className: "balance-footer__label", children: "余额" }),
             jsx.jsxs("span", {
-              className: "balance-footer__value" + (low ? " balance-footer__value--low" : " balance-footer__value--healthy"),
+              className: "balance-footer__value" + (low ? " balance-footer__value--low" : " balance-footer__value--healthy") + valueDensity,
               children: [
                 totalText,
                 // 分隔点用元素而不是字符串：inline-flex 会把匿名文本条目的首尾空白按规范去掉，
@@ -2093,7 +2339,7 @@ window.__ModuleLoader__.load({
             ? jsx.jsx("span", { className: "balance-footer__spacer" })
             : periodNode,
           jsx.jsx("span", {
-            className: "balance-footer__value" + (low ? " balance-footer__value--low" : " balance-footer__value--healthy") + (state.refreshing ? " balance-footer__value--stale" : ""),
+            className: "balance-footer__value" + (low ? " balance-footer__value--low" : " balance-footer__value--healthy") + (state.refreshing ? " balance-footer__value--stale" : "") + valueDensity,
             children: rollCells === null
               ? totalText
               : jsx.jsx("span", {
@@ -2555,6 +2801,53 @@ function UsageCostLine({ useProjection, sessionId }) {
       // 我们只给标题、正文和底部按钮。取不到时退化成纯文字按钮，绝不自己画遮罩。
       const tipModal = primitives && typeof primitives.Modal === "function" ? primitives.Modal : null;
       const tipButton = primitives && typeof primitives.Button === "function" ? primitives.Button : null;
+      // 节假日数据：状态来自服务端，按钮触发一次强制同步。
+      const calendar = useCalendar();
+      const [calendarSync, setCalendarSync] = react.useState({ kind: "idle", text: "" });
+      const calendarBusy = calendarSync.kind === "syncing";
+      const calendarSummary = (() => {
+        if (calendarSync.kind === "ok" || calendarSync.kind === "error") return calendarSync.text;
+        if (calendar.fetchedAt > 0) {
+          const at = new Date(calendar.fetchedAt);
+          const stamp =
+            at.getFullYear() + "-" + String(at.getMonth() + 1).padStart(2, "0") + "-" +
+            String(at.getDate()).padStart(2, "0") + " " + String(at.getHours()).padStart(2, "0") + ":" +
+            String(at.getMinutes()).padStart(2, "0");
+          const years = calendar.years.length > 0 ? calendar.years.join(" / ") : "—";
+          // 只报日期与时刻，不报完整年份列表：那串太长会把左边的标题挤成一字一行。
+          // 「同步了哪几年」由服务端 days 的键直接决定，用户点「立即同步」那边也能看到。
+          const pending = calendar.missing.length > 0 ? " · " + calendar.missing.join(" / ") + " 待公布" : "";
+          return "已同步 " + calendar.count + " 天 · " + stamp.slice(5) + pending;
+        }
+        return "尚未同步，正在用插件内置表。";
+      })();
+      const onSyncCalendar = async () => {
+        if (calendarBusy) return;
+        setCalendarSync({ kind: "syncing", text: "正在同步…" });
+        try {
+          const data = await syncCalendar();
+          if (data && data.ok === true) {
+            const years = Array.isArray(data.years) && data.years.length > 0 ? data.years.join(" / ") : "—";
+            const pending = Array.isArray(data.pending) && data.pending.length > 0
+              ? "（" + data.pending.join(" / ") + " 待公布）"
+              : "";
+            setCalendarSync({
+              kind: "ok",
+              text: "已更新 " + years + "（" + (Number(data.added) || 0) + " 天）" + pending,
+            });
+          } else {
+            setCalendarSync({
+              kind: "error",
+              text: (data && data.error) || "同步失败，继续使用本地数据。",
+            });
+          }
+        } catch (error) {
+          setCalendarSync({
+            kind: "error",
+            text: "同步失败：" + (error instanceof Error ? error.message : String(error)),
+          });
+        }
+      };
       const tipClose = () => setSidebarTip(false);
       const tipFooter = tipButton
         ? jsx.jsx(tipButton, { variant: "primary", onClick: tipClose, children: "知道了" })
@@ -2767,6 +3060,24 @@ function UsageCostLine({ useProjection, sessionId }) {
           jsx.jsx("span", { className: "balance-settings__unit", children: unit, key: key + "-unit" }),
         ]);
 
+      // 文本行：用于「高峰时段」这类要手写表达式的项。
+      // 边输边存（和 numberRow 一致），半截输入由服务端原样存下、解析失败时回退默认窗口，
+      // 所以打到一半不会被弹回。
+      const textRow = (key, label, hint, placeholder) =>
+        row(
+          key,
+          label,
+          hint,
+          jsx.jsx("input", {
+            className: "balance-settings__input balance-settings__input--text",
+            type: "text",
+            value: value[key] == null ? "" : String(value[key]),
+            placeholder,
+            spellCheck: false,
+            onChange: (event) => patch(key, event.target.value),
+          }),
+        );
+
       // onToggle（可选）拿到的是「点完之后的新值」，用来在关掉某项时追加副作用
       const toggleRow = (key, label, hint, onToggle) =>
         row(
@@ -3042,7 +3353,45 @@ function UsageCostLine({ useProjection, sessionId }) {
           ]),
 
           group("billing", "计费", [
+            // 官方改时段就等于改「哪几个小时翻倍」。留成可编辑项，
+            // 以后即使没人改代码，用户自己也能跟上官方口径。
+            textRow(
+              "peakWindowsText",
+              "高峰时段",
+              "工作日北京时间的这些时段按高峰计价。格式 9-12, 14-18（官方当前值）。写错了自动沿用上一组有效值。",
+              "9-12, 14-18",
+            ),
             numberRow("peakMultiplier", "高峰时段倍率", "官方为 2（高峰价 = 空闲价 × 倍率）。", 1, 10, "倍"),
+            // 法定节假日/调休直接决定某天算高峰还是空闲（算钱和标签都靠它），
+            // 内置表只是离线兜底。给一个手动同步按钮：即使哪天没人维护插件，
+            // 用户自己点一下就能把下一年的国务院公告补进来。
+            row(
+              "calendar",
+              "节假日数据",
+              "法定节假日与调休从国务院公告同步。插件每 30 天自动同步一次，这里可以手动立即更新。",
+              jsx.jsxs("div", {
+                className: "balance-settings__calendar",
+                children: [
+                  jsx.jsx("span", {
+                    className:
+                      "balance-settings__calendar-note" +
+                      (calendarSync.kind === "error"
+                        ? " balance-settings__calendar-note--error"
+                        : calendar.fetchedAt > 0
+                          ? ""
+                          : " balance-settings__calendar-note--warn"),
+                    children: calendarSummary,
+                  }),
+                  jsx.jsx("button", {
+                    type: "button",
+                    className: "balance-settings__btn",
+                    onClick: onSyncCalendar,
+                    disabled: calendarBusy,
+                    children: calendarBusy ? "同步中…" : "立即同步",
+                  }),
+                ],
+              }),
+            ),
           ]),
 
           jsx.jsxs("div", {
@@ -3171,6 +3520,8 @@ function UsageCostLine({ useProjection, sessionId }) {
       });
       // 启动检查更新：等 UI 先跑起来再查（2.5s），别跟首屏抢网络。
       // 每次页面加载 = 每次打开 DeepSeek Harness，符合「每次打开都检查一次」。
+      // 节假日数据：跟更新检查一样是「后台补一次」，但更早 —— 峰谷标签一上来就该是准的。
+      void fetchCalendarStatus();
       if (typeof window !== "undefined" && typeof window.setTimeout === "function") {
         window.setTimeout(() => {
           void checkUpdateOnStartup();

package/lib/index.js

@@ -118,26 +118,208 @@ const CN_CALENDAR = {
 
 // 节假日自动补录：内置表仅作**离线兜底**，运行时从社区维护的源拉取（其 papers 字段直接引用国务院公告）。
 // 源不可用/无网络/被 CSP 拦截时静默失败，继续用内置表；拉取结果按日期覆盖同键条目。
-const CN_CALENDAR_SOURCE = "https://cdn.jsdelivr.net/gh/NateScarlet/holiday-cn@master";
+// 节假日数据源（同一份数据、多个 CDN）。实测 cdn.jsdelivr.net 在国内经常连不上，
+// fastly / gcore 那两个镜像反而稳定，所以按「先快后慢、逐个回退」排序，
+// 任何一个能通就够 —— 这也让插件在某个 CDN 挂掉之后仍然能自己更新。
+const CN_CALENDAR_SOURCES = [
+  "https://fastly.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+  "https://gcore.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+  "https://raw.githubusercontent.com/NateScarlet/holiday-cn/master",
+  "https://cdn.jsdelivr.net/gh/NateScarlet/holiday-cn@master",
+];
+const CN_CALENDAR_SOURCE = CN_CALENDAR_SOURCES[0]; // 兼容旧引用
+const HOLIDAYS_FILENAME = "balance-holidays.json";
+/** 缓存有效期：超过这个天数就在启动时后台重拉一次（用户什么都不用做）。 */
+const CALENDAR_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const cnCalendarYears = new Set();
+// 已同步的节假日数据。days = 「YYYY-MM-DD」→ holiday / workday，
+// 落盘到 <dshHome>/balance-holidays.json —— 重启后直接用缓存，断网也不退化成内置表。
+// missing = 连上了但还没有数据的年份（典型：国务院还没发次年的放假安排）。
+// 这些年份**不受 30 天 TTL 约束**：缓存再新鲜也每次启动补试一次，
+// 否则在「11 月发了次年公告、但上次同步刚好锁住 30 天」这个窗口里会白等一个月。
+const cnCalendarState = { days: {}, fetchedAt: 0, years: [], missing: [], file: "", source: "" };
+
+/** 节假日缓存文件路径（空串 = 定位不到 home，缓存功能静默降级为纯内存）。 */
+function holidaysFilePath(ctx) {
+  const home = dshHomeDir(ctx);
+  if (home === "") return "";
+  const sep = home.includes("\\") && !home.includes("/") ? "\\" : "/";
+  return home.replace(/[\\/]+$/, "") + sep + HOLIDAYS_FILENAME;
+}
 
-/** 拉取指定年份的节假日安排并合并进 CN_CALENDAR（幂等；失败静默，不阻塞调用方）。 */
-async function ensureCnCalendar(year) {
-  if (cnCalendarYears.has(year)) return;
-  cnCalendarYears.add(year); // 先占位，避免并发重复请求
+/** 拉取单年节假日并合并进 CN_CALENDAR / cnCalendarState；返回条数，失败返回 -1。
+ *  逐个试 CN_CALENDAR_SOURCES：某个 CDN 挂掉就换下一个，全挂才算失败。 */
+async function fetchCalendarYear(year) {
+  for (const base of CN_CALENDAR_SOURCES) {
+    try {
+      const res = await fetch(base + "/" + year + ".json", { signal: AbortSignal.timeout(6000) });
+      if (!res.ok) continue;
+      const data = await res.json();
+      if (!Array.isArray(data?.days)) continue;
+      let count = 0;
+      for (const item of data.days) {
+        if (item && typeof item.date === "string" && typeof item.isOffDay === "boolean") {
+          const kind = item.isOffDay ? "holiday" : "workday";
+          CN_CALENDAR[item.date] = kind;
+          cnCalendarState.days[item.date] = kind;
+          count += 1;
+        }
+      }
+      cnCalendarState.source = base;
+      return count;
+    } catch {
+      // 这个源连不上：换下一个
+    }
+  }
+  return -1;
+}
+
+/** 读本地缓存（启动时调一次）。文件不存在 / 损坏一律当「没有缓存」。 */
+async function loadCalendarCache(ctx) {
+  cnCalendarState.file = holidaysFilePath(ctx);
+  if (cnCalendarState.file === "") return false;
   try {
-    const res = await fetch(CN_CALENDAR_SOURCE + "/" + year + ".json", { signal: AbortSignal.timeout(8000) });
-    if (!res.ok) return;
-    const data = await res.json();
-    if (!Array.isArray(data?.days)) return;
-    for (const item of data.days) {
-      if (item && typeof item.date === "string" && typeof item.isOffDay === "boolean") {
-        CN_CALENDAR[item.date] = item.isOffDay ? "holiday" : "workday";
+    const { readFile } = await import("node:fs/promises");
+    const parsed = JSON.parse(await readFile(cnCalendarState.file, "utf8"));
+    const days = parsed && typeof parsed === "object" && parsed.days && typeof parsed.days === "object" ? parsed.days : null;
+    if (days === null) return false;
+    let count = 0;
+    for (const [date, kind] of Object.entries(days)) {
+      if (typeof date === "string" && (kind === "holiday" || kind === "workday")) {
+        CN_CALENDAR[date] = kind;
+        cnCalendarState.days[date] = kind;
+        count += 1;
       }
     }
+    cnCalendarState.fetchedAt = Number(parsed.fetchedAt) || 0;
+    if (typeof parsed.source === "string") cnCalendarState.source = parsed.source;
+    cnCalendarState.years = Array.isArray(parsed.years)
+      ? parsed.years.map((y) => Number(y)).filter((y) => Number.isFinite(y)).sort()
+      : [];
+    cnCalendarState.missing = Array.isArray(parsed.missing)
+      ? parsed.missing.map((y) => Number(y)).filter((y) => Number.isFinite(y)).sort()
+      : [];
+    return count > 0;
+  } catch {
+    return false;
+  }
+}
+
+/** 写本地缓存：先写 .tmp 再 rename，避免写一半把文件写坏。 */
+async function saveCalendarCache() {
+  const file = cnCalendarState.file;
+  if (file === "") return false;
+  try {
+    const { mkdir, writeFile, rename } = await import("node:fs/promises");
+    const { dirname } = await import("node:path");
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = file + ".tmp";
+    const payload = {
+      fetchedAt: cnCalendarState.fetchedAt,
+      years: cnCalendarState.years,
+      missing: cnCalendarState.missing,
+      source: cnCalendarState.source || CN_CALENDAR_SOURCE,
+      days: cnCalendarState.days,
+    };
+    await writeFile(tmp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    await rename(tmp, file);
+    return true;
   } catch {
-    // 网络不可用：保留内置表（该年调休会退化为「周末全天空闲」）
+    return false;
+  }
+}
+
+/** 当前节假日数据状态（GET /balance-api?calendar=1 直接返回它）。 */
+function calendarStatus() {
+  return {
+    fetchedAt: cnCalendarState.fetchedAt,
+    years: cnCalendarState.years.slice(),
+    missing: cnCalendarState.missing.slice(),
+    count: Object.keys(cnCalendarState.days).length,
+    source: cnCalendarState.source || CN_CALENDAR_SOURCE,
+    days: cnCalendarState.days,
+    ttlDays: Math.round(CALENDAR_TTL_MS / 86400000),
+  };
+}
+
+/** 同步当年 ±1 年（覆盖 90 天统计窗口与跨年场景）。
+ *  force=false 且缓存新鲜、且没有缺数据的年份时，完全跳过网络；
+ *  缓存新鲜但有 missing（如次年安排还没发布），只补拉那几个年份。 */
+async function refreshCnCalendar(ctx, force) {
+  // 兜底：正常路径是 apply 里先 loadCalendarCache 把 file 填好；
+  // 但只要有人直接点「立即同步」而这个状态还没初始化，这里也得能落盘。
+  if (cnCalendarState.file === "") cnCalendarState.file = holidaysFilePath(ctx);
+  const fresh = cnCalendarState.fetchedAt > 0 && Date.now() - cnCalendarState.fetchedAt < CALENDAR_TTL_MS;
+  const stale = force || !fresh;
+  if (!stale && cnCalendarState.missing.length === 0) {
+    return { ok: true, skipped: true, ...calendarStatus() };
+  }
+  const y = new Date(Date.now() + 8 * 60 * 60 * 1000).getUTCFullYear();
+  // 只缺某几年 → 只补拉那几年，不要把已有数据的年份再拉一遍
+  const targets = stale ? [y - 1, y, y + 1] : cnCalendarState.missing.slice();
+  const done = [];
+  const failed = [];
+  const stillMissing = [];
+  let added = 0;
+  for (const year of targets) {
+    const n = await fetchCalendarYear(year);
+    if (n > 0) {
+      added += n;
+      done.push(year);
+      cnCalendarYears.add(year);
+    } else if (n === 0) {
+      // 连上了、但这一年还没数据（次年放假安排尚未公布）——不是失败，但要继续补试
+      stillMissing.push(year);
+    } else {
+      failed.push(year);
+    }
+  }
+  // 已拿到数据的年份从 missing 里摘掉；「连上了但没数据」的补进去（保持升序去重）。
+  // 注意「连不上」（n < 0）不算 missing —— 那是网络问题，交给 30 天 TTL 兜，
+  // 否则断网用户每次启动都会去拉三年、白白等超时。
+  //
+  // 下限 y-1：放假安排必然在当年之前公布，比 y-1 还早却还「缺」的年份不可能是
+  // 「待公布」，只可能是历史残留（例如插件停用两年后重新打开，那几年再也不会
+  // 被 targets 命中，会一直留着）。这类年份直接丢弃，否则设置页会永久显示
+  // 「2025 待公布」这种荒谬文本。上限不需要管：y+1 就是 target 的上界。
+  const floorYear = y - 1;
+  const kept = cnCalendarState.missing.filter((year) => year >= floorYear && !done.includes(year));
+  cnCalendarState.missing = [...new Set([...kept, ...stillMissing])].sort((x, z) => x - z);
+  if (done.length === 0 && failed.length > 0 && !stale) {
+    // 只补拉 missing 且全部连不上：保持原样，不动 fetchedAt（避免把数据「洗新」）
+    await saveCalendarCache();
+    return { ok: false, error: "连不上节假日数据源，继续使用本地数据。", failedYears: failed, ...calendarStatus() };
+  }
+  if (done.length === 0 && stillMissing.length > 0) {
+    // 连上了但确实还没公布（例如次年安排还没发）——不算错误，静默保持
+    await saveCalendarCache();
+    return { ok: true, pending: stillMissing, added: 0, ...calendarStatus() };
+  }
+  if (done.length === 0) {
+    return {
+      ok: false,
+      error: "连不上节假日数据源，继续使用本地数据。",
+      failedYears: failed,
+      ...calendarStatus(),
+    };
+  }
+  cnCalendarState.fetchedAt = Date.now();
+  cnCalendarState.years = [...new Set([...cnCalendarState.years, ...done])].sort((x, z) => x - z);
+  await saveCalendarCache();
+  return { ok: true, added, years: done, failedYears: failed, pending: cnCalendarState.missing.slice(), ...calendarStatus() };
+}
+
+/** 拉取指定年份（保留旧入口）：内部走 fetchCalendarYear，成功后落盘。 */
+async function ensureCnCalendar(year) {
+  if (cnCalendarYears.has(year)) return;
+  cnCalendarYears.add(year); // 先占位，避免并发重复请求
+  const n = await fetchCalendarYear(year);
+  if (n < 0) return;
+  if (!cnCalendarState.years.includes(year)) {
+    cnCalendarState.years = [...cnCalendarState.years, year].sort((x, z) => x - z);
   }
+  if (cnCalendarState.fetchedAt === 0) cnCalendarState.fetchedAt = Date.now();
+  void saveCalendarCache();
 }
 
 /** 北京时区日期键 YYYY-MM-DD（传入已 +8h 偏移的 Date）。 */
@@ -345,7 +527,7 @@ function formatBalance(balance) {
 //                          | { status:"failed" }  （网络失败；官方明确“失败绝不变成 0 余额”）
 // client 是 AccountClientMetadata（version / locale / timezoneOffsetSeconds），
 // 缺字段会在平台侧组装请求头时抛错，所以三个字段都要给。
-const PLUGIN_VERSION = "2.0.2";
+const PLUGIN_VERSION = "2.0.3";
 
 // ─── 检查更新 ───────────────────────────────────────────────────────────────
 // 只查 npm registry 的 latest 标签（一个很小的 JSON），不下载任何东西。
@@ -878,6 +1060,10 @@ const DEFAULT_SETTINGS = {
   statsSessionLimit: STATS_MAX_SESSIONS, // 统计扫描的最近会话数
   statsCacheSec: 300, // 统计结果缓存秒数
   // 计费
+  // 高峰时段窗口。官方当前是「工作日北京 9-12、14-18」，但这条也是会变的
+  // （改了时段就等于改了哪几个小时翻倍）。写成文本而不是数组：输入框直接对应，
+  // 没有「数组 → 界面 → 数组」的转换损耗，用户手改也不会因为半截输入被弹回。
+  peakWindowsText: "9-12, 14-18",
   peakMultiplier: 2, // 高峰时段倍率
   priceFlash: null, // flash 覆盖价（元/百万 token），四项全填才生效
   pricePro: null, // v4-pro 覆盖价
@@ -914,6 +1100,38 @@ function normalizeNewTagSeen(raw) {
   return out;
 }
 
+/** 高峰窗口文本 → 数组。接受 "9-12, 14-18"、"9-12，14-18"、"9~12" 这几种写法。
+ *  逐段校验（0 ≤ start < end ≤ 24，整点），**任何一段不合法就整串作废返回 null** ——
+ *  宁可回退官方默认窗口，也不要拿半对半错的窗口去算钱。
+ *  end = 24 表示到当天结束（hour 最大 23，`hour < end` 覆盖 23:00-23:59）。 */
+function parsePeakWindowsText(text) {
+  if (typeof text !== "string") return null;
+  const out = [];
+  for (const chunk of text.split(/[,，;；]/)) {
+    const part = chunk.trim();
+    if (part === "") continue;
+    const m = part.match(/^(\d{1,2})\s*[-~到至]\s*(\d{1,2})$/);
+    if (!m) return null;
+    const start = Number(m[1]);
+    const end = Number(m[2]);
+    if (!Number.isInteger(start) || !Number.isInteger(end)) return null;
+    if (start < 0 || end > 24 || start >= end) return null;
+    out.push({ start, end });
+  }
+  return out.length > 0 ? out : null;
+}
+
+/** 高峰窗口文本的**类型清洗**（不校验语法）。
+ *  用户打到一半（"9-"）也要能存下来继续编辑，所以这里不判合法；
+ *  真正解析发生在 withSettings（服务端算钱）与客户端 currentPeriod（显示标签），
+ *  解析失败一律回退官方默认窗口 —— 计费永远不会因为一段烂文本而错。 */
+function normalizePeakWindowsText(raw, fallback) {
+  if (typeof raw !== "string") return fallback;
+  const text = raw.trim();
+  if (text === "") return fallback;
+  return text.slice(0, 80);
+}
+
 /** 一组覆盖价：逐个字段校验（有限非负数才收），不填的字段留空表示「用默认价」。
  *  四个字段都没填则整组丢弃（等价于不覆盖）。 */
 function normalizePriceOverride(raw) {
@@ -954,6 +1172,7 @@ function normalizeSettings(raw) {
     fabLeft: clampNumber(src.fabLeft, 0, 600, d.fabLeft),
     statsSessionLimit: clampNumber(src.statsSessionLimit, 10, 2000, d.statsSessionLimit),
     statsCacheSec: clampNumber(src.statsCacheSec, 0, 3600, d.statsCacheSec),
+    peakWindowsText: normalizePeakWindowsText(src.peakWindowsText, d.peakWindowsText),
     peakMultiplier: clampNumber(src.peakMultiplier, 1, 10, d.peakMultiplier),
     priceFlash: normalizePriceOverride(src.priceFlash),
     pricePro: normalizePriceOverride(src.pricePro),
@@ -969,6 +1188,9 @@ function withSettings(config, settings) {
   return {
     ...config,
     apiKey: s.apiKey !== "" ? s.apiKey : config?.apiKey,
+    // 设置里改的高峰窗口优先；文本解析不出来就回退官方默认窗口，
+    // 绝不能把 undefined 透给 isPeakAt（那会让 isPeakAt 自己再 fallback，语义重复）
+    peakWindows: parsePeakWindowsText(s.peakWindowsText) ?? DEFAULT_PEAK_WINDOWS,
     peakMultiplier: s.peakMultiplier,
     priceByModel,
     statsSessionLimit: s.statsSessionLimit,
@@ -1614,14 +1836,17 @@ export function apply(ctx, config = {}) {
   // 时统一清理，保证重复 apply 不冲突。
   const disposers = [];
 
-  // 后台补录节假日数据（当年 ±1 年，覆盖 90 天统计窗口与跨年场景）。
-  // 故意不 await：拉取失败不能影响插件启动；isPeakAt 保持同步，未拉到时继续用内置表。
-  {
-    const y = new Date(Date.now() + 8 * 60 * 60 * 1000).getUTCFullYear();
-    void ensureCnCalendar(y - 1);
-    void ensureCnCalendar(y);
-    void ensureCnCalendar(y + 1);
-  }
+  // 节假日数据：先读本地缓存（这样断网、改过系统时间也照样按上次同步的结果算钱），
+  // 再看缓存是不是过期（默认 30 天），过期才去拉。故意不 await —— 网络慢不能拖住启动，
+  // isPeakAt 保持同步函数，缓存没到位时继续用内置表。
+  void (async () => {
+    try {
+      await loadCalendarCache(ctx);
+      await refreshCnCalendar(ctx, false);
+    } catch {
+      // 任何异常都只是「这次没更新」，不影响余额与计费
+    }
+  })();
 
   // 1) /balance 命令：保留命令行查询入口
   ctx.inject(["commands"], (commandCtx) => {
@@ -1731,6 +1956,34 @@ export function apply(ctx, config = {}) {
           }
           return;
         }
+        // 节假日数据：GET 读状态（含 days 明细，客户端据此与服务端同口径判断峰谷），
+        // POST 强制重新同步。和 update 一样排在下面那道 405 之前。
+        let wantCalendar = false;
+        try {
+          wantCalendar = new URL(req.url, "http://localhost").searchParams.get("calendar") === "1";
+        } catch {
+          wantCalendar = false;
+        }
+        if (wantCalendar) {
+          if (req.method === "POST") {
+            try {
+              writeJson(res, 200, await refreshCnCalendar(httpCtx, true));
+            } catch (error) {
+              writeJson(res, 200, {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+                ...calendarStatus(),
+              });
+            }
+            return;
+          }
+          if (req.method !== "GET") {
+            writeJson(res, 405, { ok: false, error: "method not allowed" });
+            return;
+          }
+          writeJson(res, 200, { ok: true, ...calendarStatus() });
+          return;
+        }
         if (req.method !== "GET") {
           writeJson(res, 405, { ok: false, error: "method not allowed" });
           return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "balance-dsh",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "在 DeepSeek Harness 中显示 DeepSeek 账户余额和当前会话 token/费用消耗（含高峰/空闲峰谷计费）。仅支持 DeepSeek 官方模型与账号，暂不支持其他大模型。",
   "author": "Rannist",
   "type": "module",