dsh-plugin-usage 0.1.3 → 0.2.0

package/README.md

@@ -22,6 +22,12 @@ DeepSeek Harness 的 **Token 用量统计**插件（UI 参考 CC Switch 的「
 - 💰 **定价配置** — 为模型设置每百万 Token 价格（输入 / 输出 / 缓存命中 / 缓存创建），保存后立即生效
 - 🌗 **主题自适应** — 跟随 DSH 深/浅色主题，无第三方图表库
 
+## 效果图
+
+![alt text](image.png)
+
+![alt text](image-1.png)
+
 ## 安装与构建 / Install & Build
 
 ```sh
@@ -86,7 +92,9 @@ dsh web --patch /path/to/dsh-plugin-usage/cordis.yml
 - DSH 的 agent loop 会把每次模型调用的用量以 `assistant/message` 会话事件（携带 `usage`：输入/输出/缓存命中/缓存创建 Token 与 `message.source.{provider,model}`）写入会话日志（`~/.dsh/sessions/`）。
 - 插件启动时**回填（backfill）全部历史会话**，之后每 2s 增量扫描活跃会话（内存），每 30s 增量扫描持久化会话（按 seq 水位）。
 - 覆盖范围：所有 agent loop 调用（含子代理）。compaction / session-title 等辅助调用不写入会话日志，不在统计范围内。
+- 去重：按会话内 `(turn, step)` 去重——同一 `(turn, step)` 的后续用量事件**替换**先前样本，而不是重复累计。
 - 费用 = `(输入×输入价 + 输出×输出价 + 缓存命中×缓存命中价 + 缓存创建×缓存创建价) / 1e6`，价格表可改。
+- 价格表持久化：官方 DSH settings 服务可用时，价格表经 `usage.prices` settings 命名空间持久化（重启后保留，并出现在官方 Plugins 配置页）；否则回退到进程内存（仅本次运行有效）。
 
 > 动态插件形态下数据保存在进程内存中，重启后自动从会话日志重新回填，无需落盘文件。
 
@@ -94,7 +102,17 @@ dsh web --patch /path/to/dsh-plugin-usage/cordis.yml
 
 ```
 src/
-├── host/index.js     Host half：采集（扫描/回填）+ 聚合 + 价格表 + RPC（usage/query、usage/prices、usage/client-source）
+├── host/
+│   ├── index.js         Host 入口：接线 fold / scan / query / settings / aggregate / rpc / client-source，驱动定时扫描
+│   ├── settings.js      价格表 + 费用计算（内置 DeepSeek 常见模型默认价，可选 settings 命名空间持久化）
+│   ├── state.js         运行时状态：records / watermarks / backfill / dedup / index
+│   ├── aggregate.js     增量聚合索引：add / remove / recordsInRange，供查询高效取数
+│   ├── fold.js          会话事件 → usage 记录（含会话内 (turn, step) 去重替换）
+│   ├── scan.js          启动回填 + 活跃/持久化会话的增量扫描（每 tick / 每 30s，按 seq 水位）
+│   ├── query.js         聚合与查询：按天/按模型汇总、未定价检测、heatmap
+│   ├── rpc.js           RPC 注册：usage/query、usage/prices、usage/client-source（动态 harness 与静态 connection 桥）
+│   ├── client-source.js 读取 src/client/index.js 实时提供给浏览器（动态插件形态）
+│   └── time.js          时间分桶：day/hour/minute 粒度与 step 网格（纯函数）
 ├── client/index.js   Client half：设置页「用量统计」仪表盘（筛选/汇总卡/柱状图/模型表/定价配置），样式内联
 └── client/styles.js  UI 样式源（构建脚本已合并进 index.js，可删除）
 scripts/
@@ -102,10 +120,21 @@ scripts/
 cordis.patch.yml      bundle patch：`dsh plugin add` 安装后由 `dsh.bundle` 声明自动激活
 ```
 
+## 开发与测试 / Development & Testing
+
+```sh
+npm install        # 首次安装依赖（devDependencies：typescript）
+npm run build      # tsc 输出到 lib/，再由 scripts/build-client.js 生成 client 模块入口
+npm test           # node --test tests/
+```
+
+`src/host/` 下的宿主逻辑（fold / scan / query / aggregate / time / settings 等）均为可直接
+import 的 ESM 模块，单元测试直接运行，无需启动 DSH harness。
+
 ## 说明 / Notes
 
 - 插件名 `usage`；动态插件运行在会话级，卸载后统计重新回填即可恢复。
-- 价格表修改在进程内有效（动态插件形态）；正式 patch 加载后可扩展为落盘持久化。
+- 价格表持久化策略见「数据来源与口径」（官方 settings 可用时走 `usage.prices` 命名空间，否则进程内存回退）。
 
 ## 开源协议 / License
 

package/lib/client/index.js

@@ -978,6 +978,32 @@ const CSS = `
 // RPC bridge: dynamic-plugin runs provide a `host` global; static (bundle)
 // installs provide ctx.get('connection').rpc. Keep one UI source for both.
 function hostCall(method, args) {
+  // P0-3: prefer the official `remote` service when it exposes the usage API;
+  // otherwise fall through to the host/connection fallbacks unchanged.
+  const remoteScope = (typeof ctx !== 'undefined' && ctx && typeof ctx.get === 'function')
+    ? ctx
+    : (typeof _usageCtx !== 'undefined' && _usageCtx && typeof _usageCtx.get === 'function' ? _usageCtx : null)
+  if (remoteScope && typeof remoteScope.get === 'function') {
+    try {
+      const remote = remoteScope.get('remote')
+      if (remote && remote.usage) {
+        const rName = String(method)
+        const rSlash = rName.indexOf('/')
+        const rEp = rSlash === -1 ? rName : rName.slice(rSlash + 1)
+        const rCamel = rEp.replace(/-([a-z])/g, (m, c) => c.toUpperCase())
+        const fn = (typeof remote.usage[rCamel] === 'function' && remote.usage[rCamel])
+          || (typeof remote.usage[rEp] === 'function' && remote.usage[rEp])
+        if (fn) {
+          return Promise.resolve().then(() => fn(args)).then((res) => {
+            if (res && res.ok) return res.value
+            throw new Error((res && res.error && res.error.message) || ('RPC ' + method + ' failed'))
+          })
+        }
+      }
+    } catch (e) {
+      // remote probing failed — fall through to the existing fallbacks
+    }
+  }
   if (typeof host !== 'undefined' && host && typeof host.call === 'function') {
     return Promise.resolve(host.call(method, args))
   }
@@ -1002,6 +1028,61 @@ function hostCall(method, args) {
     throw new Error((res && res.error && res.error.message) || ('RPC ' + method + ' failed'))
   })
 }
+
+/* ---------------------------------------------------------------------------
+ * 设置域定价：官方 ctx.settingsScope（dsh-client-ui-settings）优先，
+ * 不可用时回退 usage/prices RPC。绑定只做一次，读写共用同一 scope。
+ * ------------------------------------------------------------------------- */
+let usageCtx = null
+let _usagePricesScope = null
+
+function resolveUsageCtx() {
+  if (usageCtx && typeof usageCtx.get === 'function') return usageCtx
+  if (typeof _usageCtx !== 'undefined' && _usageCtx && typeof _usageCtx.get === 'function') return _usageCtx
+  return null
+}
+
+function getUsagePricesScope() {
+  if (_usagePricesScope) return _usagePricesScope
+  const c = resolveUsageCtx()
+  if (!c || typeof c.get !== 'function') return null
+  try {
+    const binder = c.get('settingsScope')
+    if (!binder || typeof binder.bind !== 'function') return null
+    _usagePricesScope = binder.bind({ namespace: 'usage.prices' })
+    return _usagePricesScope
+  } catch (e) {
+    return null
+  }
+}
+
+// 价格写入口：settings scope 可用时写 usage.prices 命名空间字段，
+// 否则回退 usage/prices RPC（当前 UI 无价格编辑器，保留此写入 seam 供后续使用）。
+function usageSavePrices(next) {
+  const args = {}
+  if (next && typeof next === 'object') {
+    if (next.prices !== undefined) args.prices = next.prices
+    if (next.currency !== undefined) args.currency = next.currency
+  }
+  try {
+    const scope = getUsagePricesScope()
+    if (scope && typeof scope.set === 'function') {
+      const jobs = []
+      if (args.prices !== undefined) jobs.push(scope.set('prices', args.prices))
+      if (args.currency !== undefined) jobs.push(scope.set('currency', args.currency))
+      if (jobs.length > 0) {
+        return Promise.all(jobs).then(() => {
+          const snap = typeof scope.getSnapshot === 'function' ? scope.getSnapshot() : null
+          return snap && snap.value ? snap.value : null
+        })
+      }
+    }
+  } catch (e) {
+    // fall through to the RPC write path
+  }
+  return hostCall('usage/prices', args)
+}
+
 ;
 const h = React.createElement
 
@@ -1388,6 +1469,14 @@ function CustomRangePopover(props) {
   const [from, setFrom] = React.useState(custom.from)
   const [to, setTo] = React.useState(custom.to)
   const invalid = !from || !to || from > to
+  // P2-11：dialog 以 Escape 关闭
+  React.useEffect(() => {
+    function onKey(e) {
+      if (e.key === 'Escape' || e.key === 'Esc') onClose()
+    }
+    document.addEventListener('keydown', onKey)
+    return () => document.removeEventListener('keydown', onKey)
+  }, [onClose])
   return h('div', {
     className: 'tsd-popover tsd-range-popover',
     role: 'dialog',
@@ -1435,8 +1524,15 @@ function ModelDropdown(props) {
     function handler(e) {
       if (anchorRef.current && !anchorRef.current.contains(e.target)) setOpen(false)
     }
+    function onKey(e) {
+      if (e.key === 'Escape' || e.key === 'Esc') setOpen(false)
+    }
     document.addEventListener('click', handler)
-    return () => document.removeEventListener('click', handler)
+    document.addEventListener('keydown', onKey)
+    return () => {
+      document.removeEventListener('click', handler)
+      document.removeEventListener('keydown', onKey)
+    }
   }, [open])
 
   // 只列出当前范围有数据的模型；已选但掉出候选列表的「补回」，保证可渲染、可清除
@@ -2128,6 +2224,10 @@ function StatsDashboard(props) {
   const [data, setData] = React.useState(null)
   const [error, setError] = React.useState(null)
   const [prices, setPrices] = React.useState({ prices: {}, currency: '¥' })
+  // P1-6 backfill 轮询状态：queryKey 变化时重置，仅对同一查询串轮询
+  const queryKeyRef = React.useRef(null)
+  const backfillSeenRef = React.useRef(false)
+  const finalRefreshRef = React.useRef(false)
 
   const eff = React.useMemo(() => rangeFor(range, custom), [range, custom])
   // Fixed step policy: today = hourly; 7d/30d/custom = daily, custom uses a
@@ -2137,8 +2237,18 @@ function StatsDashboard(props) {
   const granLabel = stepLabel(t, range, stepDays)
 
   // 查询统计（首载骨架；刷新保留旧数据转 refreshing；fill 0 填充 + 年度热力图）
+  // P1-6：backfill running 时每 3s 自动重查；done 后补一次收尾查询即停。
   React.useEffect(() => {
     let current = true
+    let backfillTimer = null
+    const queryKey = eff.from + '|' + eff.to + '|' + models.join(',') + '|' + effGran + '|' + stepDays
+    if (queryKeyRef.current !== queryKey) {
+      queryKeyRef.current = queryKey
+      backfillSeenRef.current = false
+      finalRefreshRef.current = false
+    }
+    const isFinalRun = finalRefreshRef.current
+    finalRefreshRef.current = false
     setStatus((s) => (s === 'ready' && data !== null ? 'refreshing' : 'loading'))
     hostCall('usage/query', {
       from: eff.from,
@@ -2154,21 +2264,68 @@ function StatsDashboard(props) {
         setData(r)
         setStatus('ready')
         setError(null)
+        const bs = r && r.backfill ? r.backfill.status : null
+        if (bs === 'running') {
+          backfillSeenRef.current = true
+          // 同一 effect 至多挂一个定时器；重查复用 retry 计数器触发 effect 重跑
+          backfillTimer = setTimeout(() => {
+            if (current) setRetry((v) => v + 1)
+          }, 3000)
+        } else if (bs === 'done' && backfillSeenRef.current && !isFinalRun) {
+          // 回填收尾：恰好再查一次拿到完整数据后停止
+          finalRefreshRef.current = true
+          setRetry((v) => v + 1)
+        }
       }, (e) => {
         if (!current) return
         setError(e)
         setStatus('error')
       })
-    return () => { current = false }
+    return () => {
+      current = false
+      if (backfillTimer !== null) clearTimeout(backfillTimer)
+    }
   }, [eff.from, eff.to, models, effGran, stepDays, retry])
 
-  // 价格表：进入页面拉一次 + 每次刷新同步
+  // 价格表：进入页面拉一次 + 每次刷新同步。
+  // P0-1：优先官方 settings scope（usage.prices 命名空间），不可用时回退 RPC。
   React.useEffect(() => {
     let current = true
-    hostCall('usage/prices').then((p) => {
-      if (current && p && p.prices) setPrices(p)
-    }, () => {})
-    return () => { current = false }
+    let scopeDispose = null
+    const loadRpc = () => {
+      hostCall('usage/prices').then((p) => {
+        if (current && p && p.prices) setPrices(p)
+      }, () => {})
+    }
+    try {
+      const scope = getUsagePricesScope()
+      if (scope && typeof scope.getSnapshot === 'function' && typeof scope.subscribe === 'function') {
+        let adopted = false
+        const adopt = () => {
+          if (!current) return
+          const snap = scope.getSnapshot()
+          const v = snap && snap.value
+          if (snap && snap.status === 'unavailable') return
+          if (v && (v.prices || v.currency)) {
+            adopted = true
+            setPrices({ prices: v.prices || {}, currency: v.currency || '¥' })
+          }
+        }
+        adopt()
+        scopeDispose = scope.subscribe(adopt)
+        if (!adopted) loadRpc() // scope 未就绪/无值：先走 RPC，订阅就绪后 scope 优先覆盖
+      } else {
+        loadRpc()
+      }
+    } catch (e) {
+      loadRpc() // 探测/绑定异常：完整回退 RPC，绝不抛出
+    }
+    return () => {
+      current = false
+      if (scopeDispose) {
+        try { scopeDispose() } catch (e) {}
+      }
+    }
   }, [retry])
 
   const reload = React.useCallback(() => setRetry((v) => v + 1), [])
@@ -2235,6 +2392,8 @@ function StatsDashboard(props) {
  * 注册：settings.section 页面
  * ------------------------------------------------------------------------- */
 function apply(ctx) {
+  usageCtx = ctx
+  _usagePricesScope = null // 每次激活重绑，避免复用已释放的 scope
   ctx.effect(() => {
     if (typeof styles !== 'undefined' && styles && typeof styles.insert === 'function') {
       return styles.insert(CSS)
@@ -2249,15 +2408,35 @@ function apply(ctx) {
   }, 'usage: styles')
   ctx.effect(() => ctx.locale.register(NS, { zh: ZH, en: EN }), 'usage: dictionaries')
   const t0 = ctx.locale ? ctx.locale.bind(NS) : fallbackT
-  const slots = ctx.get('slots')
-  if (slots === undefined) return
+  // cordis ctx is a strict proxy: DIRECT property access on an un-injected
+  // service throws ("cannot get property X without inject"), so a bare
+  // `ctx.slots ?? ...` would throw and skip the fallback. Probe via the safe
+  // ctx.get() first; fall back to the injected property (available once
+  // 'slots' is declared in the inject list below).
+  let slots = null
+  try {
+    slots = typeof ctx.get === 'function' ? ctx.get('slots') : null
+  } catch (e) {
+    slots = null
+  }
+  if (!slots || typeof slots.inject !== 'function') {
+    try {
+      if (ctx.slots && typeof ctx.slots.inject === 'function') slots = ctx.slots
+    } catch (e) {
+      slots = null
+    }
+  }
+  if (!slots || typeof slots.inject !== 'function' || typeof slots.register !== 'function') {
+    console.warn('[usage] settings.section slot unavailable')
+    return
+  }
   slots.inject('settings.section', () => slots.register(
     { name: 'settings.section', id: 'token-stats', order: 20, label: () => t0('nav'), locale: NS },
     (props) => h(StatsDashboard, props),
   ))
 }
 
-return { inject: ['locale'], apply }
+return { inject: ['locale', 'slots'], apply }
 
     })();
     exports.apply = function apply(ctx) {
@@ -2268,3 +2447,4 @@ return { inject: ['locale'], apply }
     return module.exports;
   }
 });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sources":["/Users/ruanbw/projects/usage/src/client/index.js"],"sourcesContent":["// ============================================================================\n// Token 用量统计 — settings.section Client UI（纯 JS，动态插件沙箱）\n// 可用全局：React / ctx / styles / host / console；浏览器全局 Date / Intl 等。\n// CSS 常量内联自 styles.js（动态插件沙箱无 import，样式随本文件加载）。\n// ============================================================================\nconst CSS = `\n/* ============ 布局 ============ */\n.tsd-section {\n  width: 100%;\n  display: flex;\n  flex-direction: column;\n  gap: 16px;\n  color: var(--dsw-alias-label-primary);\n  animation: tsd-fade-in 0.4s var(--ds-ease-in-out);\n}\n@keyframes tsd-fade-in {\n  from { opacity: 0; transform: translateY(8px); }\n  to { opacity: 1; transform: none; }\n}\n\n/* ============ Header ============ */\n.tsd-header {\n  display: flex;\n  align-items: flex-end;\n  justify-content: space-between;\n  gap: 12px;\n  flex-wrap: wrap;\n}\n.tsd-title {\n  margin: 0;\n  font-size: 24px;\n  font-weight: 700;\n  letter-spacing: -0.02em;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-subtitle {\n  margin: 4px 0 0;\n  font-size: 14px;\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-icon-btn {\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  width: 34px;\n  height: 34px;\n  padding: 0;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-secondary);\n  border-radius: 8px;\n  cursor: pointer;\n  font: inherit;\n}\n.tsd-icon-btn:hover {\n  color: var(--dsw-alias-label-primary);\n  background: var(--dsw-alias-interactive-bg-hover);\n}\n.tsd-spinning svg {\n  animation: tsd-spin 0.9s linear infinite;\n}\n@keyframes tsd-spin {\n  to { transform: rotate(360deg); }\n}\n\n/* ============ 筛选栏 ============ */\n.tsd-filterbar {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  flex-wrap: wrap;\n}\n.tsd-seg-wrap {\n  position: relative;\n  display: inline-flex;\n}\n.tsd-seg {\n  display: inline-flex;\n  gap: 2px;\n  padding: 4px;\n  border-radius: 10px;\n  background: color-mix(in srgb, var(--dsw-alias-label-tertiary) 12%, transparent);\n}\n.tsd-seg-btn {\n  display: inline-flex;\n  align-items: center;\n  height: 28px;\n  padding: 0 12px;\n  border: none;\n  background: transparent;\n  color: var(--dsw-alias-label-secondary);\n  border-radius: 8px;\n  font: inherit;\n  font-size: 13px;\n  line-height: 1;\n  cursor: pointer;\n  white-space: nowrap;\n}\n.tsd-seg-btn:hover {\n  color: var(--dsw-alias-label-primary);\n  background: var(--dsw-alias-interactive-bg-hover);\n}\n.tsd-seg-active {\n  background: var(--dsw-alias-bg-base);\n  color: var(--dsw-alias-brand-primary);\n  font-weight: 600;\n  box-shadow: var(--dsw-shadow-lv1);\n}\n.tsd-seg-custom {\n  max-width: 220px;\n}\n.tsd-seg-custom .tsd-seg-label {\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n.tsd-seg-custom.tsd-seg-active {\n  background: var(--dsw-alias-brand-primary);\n  color: var(--dsw-alias-label-primary-inverted, #fff);\n}\n.tsd-seg-custom.tsd-seg-active:hover {\n  background: var(--dsw-alias-button-primary-hover);\n}\n\n/* ============ 通用按钮 ============ */\n.tsd-btn {\n  height: 30px;\n  padding: 0 14px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-primary);\n  border-radius: 8px;\n  font: inherit;\n  font-size: 13px;\n  cursor: pointer;\n  white-space: nowrap;\n}\n.tsd-btn:hover { background: var(--dsw-alias-interactive-bg-hover); }\n.tsd-btn:disabled { opacity: 0.5; cursor: not-allowed; }\n.tsd-btn-primary {\n  background: var(--dsw-alias-button-primary-fill);\n  border-color: transparent;\n  color: var(--dsw-alias-label-primary-inverted, #fff);\n}\n.tsd-btn-primary:hover { background: var(--dsw-alias-button-primary-hover); }\n.tsd-btn-ghost { background: transparent; }\n.tsd-btn-ghost:hover { background: var(--dsw-alias-interactive-bg-hover); }\n\n/* ============ 浮层 Popover ============ */\n.tsd-popover-anchor {\n  position: relative;\n  display: inline-flex;\n}\n.tsd-popover {\n  position: absolute;\n  top: calc(100% + 6px);\n  left: 0;\n  z-index: 40;\n  padding: 12px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-overlay);\n  border-radius: 12px;\n  box-shadow: var(--dsw-shadow-lv3);\n}\n.tsd-model-popover {\n  width: 320px;\n  max-width: calc(100vw - 24px);\n}\n.tsd-range-popover {\n  width: 300px;\n  max-width: calc(100vw - 24px);\n}\n.tsd-popover-title {\n  font-size: 14px;\n  font-weight: 600;\n  color: var(--dsw-alias-label-primary);\n  margin: 0 0 10px;\n}\n.tsd-popover-tools {\n  display: flex;\n  justify-content: space-between;\n  margin-bottom: 8px;\n}\n.tsd-link-btn {\n  border: none;\n  background: none;\n  color: var(--dsw-alias-state-business-primary);\n  font: inherit;\n  font-size: 12px;\n  cursor: pointer;\n  padding: 2px 4px;\n  border-radius: 4px;\n}\n.tsd-link-btn:hover { background: var(--dsw-alias-interactive-bg-hover); }\n.tsd-popover-actions {\n  display: flex;\n  justify-content: flex-end;\n  gap: 8px;\n  margin-top: 12px;\n}\n.tsd-popover-note {\n  margin: 8px 0 0;\n  font-size: 11px;\n  color: var(--dsw-alias-label-tertiary);\n}\n.tsd-popover-empty {\n  margin: 0;\n  padding: 10px 0;\n  text-align: center;\n  font-size: 12px;\n  color: var(--dsw-alias-label-tertiary);\n}\n\n/* ============ 模型下拉搜索 ============ */\n.tsd-select-btn {\n  display: inline-flex;\n  align-items: center;\n  gap: 6px;\n  min-width: 120px;\n  max-width: 260px;\n  height: 36px;\n  padding: 0 10px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-primary);\n  border-radius: 8px;\n  font: inherit;\n  font-size: 13px;\n  cursor: pointer;\n}\n.tsd-select-btn:hover { border-color: var(--dsw-alias-border-l3); }\n.tsd-select-has { border-color: color-mix(in srgb, var(--dsw-alias-brand-primary) 45%, var(--dsw-alias-border-l2)); }\n.tsd-select-label {\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  min-width: 0;\n}\n.tsd-chevron {\n  flex: none;\n  transition: transform var(--ds-transition-duration-fast) var(--ds-ease-in-out);\n}\n.tsd-chevron-open { transform: rotate(180deg); }\n.tsd-search {\n  position: relative;\n  margin-bottom: 8px;\n}\n.tsd-search-icon {\n  position: absolute;\n  left: 8px;\n  top: 50%;\n  transform: translateY(-50%);\n  color: var(--dsw-alias-label-tertiary);\n  pointer-events: none;\n}\n.tsd-search input {\n  box-sizing: border-box;\n  width: 100%;\n  height: 32px;\n  padding: 0 8px 0 28px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-primary);\n  border-radius: 8px;\n  font: inherit;\n  font-size: 13px;\n  outline: none;\n}\n.tsd-search input:focus {\n  border-color: var(--dsw-alias-state-business-primary);\n  box-shadow: 0 0 0 2px color-mix(in srgb, var(--dsw-alias-state-business-primary) 18%, transparent);\n}\n.tsd-model-list {\n  display: flex;\n  flex-direction: column;\n  gap: 2px;\n  max-height: 240px;\n  overflow-y: auto;\n  --dsh-scrollbar-thumb: var(--dsw-alias-scrollbar-bg-l2);\n  --dsh-scrollbar-thumb-hover: var(--dsw-alias-scrollbar-hover-l2);\n}\n.tsd-model-item {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  padding: 5px 6px;\n  border-radius: 6px;\n  cursor: pointer;\n  font-size: 13px;\n  color: var(--dsw-alias-label-primary);\n  min-width: 0;\n}\n.tsd-model-item:hover { background: var(--dsw-alias-interactive-bg-hover); }\n.tsd-model-item input { margin: 0; accent-color: var(--dsw-alias-brand-primary); }\n.tsd-model-name {\n  font-family: var(--ds-font-family-code);\n  font-size: 12px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  min-width: 0;\n}\n\n/* ============ 自定义日期浮层 ============ */\n.tsd-range-fields {\n  display: flex;\n  flex-direction: column;\n  gap: 10px;\n}\n.tsd-field {\n  display: flex;\n  flex-direction: column;\n  gap: 4px;\n}\n.tsd-field-label {\n  font-size: 12px;\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-field input {\n  box-sizing: border-box;\n  width: 100%;\n  height: 32px;\n  padding: 0 8px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-primary);\n  border-radius: 8px;\n  font: inherit;\n  font-size: 13px;\n  outline: none;\n}\n.tsd-field input:focus {\n  border-color: var(--dsw-alias-state-business-primary);\n  box-shadow: 0 0 0 2px color-mix(in srgb, var(--dsw-alias-state-business-primary) 18%, transparent);\n}\n.tsd-field-error {\n  margin: 6px 0 0;\n  font-size: 12px;\n  color: var(--dsw-alias-state-error-primary);\n}\n.tsd-field-hint {\n  margin: 6px 0 0;\n  font-size: 11px;\n  color: var(--dsw-alias-label-tertiary);\n}\n\n/* ============ 汇总指标卡 ============ */\n.tsd-cards {\n  display: grid;\n  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));\n  gap: 10px;\n}\n.tsd-card {\n  min-width: 0;\n  padding: 14px 16px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-layer-3);\n  border-radius: 12px;\n  box-shadow: var(--dsw-shadow-lv1);\n}\n.tsd-card-head {\n  display: flex;\n  align-items: center;\n  gap: 6px;\n}\n.tsd-card-icon {\n  display: inline-flex;\n}\n.tsd-card-label {\n  font-size: 12px;\n  color: var(--dsw-alias-label-secondary);\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n.tsd-card-value {\n  margin-top: 8px;\n  font-size: 20px;\n  font-weight: 700;\n  letter-spacing: -0.01em;\n  color: var(--dsw-alias-label-primary);\n  font-variant-numeric: tabular-nums;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n.tsd-card-sub {\n  margin-top: 4px;\n  font-size: 12px;\n  color: var(--dsw-alias-label-tertiary);\n}\n.tsd-card-note {\n  margin-top: 4px;\n  font-size: 11px;\n  color: var(--dsw-alias-state-warn-primary);\n}\n\n/* ============ 卡片头部（图表 / 表格共用） ============ */\n.tsd-card-header {\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  gap: 8px;\n  margin-bottom: 12px;\n}\n.tsd-card-title {\n  margin: 0;\n  font-size: 15px;\n  font-weight: 600;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-card-tag {\n  font-size: 12px;\n  color: var(--dsw-alias-label-tertiary);\n  font-variant-numeric: tabular-nums;\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n}\n\n/* ============ 每日用量柱状图 ============ */\n.tsd-chart-card { padding: 14px 16px 10px; }\n.tsd-legend {\n  display: flex;\n  gap: 14px;\n  margin-bottom: 8px;\n}\n.tsd-legend-item {\n  display: inline-flex;\n  align-items: center;\n  gap: 6px;\n  font-size: 12px;\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-legend-dot,\n.tsd-tooltip-dot {\n  display: inline-block;\n  width: 10px;\n  height: 10px;\n  border-radius: 2px;\n  flex: none;\n}\n.tsd-legend-in { background: var(--dsw-static-deepseek-500); }\n.tsd-legend-out { background: var(--dsw-static-green-500); }\n.tsd-legend-total { background: var(--dsw-alias-label-secondary); }\n\n.tsd-chart {\n  position: relative;\n  display: flex;\n  align-items: stretch;\n  gap: 2px;\n  height: 240px;\n  padding: 0 4px;\n}\n.tsd-chart-col {\n  flex: 1;\n  min-width: 0;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  border-radius: 4px;\n  cursor: default;\n  transition: opacity var(--ds-transition-duration-fast) var(--ds-ease-in-out);\n}\n.tsd-chart-col:focus-visible {\n  outline: 2px solid var(--dsw-alias-state-business-primary);\n  outline-offset: 2px;\n}\n.tsd-chart:hover .tsd-chart-col { opacity: 0.4; }\n.tsd-chart:hover .tsd-chart-col:hover,\n.tsd-chart:focus-within .tsd-chart-col:focus { opacity: 1; }\n\n.tsd-chart-plot {\n  flex: 1;\n  width: 100%;\n  display: flex;\n  align-items: flex-end;\n  justify-content: center;\n  border-bottom: 1px solid var(--dsw-alias-border-l2);\n  background-image: linear-gradient(to top, var(--dsw-alias-border-l1) 1px, transparent 1px);\n  background-size: 100% 25%;\n  background-repeat: no-repeat;\n}\n.tsd-chart-stack {\n  width: 62%;\n  height: 100%;\n  display: flex;\n  flex-direction: column;\n  justify-content: flex-end;\n}\n.tsd-chart-seg {\n  width: 100%;\n}\n.tsd-seg-in {\n  background: var(--dsw-static-deepseek-500);\n}\n.tsd-seg-out {\n  background: var(--dsw-static-green-500);\n  border-radius: 3px 3px 0 0;\n}\n.tsd-chart-label {\n  height: 14px;\n  line-height: 14px;\n  margin-top: 6px;\n  font-size: 11px;\n  color: var(--dsw-alias-label-tertiary);\n  font-variant-numeric: tabular-nums;\n  white-space: nowrap;\n}\n.tsd-chart-label-hidden { visibility: hidden; }\n\n/* tooltip */\n.tsd-tooltip {\n  position: absolute;\n  top: 10px;\n  transform: translateX(-50%);\n  z-index: 6;\n  min-width: 156px;\n  padding: 8px 10px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  background: var(--dsw-alias-bg-overlay);\n  backdrop-filter: blur(8px);\n  border-radius: 8px;\n  box-shadow: var(--dsw-shadow-lv3);\n  pointer-events: none;\n}\n.tsd-tooltip-date {\n  margin-bottom: 6px;\n  font-size: 12px;\n  font-weight: 600;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-tooltip-row {\n  display: flex;\n  align-items: center;\n  gap: 6px;\n  margin: 2px 0;\n  font-size: 12px;\n  color: var(--dsw-alias-label-secondary);\n  font-variant-numeric: tabular-nums;\n}\n.tsd-tooltip-val {\n  margin-left: auto;\n  padding-left: 12px;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-tooltip-total {\n  display: flex;\n  justify-content: space-between;\n  margin-top: 6px;\n  padding-top: 6px;\n  border-top: 1px solid var(--dsw-alias-border-l2);\n  font-size: 12px;\n  font-weight: 600;\n  color: var(--dsw-alias-label-primary);\n  font-variant-numeric: tabular-nums;\n}\n\n/* ============ 按模型明细表 ============ */\n.tsd-table-card { padding: 0; }\n.tsd-table-card .tsd-card-header { padding: 14px 16px 0; }\n.tsd-table-wrap {\n  overflow-x: auto;\n  --dsh-scrollbar-thumb: var(--dsw-alias-scrollbar-bg-l2);\n  --dsh-scrollbar-thumb-hover: var(--dsw-alias-scrollbar-hover-l2);\n}\n.tsd-table {\n  width: 100%;\n  border-collapse: collapse;\n  font-size: 13px;\n}\n.tsd-th {\n  padding: 10px 12px;\n  text-align: left;\n  font-size: 12px;\n  font-weight: 500;\n  color: var(--dsw-alias-label-secondary);\n  border-bottom: 1px solid var(--dsw-alias-border-l2);\n  white-space: nowrap;\n}\n.tsd-th-num { text-align: right; }\n.tsd-sort-btn {\n  display: inline-flex;\n  align-items: center;\n  gap: 2px;\n  padding: 0;\n  border: none;\n  background: none;\n  font: inherit;\n  font-size: 12px;\n  color: inherit;\n  cursor: pointer;\n}\n.tsd-sort-btn:hover { color: var(--dsw-alias-label-primary); }\n.tsd-sort-active { color: var(--dsw-alias-brand-primary); }\n.tsd-sort-arrow {\n  font-size: 10px;\n  line-height: 1;\n}\n.tsd-tr:hover { background: var(--dsw-alias-interactive-bg-hover); }\n.tsd-td {\n  padding: 9px 12px;\n  border-bottom: 1px solid var(--dsw-alias-border-l1);\n  color: var(--dsw-alias-label-secondary);\n  white-space: nowrap;\n}\n.tsd-td-model { max-width: 240px; }\n.tsd-model-mono {\n  display: block;\n  max-width: 220px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  font-family: var(--ds-font-family-code);\n  font-size: 12px;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-num {\n  text-align: right;\n  font-variant-numeric: tabular-nums;\n}\n.tsd-total {\n  font-weight: 600;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-unpriced {\n  color: var(--dsw-alias-label-tertiary);\n  font-style: italic;\n}\n.tsd-td-ratio { text-align: right; }\n.tsd-ratio {\n  display: inline-flex;\n  align-items: center;\n  justify-content: flex-end;\n  gap: 8px;\n}\n.tsd-ratio-bar {\n  width: 60px;\n  height: 6px;\n  border-radius: 3px;\n  background: var(--dsw-alias-bg-layer-1);\n  overflow: hidden;\n  flex: none;\n}\n.tsd-ratio-fill {\n  height: 100%;\n  border-radius: 3px;\n  background: linear-gradient(90deg, var(--dsw-static-deepseek-500), color-mix(in srgb, var(--dsw-static-deepseek-500) 55%, var(--dsw-static-deepseek-300)));\n}\n.tsd-ratio-pct {\n  min-width: 42px;\n  text-align: right;\n  font-size: 12px;\n  color: var(--dsw-alias-label-secondary);\n  font-variant-numeric: tabular-nums;\n}\n\n/* ============ 三态：空 / 错误 / 加载 ============ */\n.tsd-empty {\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  gap: 6px;\n  padding: 40px 16px;\n  text-align: center;\n}\n.tsd-empty-icon {\n  color: var(--dsw-alias-label-tertiary);\n  margin-bottom: 4px;\n}\n.tsd-empty-title {\n  margin: 0;\n  font-size: 15px;\n  font-weight: 600;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-empty-desc {\n  margin: 0;\n  font-size: 13px;\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-empty-block {\n  padding: 24px;\n  text-align: center;\n  font-size: 13px;\n  color: var(--dsw-alias-label-tertiary);\n}\n\n.tsd-error {\n  display: flex;\n  align-items: center;\n  gap: 12px;\n  padding: 20px 16px;\n  border-color: color-mix(in srgb, var(--dsw-alias-state-error-primary) 40%, transparent);\n  background: color-mix(in srgb, var(--dsw-alias-state-error-secondary) 30%, var(--dsw-alias-bg-layer-3));\n}\n.tsd-error-icon {\n  flex: none;\n  color: var(--dsw-alias-state-error-primary);\n}\n.tsd-error-text {\n  flex: 1;\n  min-width: 0;\n}\n.tsd-error-title {\n  margin: 0;\n  font-size: 14px;\n  font-weight: 600;\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-error-detail {\n  margin: 2px 0 0;\n  font-size: 12px;\n  color: var(--dsw-alias-label-secondary);\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n.tsd-alert-banner {\n  display: flex;\n  align-items: center;\n  gap: 10px;\n  padding: 10px 14px;\n  border: 1px solid color-mix(in srgb, var(--dsw-alias-state-error-primary) 40%, transparent);\n  border-radius: 10px;\n  background: color-mix(in srgb, var(--dsw-alias-state-error-secondary) 30%, var(--dsw-alias-bg-layer-3));\n  color: var(--dsw-alias-state-error-primary);\n  font-size: 13px;\n}\n\n.tsd-loading {\n  display: flex;\n  flex-direction: column;\n  gap: 16px;\n}\n.tsd-card-skeleton { min-height: 84px; }\n.tsd-skeleton {\n  background: var(--dsw-alias-bg-skeleton);\n  border-radius: 6px;\n  animation: tsd-pulse 1.6s var(--ds-ease-in-out) infinite;\n}\n.tsd-skeleton-row {\n  height: 14px;\n  margin: 12px 0;\n  background: var(--dsw-alias-bg-skeleton);\n  border-radius: 4px;\n  animation: tsd-pulse 1.6s var(--ds-ease-in-out) infinite;\n}\n@keyframes tsd-pulse {\n  0%, 100% { opacity: 1; }\n  50% { opacity: 0.45; }\n}\n\n/* ============ 刷新时的内容态 ============ */\n.tsd-content {\n  display: flex;\n  flex-direction: column;\n  gap: 16px;\n  transition: opacity var(--ds-transition-duration) var(--ds-ease-in-out);\n}\n.tsd-content[data-busy=true] { opacity: 0.55; }\n\n/* ============ 无障碍 ============ */\n.tsd-visually-hidden {\n  position: absolute;\n  width: 1px;\n  height: 1px;\n  padding: 0;\n  margin: -1px;\n  overflow: hidden;\n  clip: rect(0 0 0 0);\n  white-space: nowrap;\n  border: 0;\n}\n.tsd-icon {\n  flex: none;\n}\n.tsd-seg-btn:focus-visible,\n.tsd-select-btn:focus-visible,\n.tsd-btn:focus-visible,\n.tsd-icon-btn:focus-visible,\n.tsd-link-btn:focus-visible,\n.tsd-sort-btn:focus-visible {\n  outline: 2px solid var(--dsw-alias-state-business-primary);\n  outline-offset: 2px;\n}\n/* ============ 粒度切换 ============ */\n.tsd-card-actions {\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n}\n.tsd-gran {\n  display: inline-flex;\n  gap: 2px;\n  padding: 2px;\n  border-radius: 8px;\n  background: var(--dsw-alias-bg-layer-1);\n}\n.tsd-gran-btn {\n  border: none;\n  background: transparent;\n  color: var(--dsw-alias-label-tertiary);\n  font: inherit;\n  font-size: 11px;\n  line-height: 16px;\n  border-radius: 6px;\n  padding: 2px 8px;\n  cursor: pointer;\n}\n.tsd-gran-btn[data-active=\"true\"] {\n  background: var(--dsw-alias-bg-layer-3);\n  color: var(--dsw-alias-label-primary);\n  box-shadow: var(--dsw-shadow-lv1);\n}\n.tsd-gran-btn:disabled {\n  opacity: 0.4;\n  cursor: not-allowed;\n}\n/* ============ 折线图 ============ */\n.tsd-linechart {\n  position: relative;\n  padding: 6px 10px 8px;\n}\n.tsd-linechart svg {\n  display: block;\n  width: 100%;\n  height: auto;\n}\n.tsd-linechart .tsd-line-grid {\n  stroke: var(--dsw-alias-border-l2);\n  stroke-width: 1;\n  stroke-dasharray: 3 3;\n}\n.tsd-linechart .tsd-line-axis {\n  stroke: var(--dsw-alias-border-l2);\n  stroke-width: 1;\n}\n.tsd-linechart .tsd-line-in {\n  stroke: var(--dsw-static-deepseek-500);\n  stroke-width: 2;\n  fill: none;\n}\n.tsd-linechart .tsd-line-out {\n  stroke: var(--dsw-static-green-500);\n  stroke-width: 2;\n  fill: none;\n}\n.tsd-linechart .tsd-line-total {\n  stroke: var(--dsw-alias-label-secondary);\n  stroke-width: 1.5;\n  stroke-dasharray: 4 3;\n  fill: none;\n}\n.tsd-linechart .tsd-line-dot {\n  fill: var(--dsw-alias-bg-layer-2);\n  stroke: var(--dsw-alias-label-secondary);\n  stroke-width: 1;\n}\n.tsd-linechart .tsd-line-hover {\n  fill: transparent;\n  cursor: crosshair;\n}\n.tsd-linechart .tsd-line-cursor {\n  stroke: var(--dsw-alias-border-l3);\n  stroke-width: 1;\n  stroke-dasharray: 3 3;\n  pointer-events: none;\n}\n.tsd-linechart .tsd-line-hl {\n  stroke: var(--dsw-alias-bg-base);\n  stroke-width: 1.5;\n  pointer-events: none;\n}\n.tsd-linechart .tsd-line-hl-in { fill: var(--dsw-static-deepseek-500); }\n.tsd-linechart .tsd-line-hl-out { fill: var(--dsw-static-green-500); }\n.tsd-linechart .tsd-line-hl-total { fill: var(--dsw-alias-label-secondary); }\n.tsd-linechart .tsd-line-text {\n  fill: var(--dsw-alias-label-tertiary);\n  font-size: 10px;\n}\n/* ============ 年度热力图 ============ */\n.tsd-heatmap {\n  padding: 6px 14px 14px;\n  overflow-x: auto;\n}\n.tsd-heatmap-inner {\n  display: inline-flex;\n  flex-direction: column;\n  gap: 4px;\n  min-width: min-content;\n}\n.tsd-heatmap-months {\n  display: flex;\n  margin-left: 26px;\n  height: 14px;\n  position: relative;\n}\n.tsd-heatmap-month {\n  font-size: 9px;\n  line-height: 14px;\n  color: var(--dsw-alias-label-tertiary);\n  white-space: nowrap;\n  position: absolute;\n  top: 0;\n}\n.tsd-heatmap-body {\n  display: flex;\n  gap: 4px;\n}\n.tsd-heatmap-days {\n  display: flex;\n  flex-direction: column;\n  gap: 2px;\n  width: 22px;\n  flex: none;\n}\n.tsd-heatmap-day {\n  height: 10px;\n  font-size: 9px;\n  line-height: 10px;\n  color: var(--dsw-alias-label-tertiary);\n  text-align: right;\n  padding-right: 4px;\n}\n.tsd-heatmap-grid {\n  display: flex;\n  gap: 2px;\n}\n.tsd-heatmap-col {\n  display: flex;\n  flex-direction: column;\n  gap: 2px;\n}\n.tsd-heatmap-cell {\n  width: 10px;\n  height: 10px;\n  border-radius: 2px;\n  background: var(--dsw-alias-interactive-bg-hover);\n  transition: transform var(--ds-transition-duration-fast) var(--ds-ease-in-out), box-shadow var(--ds-transition-duration-fast) var(--ds-ease-in-out);\n}\n.tsd-heatmap-cell:hover {\n  outline: 1px solid var(--dsw-alias-label-secondary);\n  transform: scale(1.35);\n  box-shadow: var(--dsw-shadow-lv2);\n  position: relative;\n  z-index: 2;\n}\n.tsd-heatmap-legend {\n  display: flex;\n  align-items: center;\n  gap: 4px;\n  margin: 8px 14px 0;\n  padding-top: 8px;\n  border-top: 1px solid var(--dsw-alias-border-l2);\n  font-size: 10px;\n  color: var(--dsw-alias-label-tertiary);\n}\n`\n\n// RPC bridge: dynamic-plugin runs provide a `host` global; static (bundle)\n// installs provide ctx.get('connection').rpc. Keep one UI source for both.\nfunction hostCall(method, args) {\n  // P0-3: prefer the official `remote` service when it exposes the usage API;\n  // otherwise fall through to the host/connection fallbacks unchanged.\n  const remoteScope = (typeof ctx !== 'undefined' && ctx && typeof ctx.get === 'function')\n    ? ctx\n    : (typeof _usageCtx !== 'undefined' && _usageCtx && typeof _usageCtx.get === 'function' ? _usageCtx : null)\n  if (remoteScope && typeof remoteScope.get === 'function') {\n    try {\n      const remote = remoteScope.get('remote')\n      if (remote && remote.usage) {\n        const rName = String(method)\n        const rSlash = rName.indexOf('/')\n        const rEp = rSlash === -1 ? rName : rName.slice(rSlash + 1)\n        const rCamel = rEp.replace(/-([a-z])/g, (m, c) => c.toUpperCase())\n        const fn = (typeof remote.usage[rCamel] === 'function' && remote.usage[rCamel])\n          || (typeof remote.usage[rEp] === 'function' && remote.usage[rEp])\n        if (fn) {\n          return Promise.resolve().then(() => fn(args)).then((res) => {\n            if (res && res.ok) return res.value\n            throw new Error((res && res.error && res.error.message) || ('RPC ' + method + ' failed'))\n          })\n        }\n      }\n    } catch (e) {\n      // remote probing failed — fall through to the existing fallbacks\n    }\n  }\n  if (typeof host !== 'undefined' && host && typeof host.call === 'function') {\n    return Promise.resolve(host.call(method, args))\n  }\n  // Static bundle installs have no ctx/host globals: the entry apply() stores\n  // the real context in _usageCtx (declared by the build wrapper).\n  const scope = (typeof ctx !== 'undefined' && ctx && typeof ctx.get === 'function')\n    ? ctx\n    : (typeof _usageCtx !== 'undefined' ? _usageCtx : null)\n  if (scope === null || typeof scope.get !== 'function') {\n    return Promise.reject(new Error('context unavailable'))\n  }\n  const connection = scope.get('connection')\n  if (connection === undefined || connection.rpc === undefined) {\n    return Promise.reject(new Error('connection service unavailable'))\n  }\n  const name = String(method)\n  const slash = name.indexOf('/')\n  const channel = slash === -1 ? name : name.slice(0, slash)\n  const endpoint = slash === -1 ? name : name.slice(slash + 1)\n  return connection.rpc.call('/' + channel.replace(/^\\/+/, ''), endpoint, args).then((res) => {\n    if (res && res.ok) return res.value\n    throw new Error((res && res.error && res.error.message) || ('RPC ' + method + ' failed'))\n  })\n}\n\n/* ---------------------------------------------------------------------------\n * 设置域定价：官方 ctx.settingsScope（dsh-client-ui-settings）优先，\n * 不可用时回退 usage/prices RPC。绑定只做一次，读写共用同一 scope。\n * ------------------------------------------------------------------------- */\nlet usageCtx = null\nlet _usagePricesScope = null\n\nfunction resolveUsageCtx() {\n  if (usageCtx && typeof usageCtx.get === 'function') return usageCtx\n  if (typeof _usageCtx !== 'undefined' && _usageCtx && typeof _usageCtx.get === 'function') return _usageCtx\n  return null\n}\n\nfunction getUsagePricesScope() {\n  if (_usagePricesScope) return _usagePricesScope\n  const c = resolveUsageCtx()\n  if (!c || typeof c.get !== 'function') return null\n  try {\n    const binder = c.get('settingsScope')\n    if (!binder || typeof binder.bind !== 'function') return null\n    _usagePricesScope = binder.bind({ namespace: 'usage.prices' })\n    return _usagePricesScope\n  } catch (e) {\n    return null\n  }\n}\n\n// 价格写入口：settings scope 可用时写 usage.prices 命名空间字段，\n// 否则回退 usage/prices RPC（当前 UI 无价格编辑器，保留此写入 seam 供后续使用）。\nfunction usageSavePrices(next) {\n  const args = {}\n  if (next && typeof next === 'object') {\n    if (next.prices !== undefined) args.prices = next.prices\n    if (next.currency !== undefined) args.currency = next.currency\n  }\n  try {\n    const scope = getUsagePricesScope()\n    if (scope && typeof scope.set === 'function') {\n      const jobs = []\n      if (args.prices !== undefined) jobs.push(scope.set('prices', args.prices))\n      if (args.currency !== undefined) jobs.push(scope.set('currency', args.currency))\n      if (jobs.length > 0) {\n        return Promise.all(jobs).then(() => {\n          const snap = typeof scope.getSnapshot === 'function' ? scope.getSnapshot() : null\n          return snap && snap.value ? snap.value : null\n        })\n      }\n    }\n  } catch (e) {\n    // fall through to the RPC write path\n  }\n  return hostCall('usage/prices', args)\n}\n\n;\nconst h = React.createElement\n\n/* ---------------------------------------------------------------------------\n * 国际化：zh/en 字典 + Context（locale 服务经 slot 注册注入 t，子组件经 Context 取用）\n * ------------------------------------------------------------------------- */\nconst NS = 'usage'\nconst ZH = {\n  nav: '用量统计',\n  subtitle: '查看 AI 模型的使用情况和成本统计',\n  refresh: '刷新',\n  today: '今日',\n  last7d: '近7天',\n  last30d: '近30天',\n  custom: '自定义',\n  allModels: '全部模型',\n  selectedModels: '已选 {count} 个模型',\n  selectAll: '全选',\n  clear: '清空',\n  searchModels: '搜索模型',\n  noMatchModels: '无匹配模型',\n  modelFilterHint: '勾选即时生效，仅列出当前范围内有数据的模型',\n  customRangeTitle: '自定义时间范围',\n  customRangeAria: '自定义日期范围',\n  startTime: '开始时间',\n  endTime: '结束时间',\n  rangeInvalid: '开始时间不能晚于结束时间',\n  rangeHint: '支持选择日期，最长 30 天',\n  cancel: '取消',\n  confirm: '确定',\n  dateRangeGroup: '日期范围',\n  modelFilterGroup: '模型筛选',\n  chartTypeGroup: '图表类型',\n  totalTokens: '总 Token',\n  inputTokens: '输入 Token',\n  outputTokens: '输出 Token',\n  calls: '调用次数',\n  cost: '成本',\n  approxIO: '≈ 输入+输出',\n  unpricedNote: '{count} 次调用未定价',\n  dailyTrend: '每日用量趋势',\n  barView: '柱状图',\n  lineView: '折线图',\n  byHour: '按小时',\n  byDay: '按天',\n  everyNDays: '每 {n} 天',\n  legendInput: '输入',\n  legendOutput: '输出',\n  legendTotal: '总 Token',\n  tooltipTotal: '合计',\n  startNDays: '起 {n} 天',\n  lineChartAria: 'Token 用量趋势折线图',\n  yearlyHeatmap: '年度用量热力图',\n  yearDaily: '{year} 年每日 Token 用量',\n  monthLabel: '{n}月',\n  weekdayMon: '一',\n  weekdayWed: '三',\n  weekdayFri: '五',\n  less: '少',\n  more: '多',\n  byModelTitle: '按模型明细',\n  modelCount: '共 {n} 个模型',\n  modelTableCaption: '按模型用量明细',\n  colModel: '模型',\n  colCalls: '请求数',\n  colInput: '输入 Token',\n  colOutput: '输出 Token',\n  colTotal: '总 Token',\n  colCost: '成本',\n  colShare: '占比',\n  unpriced: '未定价',\n  unpricedRowHint: '该模型未配置定价，按 0 计价',\n  noData: '暂无数据',\n  emptyDesc: '该时间段内没有调用记录',\n  emptyFiltered: '当前筛选条件下没有数据，试试调整时间范围或模型',\n  resetFilters: '重置筛选',\n  loadFailed: '数据加载失败：{message}',\n  loadFailedTitle: '数据加载失败',\n  retry: '重试',\n  barAria: '{key}，输入 {in} Token，输出 {out} Token，合计 {tot} Token',\n  hmTitle: '{key}：{tokens} Token{calls}',\n  hmCalls: '，{count} 次调用',\n  wd0: '周日',\n  wd1: '周一',\n  wd2: '周二',\n  wd3: '周三',\n  wd4: '周四',\n  wd5: '周五',\n  wd6: '周六',\n}\nconst EN = {\n  nav: 'Usage Stats',\n  subtitle: 'View AI model usage and cost statistics',\n  refresh: 'Refresh',\n  today: 'Today',\n  last7d: 'Last 7 days',\n  last30d: 'Last 30 days',\n  custom: 'Custom',\n  allModels: 'All models',\n  selectedModels: '{count} models selected',\n  selectAll: 'Select all',\n  clear: 'Clear',\n  searchModels: 'Search models',\n  noMatchModels: 'No matching models',\n  modelFilterHint: 'Applies instantly; lists only models with data in the range',\n  customRangeTitle: 'Custom time range',\n  customRangeAria: 'Custom date range',\n  startTime: 'Start',\n  endTime: 'End',\n  rangeInvalid: 'Start must not be later than end',\n  rangeHint: 'Date only, up to 30 days',\n  cancel: 'Cancel',\n  confirm: 'OK',\n  dateRangeGroup: 'Date range',\n  modelFilterGroup: 'Model filter',\n  chartTypeGroup: 'Chart type',\n  totalTokens: 'Total Tokens',\n  inputTokens: 'Input Tokens',\n  outputTokens: 'Output Tokens',\n  calls: 'Calls',\n  cost: 'Cost',\n  approxIO: '≈ input+output',\n  unpricedNote: '{count} calls unpriced',\n  dailyTrend: 'Daily usage trend',\n  barView: 'Bars',\n  lineView: 'Line',\n  byHour: 'Hourly',\n  byDay: 'Daily',\n  everyNDays: 'Every {n} days',\n  legendInput: 'Input',\n  legendOutput: 'Output',\n  legendTotal: 'Total',\n  tooltipTotal: 'Total',\n  startNDays: 'for {n} days',\n  lineChartAria: 'Token usage trend line chart',\n  yearlyHeatmap: 'Yearly heatmap',\n  yearDaily: 'Daily tokens in {year}',\n  monthLabel: '{n}',\n  weekdayMon: 'Mon',\n  weekdayWed: 'Wed',\n  weekdayFri: 'Fri',\n  less: 'Less',\n  more: 'More',\n  byModelTitle: 'By model',\n  modelCount: '{n} models',\n  modelTableCaption: 'Token usage by model',\n  colModel: 'Model',\n  colCalls: 'Calls',\n  colInput: 'Input Tokens',\n  colOutput: 'Output Tokens',\n  colTotal: 'Total Tokens',\n  colCost: 'Cost',\n  colShare: 'Share',\n  unpriced: 'Unpriced',\n  unpricedRowHint: 'No pricing configured; counted as 0',\n  noData: 'No data',\n  emptyDesc: 'No calls in this period',\n  emptyFiltered: 'No data for the current filters, try adjusting the range or models',\n  resetFilters: 'Reset filters',\n  loadFailed: 'Failed to load data: {message}',\n  loadFailedTitle: 'Failed to load data',\n  retry: 'Retry',\n  barAria: '{key}, input {in} tokens, output {out} tokens, total {tot} tokens',\n  hmTitle: '{key}: {tokens} tokens{calls}',\n  hmCalls: ', {count} calls',\n  wd0: 'Sun',\n  wd1: 'Mon',\n  wd2: 'Tue',\n  wd3: 'Wed',\n  wd4: 'Thu',\n  wd5: 'Fri',\n  wd6: 'Sat',\n}\nconst T = React.createContext(null)\nfunction useT() {\n  return React.useContext(T)\n}\nfunction fallbackT(key, params) {\n  let s = ZH[key]\n  if (s === undefined) return key\n  if (params) {\n    s = s.replace(/\\{(\\w+)\\}/g, (m, n) => (params[n] !== undefined ? String(params[n]) : m))\n  }\n  return s\n}\n\n/* ---------------------------------------------------------------------------\n * 数字格式化（规格第 5 节）\n * ------------------------------------------------------------------------- */\nfunction formatTokensShort(n) {\n  if (!Number.isFinite(n)) return '--'\n  if (n >= 1e6) return Math.round(n / 1e4) / 100 + 'M' // 1.23M\n  if (n >= 1e3) return Math.round(n / 1e2) / 10 + 'K' // 12.3K\n  return String(Math.round(n))\n}\nfunction formatInt(n) {\n  return Number.isFinite(n) ? Math.round(n).toLocaleString() : '--'\n}\nfunction formatCost(n, cur) {\n  if (!Number.isFinite(n)) return '--'\n  return (cur || '¥') + n.toFixed(2)\n}\nfunction dayLabel(key) {\n  const [, m, d] = String(key || '').split('-')\n  if (m === undefined || d === undefined) return '--'\n  return m + '-' + d\n}\nfunction fmtPct(ratio) {\n  if (!Number.isFinite(ratio)) return '0%'\n  const p = ratio * 100\n  if (p >= 99.95) return '100%'\n  return p.toFixed(1) + '%'\n}\n\n/* ---------------------------------------------------------------------------\n * 日期工具\n * ------------------------------------------------------------------------- */\nfunction startOfDay(d) {\n  const x = new Date(d)\n  x.setHours(0, 0, 0, 0)\n  return x\n}\nfunction addDays(d, n) {\n  const x = new Date(d)\n  x.setDate(x.getDate() + n)\n  return x\n}\nfunction fmtDateInput(d) {\n  const y = d.getFullYear()\n  const m = String(d.getMonth() + 1).padStart(2, '0')\n  const day = String(d.getDate()).padStart(2, '0')\n  return y + '-' + m + '-' + day\n}\nfunction fmtDateSlash(s) {\n  const m = String(s || '').match(/^(\\d{4})-(\\d{2})-(\\d{2})$/)\n  if (!m) return '--'\n  return m[1] + '/' + m[2] + '/' + m[3]\n}\n// 预设 / 自定义 → { from, to }（Unix 毫秒）\n// 今日 = 当天 00:00 至今；近7/30天 = 含今天往前 N 个自然日 00:00 起；自定义 = 起日 00:00 ~ 止日 23:59:59.999\nfunction rangeFor(preset, custom) {\n  const now = new Date()\n  const today = startOfDay(now)\n  if (preset === 'today') return { from: today.getTime(), to: now.getTime() }\n  if (preset === '7d') return { from: addDays(today, -6).getTime(), to: now.getTime() }\n  if (preset === '30d') return { from: addDays(today, -29).getTime(), to: now.getTime() }\n  const from = new Date(custom.from + 'T00:00:00').getTime()\n  const to = new Date(custom.to + 'T23:59:59.999').getTime()\n  if (!Number.isFinite(from) || !Number.isFinite(to)) {\n    return { from: today.getTime(), to: now.getTime() }\n  }\n  return { from, to }\n}\nfunction weekdayOf(key) {\n  try {\n    return new Date(key + 'T00:00:00').toLocaleDateString('zh-CN', { weekday: 'short' })\n  } catch (e) {\n    return ''\n  }\n}\n/** Weekday for a day/hour/minute bucket key (`YYYY-MM-DD` or `YYYY-MM-DD HH:mm`). */\nfunction weekdayName(key, t) {\n  try {\n    const d = new Date(String(key).replace(' ', 'T'))\n    return t(['wd0', 'wd1', 'wd2', 'wd3', 'wd4', 'wd5', 'wd6'][d.getDay()] || 'wd0')\n  } catch (e) {\n    return ''\n  }\n}\n/** X-axis label for a bucket key under a granularity. */\nfunction xLabel(key, g) {\n  const s = String(key)\n  const sp = s.split(' ')\n  if (g === 'minute') return sp.length > 1 ? sp[1].slice(0, 5) : s.slice(5)\n  if (g === 'hour') return sp.length > 1 ? sp[1].slice(0, 2) + ':00' : s.slice(5)\n  return dayLabel(key)\n}\n/** Fixed granularity policy: today is hourly, everything else is daily. */\nfunction effGranularity(range) {\n  return range === 'today' ? 'hour' : 'day';\n}\n/** Stable step strategy for custom ranges: target ~15-25 buckets. */\nfunction pickStepDays(spanMs) {\n  const days = Math.max(1, Math.round((spanMs || 0) / 86400000))\n  if (days <= 31) return 1\n  if (days <= 62) return 3\n  if (days <= 150) return 5\n  return 7\n}\n/** Human label for the current step policy. */\nfunction stepLabel(t, range, stepDays) {\n  if (range === 'today') return t('byHour')\n  return stepDays > 1 ? t('everyNDays', { n: stepDays }) : t('byDay')\n}\n/** Heatmap cell color by relative token volume. */\nfunction heatColor(total, max) {\n  if (!total) return 'var(--dsw-alias-interactive-bg-hover)'\n  const r = total / max\n  const pct = r < 0.25 ? 22 : r < 0.5 ? 45 : r < 0.75 ? 70 : 100\n  return 'color-mix(in srgb, var(--dsw-static-deepseek-500) ' + pct + '%, var(--dsw-alias-bg-layer-2))'\n}\nfunction niceCeil(v) {\n  if (!Number.isFinite(v) || v <= 0) return 1\n  const mag = Math.pow(10, Math.floor(Math.log10(v)))\n  const norm = v / mag\n  const nice = norm <= 1 ? 1 : norm <= 2 ? 2 : norm <= 5 ? 5 : 10\n  return nice * mag\n}\nfunction defaultCustom() {\n  const now = new Date()\n  return { from: fmtDateInput(addDays(now, -6)), to: fmtDateInput(now) }\n}\n\n/* ---------------------------------------------------------------------------\n * 内联 SVG 图标（无图标库，手写 feather 风格 stroke 图标）\n * ------------------------------------------------------------------------- */\nconst ICON_PATHS = {\n  layers: 'M12 2l8 4.5-8 4.5-8-4.5L12 2zm0 8l8 4.5-8 4.5-8-4.5L12 10zm0 8l8 4.5-8 4.5-8-4.5L12 18z',\n  down: 'M12 3v12m0 0l-4.5-4.5M12 15l4.5-4.5M4 21h16',\n  up: 'M12 21V9m0 0l-4.5 4.5M12 9l4.5 4.5M4 3h16',\n  activity: 'M2 12h4l2.5-8 5 16 2.5-8h6',\n  coins: 'M3 9a2 2 0 012-2h14a2 2 0 012 2v9a2 2 0 01-2 2H5a2 2 0 01-2-2V9zm0 5h18M8 5.5V4a2 2 0 012-2h4a2 2 0 012 2v1.5',\n  refresh: 'M21 12a9 9 0 11-2.64-6.36M21 4v6h-6',\n  chevron: 'M6 9l6 6 6-6',\n  inbox: 'M22 12h-6l-2 3h-4l-2-3H2m3.5-6.5L2 12v6a2 2 0 002 2h16a2 2 0 002-2v-6l-3.5-6.5A2 2 0 0016.76 5H7.24a2 2 0 00-1.74 1.5z',\n  alert: 'M12 9v4m0 4h.01M10.3 3.86L1.82 18a2 2 0 001.71 3h16.94a2 2 0 001.71-3L13.7 3.86a2 2 0 00-3.4 0z',\n  search: 'M21 21l-4.35-4.35M17 10.5a6.5 6.5 0 11-13 0 6.5 6.5 0 0113 0z',\n}\nfunction SvgIcon(props) {\n  const { name, size, className } = props\n  return h('svg', {\n    className: className || 'tsd-icon',\n    width: size || 16,\n    height: size || 16,\n    viewBox: '0 0 24 24',\n    fill: 'none',\n    stroke: 'currentColor',\n    strokeWidth: 2,\n    strokeLinecap: 'round',\n    strokeLinejoin: 'round',\n    'aria-hidden': true,\n  }, h('path', { d: ICON_PATHS[name] || ICON_PATHS.activity }))\n}\n\n/* ---------------------------------------------------------------------------\n * 通用 Hook：外部点击关闭\n * ------------------------------------------------------------------------- */\nfunction useOutsideClick(open, ref, onClose) {\n  React.useEffect(() => {\n    if (!open) return undefined\n    function handler(e) {\n      if (ref.current && !ref.current.contains(e.target)) onClose()\n    }\n    document.addEventListener('click', handler)\n    return () => document.removeEventListener('click', handler)\n  }, [open, onClose, ref])\n}\n\n/* ---------------------------------------------------------------------------\n * Header：标题 + 副标题 + 刷新按钮\n * ------------------------------------------------------------------------- */\nfunction StatsHeader(props) {\n  const { busy, onRefresh } = props\n  const t = useT()\n  return h('div', { className: 'tsd-header' },\n    h('div', { className: 'tsd-header-text' },\n      h('h2', { className: 'tsd-title' }, t('nav')),\n      h('p', { className: 'tsd-subtitle' }, t('subtitle'))),\n    h('button', {\n      type: 'button',\n      className: 'tsd-icon-btn' + (busy ? ' tsd-spinning' : ''),\n      onClick: onRefresh,\n      title: t('refresh'),\n      'aria-label': t('refresh'),\n    }, h(SvgIcon, { name: 'refresh' })))\n}\n\n/* ---------------------------------------------------------------------------\n * 自定义日期范围浮层\n * ------------------------------------------------------------------------- */\nfunction CustomRangePopover(props) {\n  const { custom, onApply, onClose } = props\n  const t = useT()\n  const [from, setFrom] = React.useState(custom.from)\n  const [to, setTo] = React.useState(custom.to)\n  const invalid = !from || !to || from > to\n  // P2-11：dialog 以 Escape 关闭\n  React.useEffect(() => {\n    function onKey(e) {\n      if (e.key === 'Escape' || e.key === 'Esc') onClose()\n    }\n    document.addEventListener('keydown', onKey)\n    return () => document.removeEventListener('keydown', onKey)\n  }, [onClose])\n  return h('div', {\n    className: 'tsd-popover tsd-range-popover',\n    role: 'dialog',\n    'aria-label': t('customRangeAria'),\n  },\n    h('div', { className: 'tsd-popover-title' }, t('customRangeTitle')),\n    h('div', { className: 'tsd-range-fields' },\n      h('label', { className: 'tsd-field' },\n        h('span', { className: 'tsd-field-label' }, t('startTime')),\n        h('input', {\n          type: 'date', value: from, 'aria-label': t('startTime'),\n          onChange: (e) => setFrom(e.target.value),\n        })),\n      h('label', { className: 'tsd-field' },\n        h('span', { className: 'tsd-field-label' }, t('endTime')),\n        h('input', {\n          type: 'date', value: to, 'aria-label': t('endTime'),\n          onChange: (e) => setTo(e.target.value),\n        }))),\n    invalid\n      ? h('p', { className: 'tsd-field-error', role: 'alert' }, t('rangeInvalid'))\n      : null,\n    h('p', { className: 'tsd-field-hint' }, t('rangeHint')),\n    h('div', { className: 'tsd-popover-actions' },\n      h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: onClose }, t('cancel')),\n      h('button', {\n        type: 'button', className: 'tsd-btn tsd-btn-primary',\n        disabled: invalid,\n        onClick: () => { if (!invalid) onApply({ from, to }) },\n      }, t('confirm'))))\n}\n\n/* ---------------------------------------------------------------------------\n * 模型多选下拉\n * ------------------------------------------------------------------------- */\nfunction ModelDropdown(props) {\n  const { options, selected, onChange } = props\n  const t = useT()\n  const [open, setOpen] = React.useState(false)\n  const [query, setQuery] = React.useState('')\n  const anchorRef = React.useRef(null)\n\n  React.useEffect(() => {\n    if (!open) return undefined\n    function handler(e) {\n      if (anchorRef.current && !anchorRef.current.contains(e.target)) setOpen(false)\n    }\n    function onKey(e) {\n      if (e.key === 'Escape' || e.key === 'Esc') setOpen(false)\n    }\n    document.addEventListener('click', handler)\n    document.addEventListener('keydown', onKey)\n    return () => {\n      document.removeEventListener('click', handler)\n      document.removeEventListener('keydown', onKey)\n    }\n  }, [open])\n\n  // 只列出当前范围有数据的模型；已选但掉出候选列表的「补回」，保证可渲染、可清除\n  const candidates = React.useMemo(() => {\n    const set = new Set((options || []).map((m) => m.provider + '/' + m.model))\n    ;(selected || []).forEach((m) => set.add(m))\n    const list = Array.from(set)\n    list.sort()\n    return list\n  }, [options, selected])\n\n  const q = query.trim().toLocaleLowerCase()\n  const filtered = q === '' ? candidates : candidates.filter((c) => c.toLocaleLowerCase().indexOf(q) >= 0)\n  const label = selected.length === 0 ? t('allModels') : t('selectedModels', { count: selected.length })\n\n  return h('div', { className: 'tsd-popover-anchor', ref: anchorRef },\n    h('button', {\n      type: 'button',\n      className: 'tsd-select-btn' + (selected.length > 0 ? ' tsd-select-has' : ''),\n      onClick: () => { setOpen((v) => !v); setQuery('') },\n      'aria-expanded': open,\n      'aria-haspopup': 'listbox',\n      title: label,\n    },\n      h('span', { className: 'tsd-select-label' }, label),\n      h(SvgIcon, { name: 'chevron', size: 14, className: 'tsd-chevron' + (open ? ' tsd-chevron-open' : '') })),\n    open\n      ? h('div', {\n          className: 'tsd-popover tsd-model-popover',\n          role: 'listbox',\n          'aria-label': t('modelFilterGroup'),\n          'aria-multiselectable': true,\n        },\n          h('div', { className: 'tsd-popover-tools' },\n            h('button', { type: 'button', className: 'tsd-link-btn', onClick: () => onChange(candidates.slice()) }, t('selectAll')),\n            h('button', { type: 'button', className: 'tsd-link-btn', onClick: () => onChange([]) }, t('clear'))),\n          h('div', { className: 'tsd-search' },\n            h(SvgIcon, { name: 'search', size: 14, className: 'tsd-search-icon' }),\n            h('input', {\n              type: 'search', value: query, placeholder: t('searchModels'),\n              'aria-label': t('searchModels'),\n              onChange: (e) => setQuery(e.target.value),\n            })),\n          h('div', { className: 'tsd-model-list' },\n            filtered.length === 0\n              ? h('p', { className: 'tsd-popover-empty' }, t('noMatchModels'))\n              : null,\n            filtered.map((key) =>\n              h('label', { key, className: 'tsd-model-item' },\n                h('input', {\n                  type: 'checkbox',\n                  checked: selected.indexOf(key) >= 0,\n                  onChange: (e) => {\n                    const next = selected.slice()\n                    if (e.target.checked) {\n                      if (next.indexOf(key) < 0) next.push(key)\n                    } else {\n                      const i = next.indexOf(key)\n                      if (i >= 0) next.splice(i, 1)\n                    }\n                    onChange(next) // 勾选即时生效\n                  },\n                }),\n                h('span', { className: 'tsd-model-name', title: key }, key)))),\n          h('p', { className: 'tsd-popover-note' }, t('modelFilterHint')))\n      : null)\n}\n\n/* ---------------------------------------------------------------------------\n * 筛选栏：日期预设（分段按钮）+ 自定义浮层 + 模型多选\n * ------------------------------------------------------------------------- */\nfunction FilterBar(props) {\n  const {\n    range, custom, models, customOpen, modelOptions,\n    onPreset, onCustomOpen, onCustomApply, onCustomClose, onModelsChange,\n  } = props\n  const t = useT()\n  const segRef = React.useRef(null)\n  useOutsideClick(customOpen, segRef, onCustomClose)\n\n  const customLabel = fmtDateSlash(custom.from) + ' - ' + fmtDateSlash(custom.to)\n  const presets = [\n    { key: 'today', label: t('today') },\n    { key: '7d', label: t('last7d') },\n    { key: '30d', label: t('last30d') },\n    { key: 'custom', label: t('custom') },\n  ]\n\n  return h('div', { className: 'tsd-filterbar' },\n    h('div', { className: 'tsd-seg-wrap', ref: segRef },\n      h('div', { className: 'tsd-seg', role: 'group', 'aria-label': t('dateRangeGroup') },\n        presets.map((p) => {\n          const active = range === p.key\n          const isCustom = p.key === 'custom'\n          const label = isCustom && active ? customLabel : p.label\n          return h('button', {\n            key: p.key,\n            type: 'button',\n            className: 'tsd-seg-btn' + (active ? ' tsd-seg-active' : '') + (isCustom ? ' tsd-seg-custom' : ''),\n            'aria-pressed': active,\n            title: isCustom && active ? customLabel : undefined,\n            onClick: () => { if (isCustom) onCustomOpen(!customOpen); else onPreset(p.key) },\n          },\n            h('span', { className: 'tsd-seg-label' }, label))\n        })),\n      customOpen ? h(CustomRangePopover, { custom, onApply: onCustomApply, onClose: onCustomClose }) : null),\n    h(ModelDropdown, { options: modelOptions, selected: models, onChange: onModelsChange }))\n}\n\n/* ---------------------------------------------------------------------------\n * 汇总指标卡 ×5\n * ------------------------------------------------------------------------- */\nfunction SummaryCards(props) {\n  const { total, currency, unpricedCalls } = props\n  const tt = useT()\n  const d = total || {}\n  const inputTotal = (d.inputTokens || 0) + (d.cacheReadTokens || 0) + (d.cacheWriteTokens || 0)\n  const cards = [\n    {\n      key: 'total', icon: 'layers', label: tt('totalTokens'),\n      value: formatTokensShort(d.totalTokens), title: formatInt(d.totalTokens),\n      sub: tt('approxIO'), color: 'var(--dsw-alias-brand-primary)',\n    },\n    {\n      key: 'input', icon: 'down', label: tt('inputTokens'),\n      value: formatTokensShort(inputTotal), title: formatInt(inputTotal),\n      color: 'var(--dsw-static-deepseek-500)',\n    },\n    {\n      key: 'output', icon: 'up', label: tt('outputTokens'),\n      value: formatTokensShort(d.outputTokens), title: formatInt(d.outputTokens),\n      color: 'var(--dsw-static-green-500)',\n    },\n    {\n      key: 'calls', icon: 'activity', label: tt('calls'),\n      value: formatInt(d.calls), title: formatInt(d.calls),\n      color: 'var(--dsw-static-deepseek-500)',\n    },\n    {\n      key: 'cost', icon: 'coins', label: tt('cost'),\n      value: formatCost(d.cost, currency), title: formatCost(d.cost, currency),\n      color: 'var(--dsw-static-green-500)',\n    },\n  ]\n  return h('div', { className: 'tsd-cards' },\n    cards.map((c) =>\n      h('div', { key: c.key, className: 'tsd-card' },\n        h('div', { className: 'tsd-card-head' },\n          h('span', { className: 'tsd-card-icon', style: { color: c.color } },\n            h(SvgIcon, { name: c.icon, size: 14 })),\n          h('span', { className: 'tsd-card-label' }, c.label)),\n        h('div', { className: 'tsd-card-value', title: c.title }, c.value),\n        c.sub ? h('div', { className: 'tsd-card-sub' }, c.sub) : null,\n        c.key === 'cost' && unpricedCalls > 0\n          ? h('div', { className: 'tsd-card-note' }, tt('unpricedNote', { count: formatInt(unpricedCalls) }))\n          : null)))\n}\n\n/* ---------------------------------------------------------------------------\n * 每日用量柱状图（手写 div 堆叠柱：下段输入蓝 / 上段输出绿）\n * ------------------------------------------------------------------------- */\nfunction DailyChart(props) {\n  const { daily, gran, stepDays, granLabel } = props\n  const t = useT()\n  const chartRef = React.useRef(null)\n  const [tip, setTip] = React.useState(null) // { row, x }\n  const [view, setView] = React.useState('bar') // bar | line\n  const rows = daily || []\n\n  const inOf = (r) => (r.inputTokens || 0) + (r.cacheReadTokens || 0) + (r.cacheWriteTokens || 0)\n  const outOf = (r) => r.outputTokens || 0\n  const totOf = (r) => r.totalTokens || 0\n\n  if (rows.length === 0) {\n    return h('div', { className: 'tsd-card tsd-chart-card' },\n      h('div', { className: 'tsd-card-header' },\n        h('h3', { className: 'tsd-card-title' }, t('dailyTrend')),\n        h('span', { className: 'tsd-card-tag' }, t('noData'))),\n      h('div', { className: 'tsd-empty-block' }, t('noData')))\n  }\n\n  const max = Math.max(1, ...rows.map((d) => d.totalTokens || 0))\n  const labelEvery = rows.length > 28 ? 4 : rows.length > 14 ? 2 : 1\n  const firstLabel = xLabel(rows[0].key, gran)\n  const lastLabel = xLabel(rows[rows.length - 1].key, gran)\n  const rangeLabel = firstLabel + ' - ' + lastLabel\n\n  function showTip(e, row) {\n    const chartRect = chartRef.current ? chartRef.current.getBoundingClientRect() : null\n    if (!chartRect) return\n    const elRect = e.currentTarget.getBoundingClientRect()\n    const x = Math.min(Math.max(elRect.left + elRect.width / 2 - chartRect.left, 72), chartRect.width - 72)\n    setTip({ row, x })\n  }\n\n  const viewSwitcher = h('div', { className: 'tsd-gran', role: 'group', 'aria-label': t('chartTypeGroup') },\n    h('button', {\n      type: 'button',\n      className: 'tsd-gran-btn',\n      'data-active': view === 'bar' ? 'true' : undefined,\n      onClick: () => { setTip(null); setView('bar') },\n    }, t('barView')),\n    h('button', {\n      type: 'button',\n      className: 'tsd-gran-btn',\n      'data-active': view === 'line' ? 'true' : undefined,\n      onClick: () => { setTip(null); setView('line') },\n    }, t('lineView')))\n\n  const barTip = tip\n    ? h('div', { className: 'tsd-tooltip', style: { left: tip.x + 'px' } },\n        h('div', { className: 'tsd-tooltip-date' }, tip.row.key + ' ' + weekdayName(tip.row.key, t)),\n        h('div', { className: 'tsd-tooltip-row' },\n          h('span', { className: 'tsd-tooltip-dot tsd-legend-in' }),\n          h('span', null, t('legendInput')),\n          h('span', { className: 'tsd-tooltip-val' }, formatInt(inOf(tip.row)))),\n        h('div', { className: 'tsd-tooltip-row' },\n          h('span', { className: 'tsd-tooltip-dot tsd-legend-out' }),\n          h('span', null, t('legendOutput')),\n          h('span', { className: 'tsd-tooltip-val' }, formatInt(outOf(tip.row)))),\n        h('div', { className: 'tsd-tooltip-total' },\n          h('span', null, t('tooltipTotal')),\n          h('span', null, formatInt(totOf(tip.row)))))\n    : null\n\n  const body = view === 'line'\n    ? h(LineChart, { rows, gran, stepDays, showTip, tip, setTip, chartRef })\n    : h('div', { className: 'tsd-chart', ref: chartRef },\n        rows.map((row, i) => {\n          const inT = inOf(row)\n          const outT = outOf(row)\n          const totT = totOf(row)\n          const pctIn = (inT / max) * 100\n          const pctOut = (outT / max) * 100\n          const showLabel = i % labelEvery === 0 || i === rows.length - 1\n          return h('div', {\n            key: row.key,\n            className: 'tsd-chart-col',\n            tabIndex: 0,\n            onMouseEnter: (e) => showTip(e, row),\n            onMouseLeave: () => setTip(null),\n            onFocus: (e) => showTip(e, row),\n            onBlur: () => setTip(null),\n            'aria-label': t('barAria', { key: row.key, in: formatInt(inT), out: formatInt(outT), tot: formatInt(totT) }),\n          },\n            h('div', { className: 'tsd-chart-plot' },\n              h('div', { className: 'tsd-chart-stack' },\n                h('div', { className: 'tsd-chart-seg tsd-seg-out', style: { height: pctOut + '%' } }),\n                h('div', { className: 'tsd-chart-seg tsd-seg-in', style: { height: pctIn + '%' } }))),\n            h('span', {\n              className: 'tsd-chart-label' + (showLabel ? '' : ' tsd-chart-label-hidden'),\n            }, xLabel(row.key, gran)))\n        }),\n        barTip)\n\n  return h('div', { className: 'tsd-card tsd-chart-card' },\n    h('div', { className: 'tsd-card-header' },\n      h('h3', { className: 'tsd-card-title' }, t('dailyTrend')),\n      h('span', { className: 'tsd-card-actions' },\n        h('span', { className: 'tsd-card-tag' }, granLabel + ' · ' + rangeLabel),\n        viewSwitcher)),\n    h('div', { className: 'tsd-legend' },\n      h('span', { className: 'tsd-legend-item' },\n        h('span', { className: 'tsd-legend-dot tsd-legend-in' }), t('legendInput')),\n      h('span', { className: 'tsd-legend-item' },\n        h('span', { className: 'tsd-legend-dot tsd-legend-out' }), t('legendOutput')),\n      h('span', { className: 'tsd-legend-item' },\n        h('span', { className: 'tsd-legend-dot tsd-legend-total' }), t('legendTotal'))),\n    body)\n}\n\n/* ---------------------------------------------------------------------------\n * 折线图（SVG：输入 / 输出 / 总 Token）\n * ------------------------------------------------------------------------- */\n/** Catmull-Rom -> cubic bezier smooth path through the given points. */\nfunction smoothPath(pts) {\n  if (!pts || pts.length < 2) return ''\n  const f = (v) => Math.round(v * 100) / 100\n  let d = 'M ' + f(pts[0].x) + ' ' + f(pts[0].y)\n  for (let i = 0; i < pts.length - 1; i++) {\n    const p0 = pts[i - 1] || pts[i]\n    const p1 = pts[i]\n    const p2 = pts[i + 1]\n    const p3 = pts[i + 2] || p2\n    const c1x = p1.x + (p2.x - p0.x) / 6\n    const c1y = p1.y + (p2.y - p0.y) / 6\n    const c2x = p2.x - (p3.x - p1.x) / 6\n    const c2y = p2.y - (p3.y - p1.y) / 6\n    d += ' C ' + f(c1x) + ' ' + f(c1y) + ', ' + f(c2x) + ' ' + f(c2y) + ', ' + f(p2.x) + ' ' + f(p2.y)\n  }\n  return d\n}\n\nfunction LineChart(props) {\n  const { rows, gran, stepDays, showTip, tip, setTip, chartRef } = props\n  const t = useT()\n  const W = 620\n  const H = 240\n  const PAD = { t: 14, r: 14, b: 26, l: 48 }\n  const innerW = W - PAD.l - PAD.r\n  const innerH = H - PAD.t - PAD.b\n  const n = rows.length\n\n  const inOf = (r) => (r.inputTokens || 0) + (r.cacheReadTokens || 0) + (r.cacheWriteTokens || 0)\n  const outOf = (r) => r.outputTokens || 0\n  const totOf = (r) => r.totalTokens || 0\n  const max = Math.max(1, ...rows.map((d) => d.totalTokens || 0))\n  const niceMax = niceCeil(max)\n\n  const x = (i) => PAD.l + (n === 1 ? innerW / 2 : (i / (n - 1)) * innerW)\n  const y = (v) => PAD.t + innerH - (v / niceMax) * innerH\n  const colW = innerW / n\n\n  // Hover state: pixel x for the tooltip, viewBox x for the cursor + dots.\n  function showTipLine(e, row) {\n    const rect = chartRef.current ? chartRef.current.getBoundingClientRect() : null\n    if (!rect || rect.width === 0) return\n    const elRect = e.currentTarget.getBoundingClientRect()\n    const xPx = elRect.left + elRect.width / 2 - rect.left\n    const svgX = (xPx / rect.width) * W\n    const x = Math.min(Math.max(xPx, 72), rect.width - 72)\n    setTip({ row, x, svgX })\n  }\n  const trow = tip ? tip.row : null\n  const cursor = tip\n    ? h('line', {\n        key: 'cursor',\n        className: 'tsd-line-cursor',\n        x1: tip.svgX, y1: PAD.t, x2: tip.svgX, y2: H - PAD.b,\n      })\n    : null\n  const dots = tip\n    ? [\n        h('circle', { key: 'hl-in', className: 'tsd-line-hl tsd-line-hl-in', cx: tip.svgX, cy: y(inOf(trow)), r: 3.5 }),\n        h('circle', { key: 'hl-out', className: 'tsd-line-hl tsd-line-hl-out', cx: tip.svgX, cy: y(outOf(trow)), r: 3.5 }),\n        h('circle', { key: 'hl-tot', className: 'tsd-line-hl tsd-line-hl-total', cx: tip.svgX, cy: y(totOf(trow)), r: 3.5 }),\n      ]\n    : null\n\n  const inPts = smoothPath(rows.map((r, i) => ({ x: x(i), y: y(inOf(r)) })))\n  const outPts = smoothPath(rows.map((r, i) => ({ x: x(i), y: y(outOf(r)) })))\n  const totPts = smoothPath(rows.map((r, i) => ({ x: x(i), y: y(totOf(r)) })))\n  const gridF = [0, 0.25, 0.5, 0.75, 1]\n  const labelEvery = rows.length > 28 ? 4 : rows.length > 14 ? 2 : 1\n  const showLabel = (i) => i % labelEvery === 0 || i === rows.length - 1\n\n  return h('div', { className: 'tsd-linechart', ref: chartRef },\n    h('svg', { viewBox: '0 0 ' + W + ' ' + H, role: 'img', 'aria-label': t('lineChartAria') },\n      // grid + axis\n      gridF.map((f) =>\n        h('line', {\n          key: 'g' + f,\n          className: 'tsd-line-grid',\n          x1: PAD.l, y1: y(f * niceMax), x2: W - PAD.r, y2: y(f * niceMax),\n        })),\n      h('line', { className: 'tsd-line-axis', x1: PAD.l, y1: PAD.t, x2: PAD.l, y2: H - PAD.b }),\n      h('line', { className: 'tsd-line-axis', x1: PAD.l, y1: H - PAD.b, x2: W - PAD.r, y2: H - PAD.b }),\n      // y labels\n      gridF.map((f) =>\n        h('text', {\n          key: 'yt' + f,\n          className: 'tsd-line-text',\n          x: PAD.l - 6,\n          y: y(f * niceMax) + 3,\n          textAnchor: 'end',\n        }, formatTokensShort(f * niceMax))),\n      // series (smooth curves)\n      h('path', { className: 'tsd-line-total', d: totPts }),\n      h('path', { className: 'tsd-line-in', d: inPts }),\n      h('path', { className: 'tsd-line-out', d: outPts }),\n      cursor,\n      dots,\n      // x labels\n      rows.map((r, i) =>\n        showLabel(i)\n          ? h('text', {\n              key: 'xl' + i,\n              className: 'tsd-line-text',\n              x: x(i),\n              y: H - 8,\n              textAnchor: i === 0 ? 'start' : i === n - 1 ? 'end' : 'middle',\n            }, xLabel(r.key, gran))\n          : null),\n      // hover targets: a full-height column per bucket, matching the bar chart feel\n      rows.map((r, i) =>\n        h('rect', {\n          key: 'h' + i,\n          className: 'tsd-line-hover',\n          x: x(i) - colW / 2,\n          y: PAD.t,\n          width: colW,\n          height: innerH,\n          tabIndex: 0,\n          onMouseEnter: (e) => showTipLine(e, r),\n          onMouseLeave: () => setTip(null),\n          onFocus: (e) => showTipLine(e, r),\n          onBlur: () => setTip(null),\n        })),\n      // visible dots on sparse points\n      rows.map((r, i) =>\n        i % labelEvery === 0 || i === n - 1\n          ? h('circle', {\n              key: 'd' + i,\n              className: 'tsd-line-dot',\n              cx: x(i),\n              cy: y(totOf(r)),\n              r: 2.5,\n            })\n          : null)),\n    tip\n      ? h('div', { className: 'tsd-tooltip', style: { left: tip.x + 'px' } },\n          h('div', { className: 'tsd-tooltip-date' }, tip.row.key + (stepDays > 1 ? ' ' + t('startNDays', { n: stepDays }) : '') + ' ' + weekdayName(tip.row.key, t)),\n          h('div', { className: 'tsd-tooltip-row' },\n            h('span', { className: 'tsd-tooltip-dot tsd-legend-in' }),\n            h('span', null, t('legendInput')),\n            h('span', { className: 'tsd-tooltip-val' }, formatInt(inOf(tip.row)))),\n          h('div', { className: 'tsd-tooltip-row' },\n            h('span', { className: 'tsd-tooltip-dot tsd-legend-out' }),\n            h('span', null, t('legendOutput')),\n            h('span', { className: 'tsd-tooltip-val' }, formatInt(outOf(tip.row)))),\n          h('div', { className: 'tsd-tooltip-total' },\n            h('span', null, t('tooltipTotal')),\n            h('span', null, formatInt(totOf(tip.row)))))\n      : null)\n}\n\n/* ---------------------------------------------------------------------------\n * 年度用量热力图（GitHub 风格）\n * ------------------------------------------------------------------------- */\nfunction HeatmapCard(props) {\n  const { days } = props\n  const t = useT()\n  const [htip, setHtip] = React.useState(null) // { cell, left, top } in viewport coords\n  const grid = React.useMemo(() => {\n    const list = days || []\n    if (list.length === 0) return null\n    const max = Math.max(1, ...list.map((d) => d.totalTokens || 0))\n    const first = new Date(list[0].key + 'T00:00:00')\n    const offset = first.getDay() // 0 = Sunday\n    const weeks = []\n    let cur = []\n    for (let i = 0; i < offset; i++) cur.push(null)\n    for (const d of list) {\n      cur.push(d)\n      if (cur.length === 7) {\n        weeks.push(cur)\n        cur = []\n      }\n    }\n    if (cur.length > 0) {\n      while (cur.length < 7) cur.push(null)\n      weeks.push(cur)\n    }\n    // 月份标记：某月 1 日所在的列\n    const monthMarks = []\n    weeks.forEach((wk, col) => {\n      for (const c of wk) {\n        if (c && c.key.endsWith('-01')) {\n          monthMarks.push({ col, name: t('monthLabel', { n: Number(c.key.slice(5, 7)) }) })\n          break\n        }\n      }\n    })\n    return { weeks, max, monthMarks }\n  }, [days])\n\n  if (grid === null) return null\n\n  function showCellTip(e, c) {\n    const elRect = e.currentTarget.getBoundingClientRect()\n    setHtip({ cell: c, left: elRect.left + elRect.width / 2, top: elRect.top })\n  }\n\n  const heatTip = htip\n    ? h('div', {\n        className: 'tsd-tooltip tsd-heat-tip',\n        style: { position: 'fixed', left: htip.left + 'px', top: htip.top + 'px', transform: 'translate(-50%, -110%)' },\n      },\n        h('div', { className: 'tsd-tooltip-date' }, htip.cell.key + ' ' + weekdayName(htip.cell.key, t)),\n        h('div', { className: 'tsd-tooltip-row' },\n          h('span', { className: 'tsd-tooltip-dot', style: { background: 'var(--dsw-static-deepseek-500)' } }),\n          h('span', null, t('totalTokens')),\n          h('span', { className: 'tsd-tooltip-val' }, formatInt(htip.cell.totalTokens || 0))),\n        htip.cell.calls > 0\n          ? h('div', { className: 'tsd-tooltip-row' },\n              h('span', { className: 'tsd-tooltip-dot', style: { background: 'var(--dsw-alias-label-tertiary)' } }),\n              h('span', null, t('calls')),\n              h('span', { className: 'tsd-tooltip-val' }, formatInt(htip.cell.calls)))\n          : null)\n    : null\n\n  const dayNames = ['', t('weekdayMon'), '', t('weekdayWed'), '', t('weekdayFri'), '']\n  const legendSteps = [0, 0.25, 0.5, 0.75, 1]\n\n  return h('div', { className: 'tsd-card tsd-heatmap-card' },\n    h('div', { className: 'tsd-card-header' },\n      h('h3', { className: 'tsd-card-title' }, t('yearlyHeatmap')),\n      h('span', { className: 'tsd-card-tag' }, t('yearDaily', { year: new Date().getFullYear() }))),\n    h('div', { className: 'tsd-heatmap' },\n      h('div', { className: 'tsd-heatmap-inner' },\n        h('div', { className: 'tsd-heatmap-months' },\n          grid.monthMarks.map((m) =>\n            h('span', {\n              key: m.col,\n              className: 'tsd-heatmap-month',\n              style: { left: (m.col * 12) + 'px' },\n            }, m.name))),\n        h('div', { className: 'tsd-heatmap-body' },\n          h('div', { className: 'tsd-heatmap-days' },\n            dayNames.map((n, i) =>\n              h('span', { key: i, className: 'tsd-heatmap-day' }, n))),\n          h('div', { className: 'tsd-heatmap-grid' },\n            grid.weeks.map((wk, col) =>\n              h('div', { key: col, className: 'tsd-heatmap-col' },\n                wk.map((c, row) =>\n                  c\n                    ? h('span', {\n                        key: c.key,\n                        className: 'tsd-heatmap-cell',\n                        style: { background: heatColor(c.totalTokens || 0, grid.max) },\n                        title: t('hmTitle', { key: c.key, tokens: formatInt(c.totalTokens || 0), calls: c.calls ? t('hmCalls', { count: formatInt(c.calls) }) : '' }),\n                        onMouseEnter: (e) => showCellTip(e, c),\n                        onMouseLeave: () => setHtip(null),\n                        onFocus: (e) => showCellTip(e, c),\n                        onBlur: () => setHtip(null),\n                        tabIndex: 0,\n                      })\n                    : h('span', { key: 'e' + col + '-' + row, className: 'tsd-heatmap-cell', style: { visibility: 'hidden' } }))))))),\n    heatTip,\n    h('div', { className: 'tsd-heatmap-legend' },\n      h('span', null, t('less')),\n      legendSteps.map((s) =>\n        h('span', {\n          key: s,\n          className: 'tsd-heatmap-cell',\n          style: { background: s === 0 ? 'var(--dsw-alias-interactive-bg-hover)' : heatColor(Math.max(1, s * 100), 100) },\n        })),\n      h('span', null, t('more')))))\n}\n\n/* ---------------------------------------------------------------------------\n * 按模型明细表\n * ------------------------------------------------------------------------- */\nfunction ModelTable(props) {\n  const { rows, currency } = props\n  const t = useT()\n  const all = rows || []\n  const [sortKey, setSortKey] = React.useState('total')\n  const [sortDir, setSortDir] = React.useState('desc')\n\n  const view = React.useMemo(() => all.map((r) => ({\n    key: r.key,\n    calls: r.calls || 0,\n    input: (r.inputTokens || 0) + (r.cacheReadTokens || 0) + (r.cacheWriteTokens || 0),\n    output: r.outputTokens || 0,\n    total: r.totalTokens || 0,\n    cost: r.cost || 0,\n    unpriced: (r.totalTokens || 0) > 0 && !(r.cost > 0),\n  })), [all])\n\n  const sumTotal = React.useMemo(() => view.reduce((s, r) => s + r.total, 0), [view])\n\n  const sorted = React.useMemo(() => {\n    const list = view.slice()\n    const dir = sortDir === 'asc' ? 1 : -1\n    list.sort((a, b) => {\n      const av = a[sortKey]\n      const bv = b[sortKey]\n      if (av === bv) return 0\n      return (av > bv ? 1 : -1) * dir\n    })\n    return list\n  }, [view, sortKey, sortDir])\n\n  function toggleSort(key) {\n    if (sortKey === key) setSortDir((d) => (d === 'asc' ? 'desc' : 'asc'))\n    else { setSortKey(key); setSortDir('desc') }\n  }\n\n  const cols = [\n    { key: 'model', label: t('colModel'), sortable: false },\n    { key: 'calls', label: t('colCalls'), sortable: true },\n    { key: 'input', label: t('colInput'), sortable: true },\n    { key: 'output', label: t('colOutput'), sortable: true },\n    { key: 'total', label: t('colTotal'), sortable: true },\n    { key: 'cost', label: t('colCost'), sortable: true },\n    { key: 'ratio', label: t('colShare'), sortable: false },\n  ]\n\n  return h('div', { className: 'tsd-card tsd-table-card' },\n    h('div', { className: 'tsd-card-header' },\n      h('h3', { className: 'tsd-card-title' }, t('byModelTitle')),\n      h('span', { className: 'tsd-card-tag' },\n        t('modelCount', { n: view.length }) + ' · ' + t('colTotal') + ' ' + formatInt(sumTotal))),\n    view.length === 0\n      ? h('div', { className: 'tsd-empty-block' }, t('noData'))\n      : h('div', { className: 'tsd-table-wrap' },\n          h('table', { className: 'tsd-table' },\n            h('caption', { className: 'tsd-visually-hidden' }, t('modelTableCaption')),\n            h('thead', null,\n              h('tr', null, cols.map((c) =>\n                h('th', {\n                  key: c.key,\n                  className: 'tsd-th' + (c.key === 'model' ? '' : ' tsd-th-num'),\n                },\n                  c.sortable\n                    ? h('button', {\n                        type: 'button',\n                        className: 'tsd-sort-btn' + (sortKey === c.key ? ' tsd-sort-active' : ''),\n                        onClick: () => toggleSort(c.key),\n                      },\n                        c.label,\n                        sortKey === c.key\n                          ? h('span', { className: 'tsd-sort-arrow' }, sortDir === 'asc' ? '↑' : '↓')\n                          : null)\n                    : c.label)))),\n            h('tbody', null, sorted.map((r) => {\n              const ratio = sumTotal > 0 ? r.total / sumTotal : 0\n              return h('tr', { key: r.key, className: 'tsd-tr' },\n                h('td', { className: 'tsd-td tsd-td-model' },\n                  h('span', { className: 'tsd-model-mono', title: r.key }, r.key)),\n                h('td', { className: 'tsd-td tsd-num' }, formatInt(r.calls)),\n                h('td', { className: 'tsd-td tsd-num' }, formatInt(r.input)),\n                h('td', { className: 'tsd-td tsd-num' }, formatInt(r.output)),\n                h('td', { className: 'tsd-td tsd-num tsd-total' }, formatInt(r.total)),\n                h('td', { className: 'tsd-td tsd-num' },\n                  r.unpriced\n                    ? h('span', { className: 'tsd-unpriced', title: t('unpricedRowHint') }, t('unpriced'))\n                    : formatCost(r.cost, currency)),\n                h('td', { className: 'tsd-td tsd-td-ratio' },\n                  h('div', { className: 'tsd-ratio' },\n                    h('div', { className: 'tsd-ratio-bar' },\n                      h('div', { className: 'tsd-ratio-fill', style: { width: ratio * 100 + '%' } })),\n                    h('span', { className: 'tsd-ratio-pct' }, fmtPct(ratio)))))\n            })))))\n}\n\n/* ---------------------------------------------------------------------------\n * 三态：加载 / 错误 / 空\n * ------------------------------------------------------------------------- */\nfunction LoadingState() {\n  const t = useT()\n  return h('div', { className: 'tsd-loading' },\n    h('div', { className: 'tsd-cards' },\n      [0, 1, 2, 3, 4].map((i) =>\n        h('div', { key: i, className: 'tsd-card tsd-card-skeleton' },\n          h('div', { className: 'tsd-skeleton', style: { width: '40%', height: 12 } }),\n          h('div', { className: 'tsd-skeleton', style: { width: '70%', height: 22, marginTop: 10 } })))),\n    h('div', { className: 'tsd-card' },\n      h('div', { className: 'tsd-skeleton', style: { width: '100%', height: 300 } })),\n    h('div', { className: 'tsd-card' },\n      [0, 1, 2, 3, 4, 5].map((i) =>\n        h('div', { key: i, className: 'tsd-skeleton-row', style: { width: 96 - i * 8 + '%' } }))))\n}\n\nfunction ErrorState(props) {\n  const { error, onRetry } = props\n  const t = useT()\n  return h('div', { className: 'tsd-card tsd-error', role: 'alert' },\n    h(SvgIcon, { name: 'alert', size: 22, className: 'tsd-error-icon' }),\n    h('div', { className: 'tsd-error-text' },\n      h('p', { className: 'tsd-error-title' }, t('loadFailedTitle')),\n      h('p', { className: 'tsd-error-detail' }, String((error && error.message) || error))),\n    h('button', { type: 'button', className: 'tsd-btn tsd-btn-primary', onClick: onRetry }, t('retry')))\n}\n\nfunction EmptyState(props) {\n  const { filtered, onReset } = props\n  const t = useT()\n  return h('div', { className: 'tsd-card tsd-empty' },\n    h(SvgIcon, { name: 'inbox', size: 28, className: 'tsd-empty-icon' }),\n    h('p', { className: 'tsd-empty-title' }, t('noData')),\n    h('p', { className: 'tsd-empty-desc' },\n      filtered ? t('emptyFiltered') : t('emptyDesc')),\n    h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: onReset }, t('resetFilters')))\n}\n\n/* ---------------------------------------------------------------------------\n * 页面级状态机 + 布局\n * ------------------------------------------------------------------------- */\nfunction StatsDashboard(props) {\n  const t = props.t || fallbackT\n  const [range, setRange] = React.useState('today') // today | 7d | 30d | custom\n  const [custom, setCustom] = React.useState(defaultCustom)\n  const [models, setModels] = React.useState([]) // [] = 全部模型\n  const [customOpen, setCustomOpen] = React.useState(false)\n  const [retry, setRetry] = React.useState(0)\n  const [status, setStatus] = React.useState('loading') // loading | refreshing | ready | error\n  const [data, setData] = React.useState(null)\n  const [error, setError] = React.useState(null)\n  const [prices, setPrices] = React.useState({ prices: {}, currency: '¥' })\n  // P1-6 backfill 轮询状态：queryKey 变化时重置，仅对同一查询串轮询\n  const queryKeyRef = React.useRef(null)\n  const backfillSeenRef = React.useRef(false)\n  const finalRefreshRef = React.useRef(false)\n\n  const eff = React.useMemo(() => rangeFor(range, custom), [range, custom])\n  // Fixed step policy: today = hourly; 7d/30d/custom = daily, custom uses a\n  // stable step (1/3/5/7 days) chosen by the range length.\n  const effGran = effGranularity(range)\n  const stepDays = range === 'custom' ? pickStepDays((eff.to || 0) - (eff.from || 0)) : 1\n  const granLabel = stepLabel(t, range, stepDays)\n\n  // 查询统计（首载骨架；刷新保留旧数据转 refreshing；fill 0 填充 + 年度热力图）\n  // P1-6：backfill running 时每 3s 自动重查；done 后补一次收尾查询即停。\n  React.useEffect(() => {\n    let current = true\n    let backfillTimer = null\n    const queryKey = eff.from + '|' + eff.to + '|' + models.join(',') + '|' + effGran + '|' + stepDays\n    if (queryKeyRef.current !== queryKey) {\n      queryKeyRef.current = queryKey\n      backfillSeenRef.current = false\n      finalRefreshRef.current = false\n    }\n    const isFinalRun = finalRefreshRef.current\n    finalRefreshRef.current = false\n    setStatus((s) => (s === 'ready' && data !== null ? 'refreshing' : 'loading'))\n    hostCall('usage/query', {\n      from: eff.from,\n      to: eff.to,\n      models: models.slice(),\n      fill: true,\n      granularity: effGran,\n      stepDays,\n      heatmap: true,\n    })\n      .then((r) => {\n        if (!current) return\n        setData(r)\n        setStatus('ready')\n        setError(null)\n        const bs = r && r.backfill ? r.backfill.status : null\n        if (bs === 'running') {\n          backfillSeenRef.current = true\n          // 同一 effect 至多挂一个定时器；重查复用 retry 计数器触发 effect 重跑\n          backfillTimer = setTimeout(() => {\n            if (current) setRetry((v) => v + 1)\n          }, 3000)\n        } else if (bs === 'done' && backfillSeenRef.current && !isFinalRun) {\n          // 回填收尾：恰好再查一次拿到完整数据后停止\n          finalRefreshRef.current = true\n          setRetry((v) => v + 1)\n        }\n      }, (e) => {\n        if (!current) return\n        setError(e)\n        setStatus('error')\n      })\n    return () => {\n      current = false\n      if (backfillTimer !== null) clearTimeout(backfillTimer)\n    }\n  }, [eff.from, eff.to, models, effGran, stepDays, retry])\n\n  // 价格表：进入页面拉一次 + 每次刷新同步。\n  // P0-1：优先官方 settings scope（usage.prices 命名空间），不可用时回退 RPC。\n  React.useEffect(() => {\n    let current = true\n    let scopeDispose = null\n    const loadRpc = () => {\n      hostCall('usage/prices').then((p) => {\n        if (current && p && p.prices) setPrices(p)\n      }, () => {})\n    }\n    try {\n      const scope = getUsagePricesScope()\n      if (scope && typeof scope.getSnapshot === 'function' && typeof scope.subscribe === 'function') {\n        let adopted = false\n        const adopt = () => {\n          if (!current) return\n          const snap = scope.getSnapshot()\n          const v = snap && snap.value\n          if (snap && snap.status === 'unavailable') return\n          if (v && (v.prices || v.currency)) {\n            adopted = true\n            setPrices({ prices: v.prices || {}, currency: v.currency || '¥' })\n          }\n        }\n        adopt()\n        scopeDispose = scope.subscribe(adopt)\n        if (!adopted) loadRpc() // scope 未就绪/无值：先走 RPC，订阅就绪后 scope 优先覆盖\n      } else {\n        loadRpc()\n      }\n    } catch (e) {\n      loadRpc() // 探测/绑定异常：完整回退 RPC，绝不抛出\n    }\n    return () => {\n      current = false\n      if (scopeDispose) {\n        try { scopeDispose() } catch (e) {}\n      }\n    }\n  }, [retry])\n\n  const reload = React.useCallback(() => setRetry((v) => v + 1), [])\n\n  const resetFilters = React.useCallback(() => {\n    setModels([])\n    setCustom(defaultCustom())\n    setRange('today')\n  }, [])\n\n  const busy = status === 'loading' || status === 'refreshing'\n  const ready = data !== null\n  const isError = status === 'error'\n  const isEmpty = ready && data.daily.length === 0 && data.byModel.length === 0\n\n  return h(T.Provider, { value: t },\n    h('div', { className: 'tsd-section', 'aria-busy': busy || undefined },\n    h(StatsHeader, { busy, onRefresh: reload }),\n    h(FilterBar, {\n      range,\n      custom,\n      models,\n      customOpen,\n      modelOptions: data ? data.models : [],\n      onPreset: (p) => { setRange(p); setCustomOpen(false) },\n      onCustomOpen: (open) => { setRange('custom'); setCustomOpen(open) },\n      onCustomApply: (c) => { setCustom(c); setCustomOpen(false) },\n      onCustomClose: () => setCustomOpen(false),\n      onModelsChange: setModels,\n    }),\n    isError && !ready\n      ? h(ErrorState, { error, onRetry: reload })\n      : null,\n    !ready && !isError\n      ? h(LoadingState, null)\n      : null,\n    ready && isError\n      ? h('div', { className: 'tsd-alert-banner', role: 'alert' },\n          h('span', null, t('loadFailed', { message: String((error && error.message) || error) })),\n          h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: reload }, t('retry')))\n      : null,\n    ready && !isError && isEmpty\n      ? h(EmptyState, { filtered: models.length > 0, onReset: resetFilters })\n      : null,\n    ready && !isError && !isEmpty\n      ? h('div', { className: 'tsd-content', 'data-busy': busy ? 'true' : undefined },\n          h(SummaryCards, {\n            total: data.total,\n            currency: prices.currency || '¥',\n            unpricedCalls: data.unpricedCalls || 0,\n          }),\n          h(DailyChart, {\n            daily: data.daily,\n            gran: effGran,\n            stepDays,\n            granLabel,\n          }),\n          h(HeatmapCard, { days: data.heatmap || [] }),\n          h(ModelTable, { rows: data.byModel, currency: prices.currency || '¥' }))\n      : null))\n}\n\n/* ---------------------------------------------------------------------------\n * 注册：settings.section 页面\n * ------------------------------------------------------------------------- */\nfunction apply(ctx) {\n  usageCtx = ctx\n  _usagePricesScope = null // 每次激活重绑，避免复用已释放的 scope\n  ctx.effect(() => {\n    if (typeof styles !== 'undefined' && styles && typeof styles.insert === 'function') {\n      return styles.insert(CSS)\n    }\n    if (typeof document !== 'undefined') {\n      const el = document.createElement('style')\n      el.setAttribute('data-plugin', 'dsh-plugin-usage')\n      el.textContent = CSS\n      document.head.appendChild(el)\n      return () => { el.remove() }\n    }\n  }, 'usage: styles')\n  ctx.effect(() => ctx.locale.register(NS, { zh: ZH, en: EN }), 'usage: dictionaries')\n  const t0 = ctx.locale ? ctx.locale.bind(NS) : fallbackT\n  // cordis ctx is a strict proxy: DIRECT property access on an un-injected\n  // service throws (\"cannot get property X without inject\"), so a bare\n  // `ctx.slots ?? ...` would throw and skip the fallback. Probe via the safe\n  // ctx.get() first; fall back to the injected property (available once\n  // 'slots' is declared in the inject list below).\n  let slots = null\n  try {\n    slots = typeof ctx.get === 'function' ? ctx.get('slots') : null\n  } catch (e) {\n    slots = null\n  }\n  if (!slots || typeof slots.inject !== 'function') {\n    try {\n      if (ctx.slots && typeof ctx.slots.inject === 'function') slots = ctx.slots\n    } catch (e) {\n      slots = null\n    }\n  }\n  if (!slots || typeof slots.inject !== 'function' || typeof slots.register !== 'function') {\n    console.warn('[usage] settings.section slot unavailable')\n    return\n  }\n  slots.inject('settings.section', () => slots.register(\n    { name: 'settings.section', id: 'token-stats', order: 20, label: () => t0('nav'), locale: NS },\n    (props) => h(StatsDashboard, props),\n  ))\n}\n\nreturn { inject: ['locale', 'slots'], apply }\n"],"names":[],"mappings":""}