dsh-peak-status 1.0.3 → 1.0.5

package/README.md

@@ -17,10 +17,20 @@ DeepSeek's official peak/valley API pricing (effective 2026-08-17, weekends adju
 
 Weekends (Saturday and Sunday) are charged at the valley price all day — no peak windows on weekends.
 
+Per DeepSeek's peak/valley note, the only days that can peak are ordinary Monday–Friday working days:
+
+| Day | State (Beijing time) |
+| :-- | :-- |
+| 法定节假日 (statutory holiday) | valley for the whole day, exactly like a weekend |
+| 调休上班的周末 (a weekend worked) | valley for the whole day too — 调休 does not change billing |
+
+So the chip shows 🟢 **国庆节** instead of a red peak on 1 October, and 🟢 **调休上班 · 谷价** on a 调休 Saturday.
+
 ## What you get
 
 - A colored status dot — **red = peak, green = off-peak** — plus the live Beijing clock (`HH:MM:SS`, timezone `Asia/Shanghai`, independent of your machine's timezone)
 - A countdown: `剩 3h 54m · 价格 ×2` during peak / `距高峰 3h 54m · 半价` off-peak
+- Holiday awareness: on a 法定节假日 the chip names the festival (e.g. `国庆节`) and counts down to the first peak window after the break; on a 调休上班的周末 it shows all-day valley and tags the day
 - Click the chip to expand a detail card: peak windows, the next transition with a `HH:MM:SS` countdown, and a progress bar of the current phase
 - Fully themed with the web UI's native `--dsw-alias-*` variables — it blends into the interface instead of floating over it
 - Mounted persistently: it survives dsh web restarts
@@ -41,10 +51,22 @@ Then restart `dsh web` (or refresh the page). The chip appears at the top-right
 
 ## Usage
 
-The chip updates every second. Click it to expand/collapse the detail card; hover for a quick tooltip. Peak/off-peak state follows the official schedule above, computed in Beijing time.
+The chip updates every second. Click it to expand/collapse the detail card; hover for a quick tooltip. Peak/off-peak state follows the official schedule above, computed in Beijing time over the official work calendar.
 
 If DeepSeek ever changes the peak schedule, a new release will ship with the updated windows — open an issue on this repository if you notice a mismatch.
 
+## Holiday calendar
+
+The calendar (法定节假日 + 调休 makeup days) is fetched over the network, with three layers of fallback:
+
+1. **Host route** — the plugin's host half serves a same-origin route `/dsh-peak-status/holiday/<year>`. It tries jiejiariapi first and apihubs second, normalizes both shapes and caches the result in memory for 6 hours, so every browser tab shares one fetch.
+2. **Browser fallback** — if that route is unavailable, the browser half calls `api.apihubs.cn` directly (it is CORS-enabled).
+3. **Plain weekend rule** — with no calendar at all the chip behaves exactly like 1.0.3: weekday windows plus weekend valley.
+
+Normalized days are cached in `localStorage` for 24 hours, so a restart or a spell offline still renders the right state, and the detail card always reports the source (`已同步 · jiejiariapi` / `未同步 · 暂按周末规则`).
+
+Pricing follows DeepSeek's 峰谷时间说明: **调休上班的周末 and 中国法定节假日 are billed at the off-peak rate for the whole day**. The calendar supplies exactly those two labels — a 调休 day never gains a peak window.
+
 ## License
 
 [MIT](LICENSE)

package/README.zh-CN.md

@@ -17,10 +17,20 @@ DeepSeek 官方峰谷定价（2026-08-17 生效，2026-08-23 起周末调整）
 
 周末（周六、周日）全天按谷价计费，不设高峰时段。
 
+按 DeepSeek 峰谷时间说明，能有高峰窗口的只有"既非周六周日、也非法定节假日"的普通工作日：
+
+| 日期 | 状态（北京时间） |
+| :-- | :-- |
+| 中国法定节假日 | 全天按空闲时段计费，与周末一致 |
+| 调休上班的周末 | 同样全天按空闲时段计费（调休不改计费，只影响标签） |
+
+所以 10 月 1 日显示 🟢 **国庆节**、调休的周六显示 🟢 **调休上班 · 谷价**，两者都不进高峰。
+
 ## 功能
 
 - 状态圆点——**红 = 高峰，绿 = 空闲**，外加实时北京时钟（`HH:MM:SS`，时区 `Asia/Shanghai`，与本机时区无关）
 - 倒计时：高峰时显示 `剩 3h 54m · 价格 ×2`，空闲时显示 `距高峰 3h 54m · 半价`
+- 节假日感知：法定节假日直接显示节日名（如 `国庆节`），并倒计时到假期结束后的第一个高峰窗口；调休上班的周末显示全天谷价并标注该日
 - 点击胶囊展开详情卡：高峰窗口、下一转折（含 `HH:MM:SS` 倒计时）、当前阶段进度条
 - 全部使用 Web UI 原生 `--dsw-alias-*` 主题变量，与界面完全融合，没有悬浮贴片
 - 持久挂载：重启 dsh web 后依然存在
@@ -41,10 +51,22 @@ dsh plugin --profile web add github:xiaoyi-xx/dsh-peak-status
 
 ## 使用
 
-胶囊每秒自动更新。点击展开/收起详情卡，悬停有快捷提示。高峰/空闲状态严格按上面官方时刻表、以北京时间计算。
+胶囊每秒自动更新。点击展开/收起详情卡，悬停有快捷提示。高峰/空闲状态严格按上面官方时刻表、以北京时间计算，并叠加中国官方工作日历。
 
 如果 DeepSeek 以后调整高峰时段，我们会发布包含新时段的新版本——发现不一致欢迎在仓库提 Issue。
 
+## 节假日表
+
+节假日表（法定节假日 + 调休上班日）通过网络获取，共三层降级：
+
+1. **host 同源路由** —— 插件 host 半提供 `/dsh-peak-status/holiday/<year>`。它先取 jiejiariapi、失败再取 apihubs，归一化两种返回结构并在内存缓存 6 小时，所有浏览器标签页共用一次拉取。
+2. **浏览器直连兜底** —— 路由不可用时，浏览器半改直连 `api.apihubs.cn`（该源允许跨域）。
+3. **纯周末规则** —— 完全拿不到日历时，胶囊行为与 1.0.3 完全一致：工作日窗口 + 周末全谷价。
+
+归一化后的结果还会写入 `localStorage` 缓存 24 小时，所以重启或短暂断网时状态依旧正确；详情卡始终标注数据来源（`已同步 · jiejiariapi` / `未同步 · 暂按周末规则`）。
+
+计费口径按 DeepSeek 峰谷时间说明：**调休上班的周末、中国法定节假日全天均按空闲时段计费**。日历提供的就是这两个标注——调休不会带来高峰窗口。
+
 ## 许可证
 
 [MIT](LICENSE)

package/lib/client.js

@@ -13,6 +13,13 @@
  *   weekends:        Saturday & Sunday all day at the valley price
  *   off-peak:        everything else (priced at half of peak)
  *
+ * The Chinese official work calendar refines that rule: per DeepSeek's peak/
+ * valley note, 中国法定节假日 and 调休上班的周末 are valley for the whole day —
+ * only ordinary Monday–Friday working days can peak. The calendar is fetched
+ * over the network — the
+ * host half serves it same-origin, a CORS-capable public source and finally
+ * the plain weekend rule are the fallbacks — and cached in localStorage.
+ *
  * Red = peak (bold), green = off-peak; live Beijing clock, countdown to the
  * next transition, click to expand a small popover with the full detail.
  * Mounted persistently via the profile's cordis.patch.yml, so it survives
@@ -71,10 +78,14 @@
     var PEAK_COLOR = 'var(--dsw-alias-state-error-primary, #e5484d)'
     var OFF_COLOR = 'var(--dsw-alias-state-success-primary, #30a46c)'
 
-    /** Beijing time parts incl. ISO weekday (1=Mon … 7=Sun), timezone-proof. */
+    /**
+     * Beijing time parts: calendar date (y/mo/d), clock, and ISO weekday
+     * (1=Mon … 7=Sun). `mo` is the month; minutes are `m`, timezone-proof.
+     */
     function bjParts() {
       var parts = new Intl.DateTimeFormat('en-GB', {
         timeZone: TZ, hour12: false, weekday: 'short',
+        year: 'numeric', month: '2-digit', day: '2-digit',
         hour: '2-digit', minute: '2-digit', second: '2-digit',
       }).formatToParts(new Date())
       var get = function (type) {
@@ -85,6 +96,9 @@
       }
       var wdMap = { Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6, Sun: 7 }
       return {
+        y: Number(get('year')),
+        mo: Number(get('month')),
+        d: Number(get('day')),
         h: Number(get('hour')),
         m: Number(get('minute')),
         s: Number(get('second')),
@@ -92,53 +106,315 @@
       }
     }
 
+    // ── 节假日表（网络拉取 + 本地缓存） ────────────────────────────────────
+    // 数据源优先级：host 半同源路由 → 浏览器可直连的 CORS 源 → 内置周末规则。
+    // 全部失败时退化成 1.0.3 的行为：胶囊照常工作，只在详情里标注未同步。
+    var CAL_ROUTE = '/dsh-peak-status/holiday/'
+    var CAL_CORS_URL = function (year) { return 'https://api.apihubs.cn/holiday/get?year=' + year + '&size=400' }
+    var CAL_TTL_MS = 24 * 60 * 60 * 1000
+    var CAL_TIMEOUT_MS = 8000
+    var CAL_KEY = 'dsh-peak-status:holiday:'
+    var CAL_SCAN_LIMIT = 40
+
+    /** year → { days, source, fetchedAt }；pending[year] 防止并发重复拉取。 */
+    var cal = { years: {}, pending: {}, listeners: [] }
+
+    /** 订阅节假日表变化，返回退订函数（React 侧用它触发重渲染）。 */
+    function calSubscribe(listener) {
+      cal.listeners.push(listener)
+      return function () {
+        var index = cal.listeners.indexOf(listener)
+        if (index >= 0) cal.listeners.splice(index, 1)
+      }
+    }
+
+    function calNotify() {
+      for (var i = 0; i < cal.listeners.length; i++) {
+        try { cal.listeners[i]() } catch (error) { /* 单个订阅者失败不影响其它 */ }
+      }
+    }
+
+    /** 'YYYY-MM-DD' —— 日历表的键。 */
+    function dayKey(y, mo, d) { return y + '-' + pad(mo) + '-' + pad(d) }
+
+    /** 自 1970-01-01 起的天序号；用 UTC 换算，绕开本地时区与夏令时。 */
+    function dayOrdinal(y, mo, d) { return Math.round(Date.UTC(y, mo - 1, d) / 86400000) }
+    function ordinalToParts(ordinal) {
+      var at = new Date(ordinal * 86400000)
+      return { y: at.getUTCFullYear(), mo: at.getUTCMonth() + 1, d: at.getUTCDate() }
+    }
+    /** 1970-01-01 是周四 → ISO 1=周一 … 7=周日。 */
+    function weekdayOf(ordinal) { return ((ordinal + 3) % 7 + 7) % 7 + 1 }
+
+    function storageGet(key) {
+      try { return window.localStorage.getItem(key) } catch (error) { return null }
+    }
+    function storageSet(key, value) {
+      try { window.localStorage.setItem(key, value) } catch (error) { /* 隐私模式/配额满：忽略 */ }
+    }
+
+    /** `20261001` 或 `2026-10-01` → `2026-10-01`；其它 → null。 */
+    function toIsoDate(value) {
+      if (typeof value === 'string') return /^\d{4}-\d{2}-\d{2}$/.test(value) ? value : null
+      if (typeof value !== 'number' || !isFinite(value)) return null
+      var text = String(Math.trunc(value))
+      return /^\d{8}$/.test(text) ? text.slice(0, 4) + '-' + text.slice(4, 6) + '-' + text.slice(6, 8) : null
+    }
+
+    /** 只保留结构正确的条目，脏缓存不至于把 UI 弄崩。 */
+    function sanitizeDays(days) {
+      if (days === null || typeof days !== 'object') return null
+      var out = {}
+      var count = 0
+      for (var key in days) {
+        if (!Object.prototype.hasOwnProperty.call(days, key)) continue
+        var row = days[key]
+        if (row === null || typeof row !== 'object' || typeof row.off !== 'boolean') continue
+        out[key] = { name: typeof row.name === 'string' ? row.name : '', off: row.off }
+        count++
+      }
+      return count > 0 ? out : null
+    }
+
+    /** jiejiariapi：{ 'YYYY-MM-DD': { date, name, isOffDay } }，只列特殊日。 */
+    function fromJiejiariapi(payload) {
+      if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return null
+      var days = {}
+      var count = 0
+      for (var key in payload) {
+        if (!Object.prototype.hasOwnProperty.call(payload, key)) continue
+        var row = payload[key]
+        if (row === null || typeof row !== 'object' || typeof row.isOffDay !== 'boolean') continue
+        var date = toIsoDate(row.date === undefined ? key : row.date)
+        if (date === null) continue
+        days[date] = { name: typeof row.name === 'string' ? row.name : '', off: row.isOffDay }
+        count++
+      }
+      return count > 0 ? days : null
+    }
+
     /**
-     * Peak/off-peak state at a Beijing-time instant.
-     * Weekends (Sat/Sun) are all-day off-peak; weekdays follow the peak
-     * windows 09:00–12:00 / 14:00–18:00. Returns the next state boundary as
-     * { nextMin, daysAhead } (daysAhead counts how many Beijing days away),
-     * seconds until it, and the progress through the current phase.
+     * apihubs：{ data: { list: [ { date: 20261001, holiday_recess, holiday_overtime } ] } }。
+     * 数字是节日编码：holiday_recess=1 放假，holiday_overtime≠10 为调休补班（见下方注释）。
      */
-    function compute(t) {
-      var now = t.h * 60 + t.m
-      var weekend = t.weekday === 6 || t.weekday === 7
-      var peak, nextMin, daysAhead, phaseStartMin, phaseLenMin
+    function fromApihubs(payload) {
+      if (payload === null || typeof payload !== 'object') return null
+      var data = payload.data !== null && typeof payload.data === 'object' ? payload.data : payload
+      var list = Array.isArray(data.list) ? data.list : (Array.isArray(data) ? data : null)
+      if (list === null) return null
+      var days = {}
+      var count = 0
+      for (var i = 0; i < list.length; i++) {
+        var row = list[i]
+        if (row === null || typeof row !== 'object') continue
+        var date = toIsoDate(row.date)
+        if (date === null) continue
+        // apihubs 用节日编号编码：holiday_recess=1 是放假日，holiday_overtime
+        // 为 10 表示非调休，其余值（11/22/55/88…）都是周末补班。
+        var off = row.holiday_recess === 1
+        var overtime = typeof row.holiday_overtime === 'number' && row.holiday_overtime !== 10
+        if (!off && !overtime) continue
+        days[date] = { name: '', off: off }
+        count++
+      }
+      return count > 0 ? days : null
+    }
+
+    /** 归一化任一支持的载荷（host 路由 / jiejiariapi / apihubs）。 */
+    function normalizeCalendar(payload) {
+      if (payload === null || typeof payload !== 'object') return null
+      if (payload.days !== undefined) return sanitizeDays(payload.days)
+      return fromJiejiariapi(payload) || fromApihubs(payload)
+    }
+
+    /** 带超时的 JSON 拉取；浏览器不支持 fetch 时直接失败，走下一层降级。 */
+    function fetchJson(url) {
+      return new Promise(function (resolve, reject) {
+        if (typeof fetch !== 'function') { reject(new Error('fetch unavailable')); return }
+        var controller = typeof AbortController === 'function' ? new AbortController() : null
+        var timer = setTimeout(function () {
+          if (controller !== null) controller.abort()
+          reject(new Error('timeout'))
+        }, CAL_TIMEOUT_MS)
+        var options = { headers: { accept: 'application/json' } }
+        if (controller !== null) options.signal = controller.signal
+        fetch(url, options).then(function (response) {
+          if (!response.ok) throw new Error('HTTP ' + response.status)
+          return response.json()
+        }).then(function (json) {
+          clearTimeout(timer)
+          resolve(json)
+        }, function (error) {
+          clearTimeout(timer)
+          reject(error)
+        })
+      })
+    }
+
+    /** 读缓存：内存 → localStorage。 */
+    function cachedYear(year) {
+      var entry = cal.years[year]
+      if (entry !== undefined) return entry
+      var raw = storageGet(CAL_KEY + year)
+      if (raw === null) return null
+      var parsed = null
+      try { parsed = JSON.parse(raw) } catch (error) { return null }
+      if (parsed === null || typeof parsed !== 'object') return null
+      var days = sanitizeDays(parsed.days)
+      if (days === null) return null
+      entry = { days: days, source: String(parsed.source || 'cache'), fetchedAt: Number(parsed.fetchedAt) || 0 }
+      cal.years[year] = entry
+      return entry
+    }
 
+    /** 拉取一年：先同源路由（含节日名），再浏览器可直连的 CORS 源。 */
+    function loadYear(year) {
+      return fetchJson(CAL_ROUTE + year).then(function (payload) {
+        var days = normalizeCalendar(payload)
+        if (days === null) return null
+        return {
+          days: days,
+          source: String(payload === null || payload === undefined || payload.source === undefined ? 'host' : payload.source),
+          fetchedAt: Date.now(),
+        }
+      }, function () { return null }).then(function (entry) {
+        if (entry !== null) return entry
+        return fetchJson(CAL_CORS_URL(year)).then(function (payload) {
+          var days = normalizeCalendar(payload)
+          return days === null ? null : { days: days, source: 'apihubs', fetchedAt: Date.now() }
+        }, function () { return null })
+      })
+    }
+
+    /** 需要时异步补拉一年；命中新鲜缓存或已在拉取则直接返回。 */
+    function ensureYear(year) {
+      var entry = cachedYear(year)
+      if (entry !== null && Date.now() - entry.fetchedAt < CAL_TTL_MS) return
+      if (cal.pending[year] === true) return
+      cal.pending[year] = true
+      loadYear(year).then(function (loaded) {
+        cal.pending[year] = false
+        if (loaded === null) { calNotify(); return }
+        cal.years[year] = loaded
+        storageSet(CAL_KEY + year, JSON.stringify({ source: loaded.source, fetchedAt: loaded.fetchedAt, days: loaded.days }))
+        calNotify()
+      }, function () {
+        cal.pending[year] = false
+        calNotify()
+      })
+    }
+
+    /** 该年的日历；未同步/未缓存 → null，调用方按周末规则退化。 */
+    function daysOfYear(year) {
+      var entry = cachedYear(year)
+      return entry === null ? null : entry.days
+    }
+
+    /** 详情卡里的同步状态文案。 */
+    function calStatusText(year) {
+      if (cal.years[year] !== undefined) return '已同步 · ' + cal.years[year].source
+      if (cal.pending[year] === true) return '同步中…'
+      return '未同步 · 暂按周末规则'
+    }
+
+    /**
+     * 一天的"能否有高峰窗口 + 计费属性"。
+     *
+     * 官方口径（DeepSeek API 峰谷时间说明）：**调休上班的周末、中国法定节假
+     * 日，全天均按空闲时段计费**。所以能进入高峰窗口的只有"既不是周六周日、
+     * 也不是法定节假日"的普通工作日：
+     *   法定节假日              → 全天谷价（哪怕落在周一~周五）
+     *   周六/周日（含调休上班）  → 全天谷价（调休不改计费，只影响标签）
+     *   其余周一~周五            → 高峰窗口 09:00–12:00 / 14:00–18:00
+     * 无日历：退化成 1.0.3 的规则（周六周日谷价，其余工作日窗口）——对普通周
+     * 末与工作日而言与官方口径一致，唯一差别是节假日落在工作日时按高峰算。
+     *
+     * @param key - 'YYYY-MM-DD'。
+     * @param weekday - ISO 1=周一 … 7=周日。
+     * @param days - 该年归一化日历或 null。
+     * @returns {rest, kind, name}，kind ∈ holiday | makeup | weekend | weekday。
+     */
+    function classifyDay(key, weekday, days) {
+      var row = days === null || days === undefined ? null : days[key]
+      var weekend = weekday === 6 || weekday === 7
+      var name = row === undefined || row === null ? '' : (row.name || '')
+      if (row !== undefined && row !== null && row.off === true) {
+        return { rest: true, kind: 'holiday', name: name }
+      }
       if (weekend) {
-        peak = false
-        nextMin = BOUNDS[0] // Monday 09:00
-        daysAhead = ((1 - t.weekday + 7) % 7) || 7 // Sat → 2, Sun → 1
-        var daysSinceSat = (t.weekday - 6 + 7) % 7 // Sat=0, Sun=1
-        phaseStartMin = daysSinceSat * 1440
-        phaseLenMin = 2 * 1440 + BOUNDS[0] // Sat 00:00 → Mon 09:00
-      } else {
-        peak = (now >= BOUNDS[0] && now < BOUNDS[1]) || (now >= BOUNDS[2] && now < BOUNDS[3])
-        var next = null
+        // 调休上班的周末依旧全天谷价，只换个标签说明"这天本该上班"。
+        return { rest: true, kind: row === undefined || row === null ? 'weekend' : 'makeup', name: name }
+      }
+      return { rest: false, kind: 'weekday', name: name }
+    }
+
+    function classifyOrdinal(ordinal, daysOf) {
+      var parts = ordinalToParts(ordinal)
+      return classifyDay(dayKey(parts.y, parts.mo, parts.d), weekdayOf(ordinal), daysOf(parts.y))
+    }
+
+    /** 下一个转折点：当天剩下的窗口边界，或下一个工作日 09:00（可跨假期）。 */
+    function nextTransition(ordinal, nowMin, daysOf) {
+      if (!classifyOrdinal(ordinal, daysOf).rest) {
         for (var i = 0; i < BOUNDS.length; i++) {
-          if (BOUNDS[i] > now) { next = BOUNDS[i]; break }
+          if (BOUNDS[i] > nowMin) return { ordinal: ordinal, min: BOUNDS[i] }
         }
-        if (next !== null) {
-          nextMin = next
-          daysAhead = 0
-          var ps = 0
-          for (var j = BOUNDS.length - 1; j >= 0; j--) {
-            if (BOUNDS[j] <= now) { ps = BOUNDS[j]; break }
-          }
-          phaseStartMin = ps
-          phaseLenMin = nextMin - ps
-        } else {
-          nextMin = BOUNDS[0]
-          // After 18:00: Friday → next Monday 09:00 (3 days), otherwise next day 09:00.
-          daysAhead = t.weekday === 5 ? 3 : 1
-          phaseStartMin = BOUNDS[3]
-          phaseLenMin = daysAhead * 1440 + BOUNDS[0] - phaseStartMin
+      }
+      for (var step = 1; step <= CAL_SCAN_LIMIT; step++) {
+        var ahead = ordinal + step
+        if (!classifyOrdinal(ahead, daysOf).rest) return { ordinal: ahead, min: BOUNDS[0] }
+      }
+      return { ordinal: ordinal + 1, min: BOUNDS[0] } // 40 天内没有工作日：理论上不可达
+    }
+
+    /** 上一个转折点：当天已过的最后一个边界，或上一个工作日 18:00。 */
+    function prevTransition(ordinal, nowMin, daysOf) {
+      if (!classifyOrdinal(ordinal, daysOf).rest) {
+        for (var i = BOUNDS.length - 1; i >= 0; i--) {
+          if (BOUNDS[i] <= nowMin) return { ordinal: ordinal, min: BOUNDS[i] }
         }
       }
+      for (var step = 1; step <= CAL_SCAN_LIMIT; step++) {
+        var behind = ordinal - step
+        if (!classifyOrdinal(behind, daysOf).rest) return { ordinal: behind, min: BOUNDS[3] }
+      }
+      return { ordinal: ordinal - 1, min: BOUNDS[3] } // 40 天内没有工作日：理论上不可达
+    }
 
-      var secsToNext = daysAhead * 86400 + (nextMin - now) * 60 - t.s
-      var elapsedMin = weekend ? daysSinceSat * 1440 + now : now - phaseStartMin
-      var progress = phaseLenMin > 0 ? Math.min(100, Math.max(0, (elapsedMin / phaseLenMin) * 100)) : 0
-      return { peak: peak, nextMin: nextMin, daysAhead: daysAhead, secsToNext: secsToNext, progress: progress }
+    /**
+     * Peak/off-peak state at one Beijing-time instant.
+     * The official work calendar decides which days may peak at all: statutory
+     * holidays and every Saturday/Sunday (调休 makeup weekends included) are
+     * valley across their whole span, so both the current state and its
+     * neighbouring transitions are found by scanning days instead of weekday
+     * arithmetic.
+     * @param t - bjParts() result (calendar date, clock, ISO weekday).
+     * @param daysOf - year → normalized days; defaults to the loaded cache.
+     * @returns { peak, nextMin, daysAhead, nextOrdinal, nextWeekday, secsToNext, progress, day }
+     */
+    function compute(t, daysOf) {
+      var lookup = daysOf === undefined ? daysOfYear : daysOf
+      var ordinal = dayOrdinal(t.y, t.mo, t.d)
+      var nowMin = t.h * 60 + t.m
+      var day = classifyDay(dayKey(t.y, t.mo, t.d), t.weekday, lookup(t.y))
+      var peak = !day.rest &&
+        ((nowMin >= BOUNDS[0] && nowMin < BOUNDS[1]) || (nowMin >= BOUNDS[2] && nowMin < BOUNDS[3]))
+      var next = nextTransition(ordinal, nowMin, lookup)
+      var prev = prevTransition(ordinal, nowMin, lookup)
+      var nowAbs = ordinal * 1440 + nowMin
+      var nextAbs = next.ordinal * 1440 + next.min
+      var prevAbs = prev.ordinal * 1440 + prev.min
+      var phaseLen = nextAbs - prevAbs
+      return {
+        peak: peak,
+        nextMin: next.min,
+        daysAhead: next.ordinal - ordinal,
+        nextOrdinal: next.ordinal,
+        nextWeekday: weekdayOf(next.ordinal),
+        secsToNext: (nextAbs - nowAbs) * 60 - t.s,
+        progress: phaseLen > 0 ? Math.min(100, Math.max(0, ((nowAbs - prevAbs) / phaseLen) * 100)) : 0,
+        day: day,
+      }
     }
 
     function pad(n) { return (n < 10 ? '0' : '') + n }
@@ -159,12 +435,17 @@
       var sec = s % 60
       return pad(h) + ':' + pad(m) + ':' + pad(sec)
     }
-    /** Human label for the next boundary: "18:00" / "明天 09:00" / "周一 09:00". */
-    function fmtBoundaryLabel(t, s) {
+    /**
+     * Human label for the next boundary: "18:00" / "明天 09:00" / "周一 09:00",
+     * and an explicit date once the jump passes a week — a 国庆 break or a 调休
+     * week easily spans six days and a weekday name would read as next week.
+     */
+    function fmtBoundaryLabel(s) {
       if (s.daysAhead === 0) return fmtBoundary(s.nextMin)
       if (s.daysAhead === 1) return '明天 ' + fmtBoundary(s.nextMin)
-      var nextW = ((t.weekday - 1 + s.daysAhead) % 7) + 1
-      return '周' + WEEKDAY_LABELS[nextW - 1] + ' ' + fmtBoundary(s.nextMin)
+      if (s.daysAhead <= 6) return '周' + WEEKDAY_LABELS[s.nextWeekday - 1] + ' ' + fmtBoundary(s.nextMin)
+      var parts = ordinalToParts(s.nextOrdinal)
+      return pad(parts.mo) + '-' + pad(parts.d) + ' ' + fmtBoundary(s.nextMin)
     }
 
     function PeakChip() {
@@ -173,25 +454,51 @@
       var setTick = tickState[1]
       var open = react.useState(false)
       var setOpen = open[1]
+      var setBump = react.useState(0)[1]
 
       react.useEffect(function () {
-        var id = setInterval(function () { setTick(bjParts()) }, 1000)
+        var id = setInterval(function () {
+          var next = bjParts()
+          setTick(next)
+          ensureYear(next.y)
+          if (next.mo === 12) ensureYear(next.y + 1) // 跨年：提前取下一年的表
+        }, 1000)
         return function () { clearInterval(id) }
       }, [])
 
+      // The calendar arrives asynchronously — re-render when it lands. Until
+      // then compute() degrades to the plain weekday/weekend rule on its own.
+      react.useEffect(function () {
+        return calSubscribe(function () { setBump(function (n) { return n + 1 }) })
+      }, [])
+
       var s = compute(tick)
-      var weekend = tick.weekday === 6 || tick.weekday === 7
+      var day = s.day
       var color = s.peak ? PEAK_COLOR : OFF_COLOR
       var clock = fmtClock(tick)
-      var boundaryLabel = fmtBoundaryLabel(tick, s)
+      var boundaryLabel = fmtBoundaryLabel(s)
+      var stateWord = s.peak
+        ? '高峰期'
+        : (day.kind === 'holiday'
+          ? (day.name || '法定节假日')
+          : (day.kind === 'weekend' ? '周末谷价' : (day.kind === 'makeup' ? '调休上班 · 谷价' : '空闲期')))
+      var dayNote = day.kind === 'holiday'
+        ? ('今日' + (day.name === '' ? '为法定节假日' : '为' + day.name) + '：全天按谷价计费。')
+        : (day.kind === 'makeup'
+          ? ('今日为调休上班日（周' + WEEKDAY_LABELS[tick.weekday - 1] + '）：官方口径仍全天按空闲时段计费。')
+          : '')
+      var offNote = day.kind === 'holiday'
+        ? ('（' + (day.name === '' ? '法定节假日' : day.name) + ' 全天谷价）')
+        : (day.kind === 'makeup' ? '（调休上班，全天谷价）' : (day.kind === 'weekend' ? '（周末全天谷价）' : ''))
+      var tooltip = (s.peak
+        ? '高峰期（工作日 9:00-12:00 / 14:00-18:00）：价格 = 空闲 ×2。' + boundaryLabel + ' 结束。'
+        : '空闲期：价格为高峰一半' + offNote + '，下一高峰 ' + boundaryLabel + '。') + dayNote + '点击展开详情'
 
       var chip = react.createElement(
         'div',
         {
           onClick: function () { setOpen(!open[0]) },
-          title: s.peak
-            ? '高峰期（工作日 9:00-12:00 / 14:00-18:00）：价格 = 空闲 ×2。' + boundaryLabel + ' 结束，点击展开详情'
-            : '空闲期：价格为高峰一半' + (weekend ? '（周末全天谷价）' : '') + '。下一高峰 ' + boundaryLabel + '，点击展开详情',
+          title: tooltip,
           style: {
             display: 'inline-flex', alignItems: 'center', gap: 6,
             fontFamily: FONT, fontSize: 12, lineHeight: '20px',
@@ -203,8 +510,7 @@
         },
         [
           react.createElement('span', { key: 'dot', style: { width: 7, height: 7, borderRadius: '50%', background: color, flexShrink: 0 } }),
-          react.createElement('span', { key: 'state', style: { fontWeight: s.peak ? 700 : 500, color: color } },
-            s.peak ? '高峰期' : (weekend ? '周末谷价' : '空闲期')),
+          react.createElement('span', { key: 'state', style: { fontWeight: s.peak ? 700 : 500, color: color } }, stateWord),
           react.createElement('span', { key: 'clock', style: { fontVariantNumeric: 'tabular-nums' } }, clock),
           react.createElement('span', { key: 'count', style: { fontVariantNumeric: 'tabular-nums' } },
             s.peak
@@ -233,7 +539,7 @@
         [
           react.createElement('div', { key: 'l1', style: { display: 'flex', alignItems: 'center', gap: 6 } }, [
             react.createElement('span', { key: 'st', style: { fontWeight: 700, color: color } },
-              s.peak ? '高峰时段' : (weekend ? '周末谷价' : '空闲时段')),
+              s.peak ? '高峰时段' : stateWord),
             react.createElement('span', { key: 'tm', style: { fontVariantNumeric: 'tabular-nums' } },
               clock + '（北京）'),
             react.createElement('span', { key: 'price', style: { color: color, fontWeight: 500 } },
@@ -241,8 +547,11 @@
           ]),
           react.createElement('div', { key: 'l2' },
             '高峰窗口（工作日）：09:00–12:00 / 14:00–18:00'),
-          react.createElement('div', { key: 'l2b', style: { color: weekend ? OFF_COLOR : DIM, fontWeight: weekend ? 600 : 400 } },
-            '周末（周六、周日）：全天按谷价计费'),
+          react.createElement('div', { key: 'l2b', style: { color: day.rest ? OFF_COLOR : DIM, fontWeight: day.rest ? 600 : 400 } },
+            '法定节假日与周末（周六、周日）：全天按谷价计费'),
+          react.createElement('div', { key: 'l2c', style: { color: day.kind === 'makeup' ? OFF_COLOR : DIM, fontWeight: day.kind === 'makeup' ? 600 : 400 } },
+            '调休上班的周末：仍全天按谷价计费（官方口径）'),
+          dayNote === '' ? null : react.createElement('div', { key: 'daynote', style: { color: color, fontWeight: 600 } }, dayNote),
           react.createElement('div', { key: 'l3', style: { fontVariantNumeric: 'tabular-nums' } },
             '下一转折：' + boundaryLabel + ' · 倒计时 ' + fmtDurFull(s.secsToNext)),
           react.createElement('div', { key: 'bar', style: { display: 'flex', alignItems: 'center', gap: 8 } }, [
@@ -255,6 +564,8 @@
             react.createElement('span', { key: 'pct', style: { fontSize: 10.5, fontVariantNumeric: 'tabular-nums' } },
               s.progress.toFixed(0) + '%'),
           ]),
+          react.createElement('div', { key: 'cal', style: { fontSize: 10.5, opacity: 0.85 } },
+            '节假日表（北京）：' + calStatusText(tick.y)),
           react.createElement('div', { key: 'foot', style: { fontSize: 10.5, lineHeight: 1.5, opacity: 0.85 } },
             '官方峰谷定价 8/17 生效，8/23 起周末全天谷价；空闲价 = 高峰一半。'),
         ],
@@ -286,6 +597,23 @@
 
     exports.apply = apply
     exports.inject = inject
+    // Test seam for scripts/test-peak.mjs: the harness drives these pure
+    // functions directly instead of mirroring them, so the shipped algorithm
+    // is the one under test. The loader never reads it.
+    exports.__test = {
+      compute: compute,
+      classifyDay: classifyDay,
+      dayKey: dayKey,
+      dayOrdinal: dayOrdinal,
+      ordinalToParts: ordinalToParts,
+      weekdayOf: weekdayOf,
+      normalizeCalendar: normalizeCalendar,
+      calRoute: CAL_ROUTE,
+      calCorsUrl: CAL_CORS_URL,
+      calStatusText: calStatusText,
+      ensureYear: ensureYear,
+      daysOfYear: daysOfYear,
+    }
     return module.exports
   }