dsh-plugin-usage 0.2.0 → 0.3.0

package/lib/client/index.js

@@ -58,13 +58,13 @@ const CSS = `
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  width: 34px;
-  height: 34px;
+  width: 28px;
+  height: 28px;
   padding: 0;
-  border: 1px solid var(--dsw-alias-border-l2);
-  background: var(--dsw-alias-bg-layer-1);
+  border: 1px solid transparent;
+  background: transparent;
   color: var(--dsw-alias-label-secondary);
-  border-radius: 8px;
+  border-radius: 6px;
   cursor: pointer;
   font: inherit;
 }
@@ -72,6 +72,14 @@ const CSS = `
   color: var(--dsw-alias-label-primary);
   background: var(--dsw-alias-interactive-bg-hover);
 }
+.tsd-icon-btn:disabled {
+  cursor: default;
+  opacity: 0.6;
+}
+.tsd-icon-btn:disabled:hover {
+  color: var(--dsw-alias-label-secondary);
+  background: transparent;
+}
 .tsd-spinning svg {
   animation: tsd-spin 0.9s linear infinite;
 }
@@ -179,9 +187,15 @@ const CSS = `
   box-shadow: var(--dsw-shadow-lv3);
 }
 .tsd-model-popover {
+  box-sizing: border-box;
   width: 320px;
   max-width: calc(100vw - 24px);
 }
+/* 浮层高度由 useFixedPanel 的 maxHeight 决定：只有列表可伸缩，其余部分不压缩 */
+.tsd-model-popover > .tsd-popover-tools,
+.tsd-model-popover > .tsd-search,
+.tsd-model-popover > .tsd-popover-note,
+.tsd-model-popover > .tsd-popover-empty { flex: none; }
 .tsd-range-popover {
   width: 300px;
   max-width: calc(100vw - 24px);
@@ -289,6 +303,8 @@ const CSS = `
 .tsd-model-list {
   display: flex;
   flex-direction: column;
+  flex: 1 1 auto;
+  min-height: 0;
   gap: 2px;
   max-height: 240px;
   overflow-y: auto;
@@ -317,6 +333,150 @@ const CSS = `
   min-width: 0;
 }
 
+/* ============ 币种切换（参考成本卡数值行内） ============ */
+/* 数值行最前只放一个「符号 + 小箭头」的图标式触发器：符号本身就是读数的一部分，
+   尺寸/字重/基线继承数值行，读起来像数字前缀而不是一个控件。
+   符号只在这里画一次，formatCost 不再重复带符号。 */
+.tsd-cur-anchor {
+  position: relative;
+  display: inline-flex;
+}
+.tsd-cur-btn {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 3px;
+  margin: 0 2px 0 0;
+  padding: 0 2px;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  line-height: inherit;
+  vertical-align: baseline;
+  cursor: pointer;
+  transition: color 0.15s ease, background 0.15s ease;
+}
+.tsd-cur-btn:hover,
+.tsd-cur-btn-open {
+  color: var(--dsw-alias-brand-primary);
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+.tsd-cur-btn:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 1px;
+}
+.tsd-cur-chevron {
+  flex: none;
+  align-self: center;
+  transition: transform 0.15s ease;
+}
+.tsd-cur-btn-open .tsd-cur-chevron { transform: rotate(180deg); }
+.tsd-cur-popover {
+  box-sizing: border-box;
+  width: 180px;
+  max-width: calc(100vw - 24px);
+  padding: 6px;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  /* 浮层挂在 .tsd-card-value 里，那边为了数值行写了 nowrap；
+     浮层里的菜单项与说明必须恢复换行，否则长文案会横着溢出浮层。 */
+  white-space: normal;
+}
+.tsd-cur-option {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 7px 9px;
+  border: none;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 13px;
+  text-align: left;
+  cursor: pointer;
+}
+.tsd-cur-option:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.tsd-cur-option:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 1px;
+}
+.tsd-cur-symbol {
+  flex: none;
+  width: 20px;
+  text-align: center;
+  font-weight: 600;
+}
+.tsd-cur-name {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--dsw-alias-label-secondary);
+  font-size: 12px;
+}
+.tsd-cur-option-active { background: var(--dsw-alias-interactive-bg-hover); }
+.tsd-cur-check {
+  margin-left: auto;
+  color: var(--dsw-alias-brand-primary);
+}
+
+/* ============ 模型占比（KPI 卡第 6 格） ============ */
+/* 主体是占比条，下方模型名与百分比压成脚注（11px tertiary），
+   与其它卡的大数字形成层级差，不抢 KPI 的读数位置。 */
+.tsd-card-share-body {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-width: 0;
+  /* 对齐 .tsd-card-value 的上边距，六张卡保持同一基线 */
+  margin-top: 8px;
+}
+.tsd-share-track {
+  display: flex;
+  align-items: stretch;
+  width: 100%;
+  height: 10px;
+  border-radius: 999px;
+  overflow: hidden;
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+.tsd-share-seg {
+  height: 100%;
+  min-width: 2px;
+  outline: none;
+  opacity: 0.9;
+  transition: opacity 0.12s ease;
+}
+.tsd-share-seg:hover,
+.tsd-share-seg:focus-visible,
+.tsd-share-seg[data-active='true'] { opacity: 1; }
+.tsd-share-caption {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  font-size: 11px;
+  line-height: 16px;
+  color: var(--dsw-alias-label-tertiary);
+}
+.tsd-share-cap-name {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.tsd-share-cap-pct {
+  flex: none;
+  font-variant-numeric: tabular-nums;
+}
+.tsd-share-empty {
+  font-size: 14px;
+  font-weight: 400;
+  color: var(--dsw-alias-label-tertiary);
+}
+
 /* ============ 自定义日期浮层 ============ */
 .tsd-range-fields {
   display: flex;
@@ -975,8 +1135,35 @@ const CSS = `
 }
 `
 
+// 0.2+ host transport: POST /api/<channel>/<endpoint>, args as the JSON body,
+// answering { ok, value } | { ok, error } (see src/host/rpc.js). The route is
+// mounted on Connection's shared API channel, so it never needs the plugin's
+// fiber to own `webServer`.
+function callFetch(channel, endpoint, args) {
+  const path = '/api/' + String(channel).replace(/^\/+/, '') + '/' + endpoint
+  return fetch(path, {
+    method: 'POST',
+    credentials: 'same-origin',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(args === undefined ? null : args),
+  }).then((res) => {
+    const type = res.headers.get('content-type') || ''
+    // Route missing on this host: 404/405 from the shared dispatcher, or the
+    // SPA HTML when no transport route matched the path at all.
+    if (res.status === 404 || res.status === 405 || type.indexOf('application/json') === -1) {
+      const error = new Error('usage Fetch route unavailable (HTTP ' + res.status + ')')
+      error.code = 'usage-route-missing'
+      throw error
+    }
+    return res.json().then((body) => {
+      if (body && body.ok) return body.value
+      throw new Error((body && body.error && body.error.message) || ('RPC ' + endpoint + ' failed'))
+    })
+  })
+}
+
 // RPC bridge: dynamic-plugin runs provide a `host` global; static (bundle)
-// installs provide ctx.get('connection').rpc. Keep one UI source for both.
+// installs provide ctx.get('connection'). 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.
@@ -1015,23 +1202,36 @@ function hostCall(method, args) {
   if (scope === null || typeof scope.get !== 'function') {
     return Promise.reject(new Error('context unavailable'))
   }
-  const connection = scope.get('connection')
-  if (connection === undefined || connection.rpc === undefined) {
-    return Promise.reject(new Error('connection service unavailable'))
-  }
   const name = String(method)
   const slash = name.indexOf('/')
   const channel = slash === -1 ? name : name.slice(0, slash)
   const endpoint = slash === -1 ? name : name.slice(slash + 1)
-  return connection.rpc.call('/' + channel.replace(/^\/+/, ''), endpoint, args).then((res) => {
-    if (res && res.ok) return res.value
-    throw new Error((res && res.error && res.error.message) || ('RPC ' + method + ' failed'))
+  // Legacy pre-0.2 transport: a `/usage` prefix RPC channel owned by the host
+  // plugin itself.
+  const callRpc = () => {
+    const connection = scope.get('connection')
+    if (connection === undefined || connection.rpc === undefined) {
+      return Promise.reject(new Error('connection service unavailable'))
+    }
+    return connection.rpc.call('/' + channel.replace(/^\/+/, ''), endpoint, args).then((res) => {
+      if (res && res.ok) return res.value
+      throw new Error((res && res.error && res.error.message) || ('RPC ' + method + ' failed'))
+    })
+  }
+  // Prefer the shared-channel Fetch route; an older host answers "route
+  // missing" and we fall back to the legacy channel it does implement.
+  const fetchUsable = typeof fetch === 'function'
+    && !(typeof location !== 'undefined' && location.protocol === 'file:')
+  if (!fetchUsable) return callRpc()
+  return callFetch(channel, endpoint, args).catch((error) => {
+    if (error && error.code === 'usage-route-missing') return callRpc()
+    throw error
   })
 }
 
 /* ---------------------------------------------------------------------------
- * 设置域定价：官方 ctx.settingsScope（dsh-client-ui-settings）优先，
- * 不可用时回退 usage/prices RPC。绑定只做一次，读写共用同一 scope。
+ * 设置域定价：官方 `ctx.configForms.get('usage')`（dsh-client-ui-settings）优先，
+ * 不可用时回退 usage/prices RPC。绑定只做一次，读写共用同一 form。
  * ------------------------------------------------------------------------- */
 let usageCtx = null
 let _usagePricesScope = null
@@ -1047,9 +1247,12 @@ function getUsagePricesScope() {
   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' })
+    // 0.2.x: the official config-form surface for this plugin's entry id
+    // (`usage`, the bundle patch row id). `settingsScope` from 0.1.x does not
+    // exist in the shipped client, so probing it only ever returned null.
+    const forms = c.get('configForms')
+    if (!forms || typeof forms.get !== 'function') return null
+    _usagePricesScope = forms.get('usage')
     return _usagePricesScope
   } catch (e) {
     return null
@@ -1094,10 +1297,14 @@ const ZH = {
   nav: '用量统计',
   subtitle: '查看 AI 模型的使用情况和成本统计',
   refresh: '刷新',
+  currencyHint: '参考成本币种（固定汇率 1 USD = 7 CNY）',
+  currencyCNY: '人民币',
+  currencyUSD: '美元',
   today: '今日',
   last7d: '近7天',
   last30d: '近30天',
   custom: '自定义',
+  all: '全部',
   allModels: '全部模型',
   selectedModels: '已选 {count} 个模型',
   selectAll: '全选',
@@ -1110,7 +1317,7 @@ const ZH = {
   startTime: '开始时间',
   endTime: '结束时间',
   rangeInvalid: '开始时间不能晚于结束时间',
-  rangeHint: '支持选择日期，最长 30 天',
+  rangeHint: '支持选择任意日期范围，不限跨度',
   cancel: '取消',
   confirm: '确定',
   dateRangeGroup: '日期范围',
@@ -1120,7 +1327,7 @@ const ZH = {
   inputTokens: '输入 Token',
   outputTokens: '输出 Token',
   calls: '调用次数',
-  cost: '成本',
+  cost: '参考成本',
   approxIO: '≈ 输入+输出',
   unpricedNote: '{count} 次调用未定价',
   dailyTrend: '每日用量趋势',
@@ -1151,8 +1358,10 @@ const ZH = {
   colInput: '输入 Token',
   colOutput: '输出 Token',
   colTotal: '总 Token',
-  colCost: '成本',
+  colCost: '参考成本',
   colShare: '占比',
+  modelShare: '模型占比',
+  shareOther: '其它',
   unpriced: '未定价',
   unpricedRowHint: '该模型未配置定价，按 0 计价',
   noData: '暂无数据',
@@ -1177,10 +1386,14 @@ const EN = {
   nav: 'Usage Stats',
   subtitle: 'View AI model usage and cost statistics',
   refresh: 'Refresh',
+  currencyHint: 'Reference-cost currency (fixed rate: 1 USD = 7 CNY)',
+  currencyCNY: 'CNY',
+  currencyUSD: 'USD',
   today: 'Today',
   last7d: 'Last 7 days',
   last30d: 'Last 30 days',
   custom: 'Custom',
+  all: 'All',
   allModels: 'All models',
   selectedModels: '{count} models selected',
   selectAll: 'Select all',
@@ -1193,7 +1406,7 @@ const EN = {
   startTime: 'Start',
   endTime: 'End',
   rangeInvalid: 'Start must not be later than end',
-  rangeHint: 'Date only, up to 30 days',
+  rangeHint: 'Any date range — no length limit',
   cancel: 'Cancel',
   confirm: 'OK',
   dateRangeGroup: 'Date range',
@@ -1203,7 +1416,7 @@ const EN = {
   inputTokens: 'Input Tokens',
   outputTokens: 'Output Tokens',
   calls: 'Calls',
-  cost: 'Cost',
+  cost: 'Est. cost',
   approxIO: '≈ input+output',
   unpricedNote: '{count} calls unpriced',
   dailyTrend: 'Daily usage trend',
@@ -1234,8 +1447,10 @@ const EN = {
   colInput: 'Input Tokens',
   colOutput: 'Output Tokens',
   colTotal: 'Total Tokens',
-  colCost: 'Cost',
+  colCost: 'Est. cost',
   colShare: 'Share',
+  modelShare: 'Model share',
+  shareOther: 'Others',
   unpriced: 'Unpriced',
   unpricedRowHint: 'No pricing configured; counted as 0',
   noData: 'No data',
@@ -1281,9 +1496,16 @@ function formatTokensShort(n) {
 function formatInt(n) {
   return Number.isFinite(n) ? Math.round(n).toLocaleString() : '--'
 }
-function formatCost(n, cur) {
+/** 只要数字部分：成本卡的符号由币种切换器自己画，再带一次就成了「¥ ¥14.78」。 */
+function costDigits(n) {
   if (!Number.isFinite(n)) return '--'
-  return (cur || '¥') + n.toFixed(2)
+  // Below half a cent there is nothing to show at 2 decimals; say so instead of
+  // printing a misleading 0.00 (a $0.03 CNY cost becomes $0.004).
+  if (n > 0 && n < 0.005) return '<0.01'
+  return n.toFixed(2)
+}
+function formatCost(n, cur) {
+  return (cur || '¥') + costDigits(n)
 }
 function dayLabel(key) {
   const [, m, d] = String(key || '').split('-')
@@ -1322,13 +1544,17 @@ function fmtDateSlash(s) {
   return m[1] + '/' + m[2] + '/' + m[3]
 }
 // 预设 / 自定义 → { from, to }（Unix 毫秒）
-// 今日 = 当天 00:00 至今；近7/30天 = 含今天往前 N 个自然日 00:00 起；自定义 = 起日 00:00 ~ 止日 23:59:59.999
+// 今日 = 当天 00:00 至今；近7/30天 = 含今天往前 N 个自然日 00:00 起；全部 = 不限起点；
+// 自定义 = 起日 00:00 ~ 止日 23:59:59.999
 function rangeFor(preset, custom) {
   const now = new Date()
   const today = startOfDay(now)
   if (preset === 'today') return { from: today.getTime(), to: now.getTime() }
   if (preset === '7d') return { from: addDays(today, -6).getTime(), to: now.getTime() }
   if (preset === '30d') return { from: addDays(today, -29).getTime(), to: now.getTime() }
+  // 全量：0 是有限值，宿主的 fill 判定认它；调用方必须同时传 fill:false，
+  // 否则会去零填充 1970 年至今、撞上 MAX_BUCKETS 退化成只看有数据的桶。
+  if (preset === 'all') return { from: 0, to: now.getTime() }
   const from = new Date(custom.from + 'T00:00:00').getTime()
   const to = new Date(custom.to + 'T23:59:59.999').getTime()
   if (!Number.isFinite(from) || !Number.isFinite(to)) {
@@ -1405,26 +1631,44 @@ const ICON_PATHS = {
   up: 'M12 21V9m0 0l-4.5 4.5M12 9l4.5 4.5M4 3h16',
   activity: 'M2 12h4l2.5-8 5 16 2.5-8h6',
   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',
-  refresh: 'M21 12a9 9 0 11-2.64-6.36M21 4v6h-6',
+  // 刷新图标取自 DSH 原生图形（16 网格、stroke 1.5），与设置页其它图标同一观感；
+  // 其余图标仍是 24 网格（stroke 2），SvgIcon 两种定义都吃。
+  refresh: {
+    viewBox: '0 0 16 16',
+    strokeWidth: 1.5,
+    paths: [
+      'M14.5001 8C14.5 9.28552 14.1188 10.5422 13.4045 11.611C12.6903 12.6799 11.6752 13.5129 10.4875 14.0049C9.29982 14.4968 7.99295 14.6255 6.73212 14.3747C5.4713 14.124 4.31314 13.505 3.4041 12.596C2.49514 11.687 1.87614 10.5288 1.62537 9.26798C1.37459 8.00716 1.50331 6.70028 1.99525 5.51261C2.48719 4.32494 3.32025 3.30981 4.3891 2.59557C5.45795 1.88134 6.71458 1.50008 8.0001 1.5C9.9001 1.5 11.7001 2.3 13.0001 3.6L14.5001 5.1',
+      'M14.4999 1.5V5.1H10.8999',
+    ],
+  },
   chevron: 'M6 9l6 6 6-6',
   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',
   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',
   search: 'M21 21l-4.35-4.35M17 10.5a6.5 6.5 0 11-13 0 6.5 6.5 0 0113 0z',
+  // 饼图（占比）：外圈 + 楔形，与卡片标题的「占比」语义一致
+  share: 'M21.21 15.89A10 10 0 118 2.83M22 12A10 10 0 0012 2v10z',
+  check: 'M20 6L9 17l-5-5',
 }
 function SvgIcon(props) {
   const { name, size, className } = props
+  // 一个名字对应「一串 path + 自己的 viewBox/线宽」；字符串是 24 网格的简写，
+  // 调用方（31 处）无需关心差别。
+  const spec = ICON_PATHS[name] || ICON_PATHS.activity
+  const icon = typeof spec === 'string'
+    ? { viewBox: '0 0 24 24', strokeWidth: 2, paths: [spec] }
+    : spec
   return h('svg', {
     className: className || 'tsd-icon',
     width: size || 16,
     height: size || 16,
-    viewBox: '0 0 24 24',
+    viewBox: icon.viewBox || '0 0 24 24',
     fill: 'none',
     stroke: 'currentColor',
-    strokeWidth: 2,
+    strokeWidth: icon.strokeWidth || 2,
     strokeLinecap: 'round',
     strokeLinejoin: 'round',
     'aria-hidden': true,
-  }, h('path', { d: ICON_PATHS[name] || ICON_PATHS.activity }))
+  }, icon.paths.map((d, i) => h('path', { key: i, d })))
 }
 
 /* ---------------------------------------------------------------------------
@@ -1441,6 +1685,58 @@ function useOutsideClick(open, ref, onClose) {
   }, [open, onClose, ref])
 }
 
+/* ---------------------------------------------------------------------------
+ * 通用 Hook：浮层定位（viewport 定位 + 空间不足上翻 + 高度封顶）
+ *
+ * 设置面板本身是 `overflow: hidden` 的裁剪容器，贴着过滤栏右端的 absolute
+ * 浮层会被整条裁掉（右侧的「清空」看不见）。CSS 无法感知祖先裁剪，只能量一次
+ * 视口再定位；滚动或缩放时重算，避免浮层留在原地。
+ * ------------------------------------------------------------------------- */
+const PANEL_MIN_ROOM = 240 // 下方空间小于它且上方更宽裕时上翻
+const PANEL_MIN_HEIGHT = 160
+
+function useFixedPanel(anchorRef, open, width, gap = 6, margin = 12) {
+  const [style, setStyle] = React.useState(null)
+  React.useEffect(() => {
+    if (!open) {
+      setStyle(null)
+      return undefined
+    }
+    function measure() {
+      const el = anchorRef.current
+      if (!el) return
+      const r = el.getBoundingClientRect()
+      const boxW = Math.min(width, window.innerWidth - margin * 2)
+      const left = Math.max(margin, Math.min(r.left, window.innerWidth - margin - boxW))
+      const below = window.innerHeight - r.bottom - gap - margin
+      const above = r.top - gap - margin
+      const flip = below < PANEL_MIN_ROOM && above > below
+      setStyle({
+        position: 'fixed',
+        left,
+        width: boxW,
+        maxHeight: Math.max(PANEL_MIN_HEIGHT, flip ? above : below),
+        ...(flip
+          ? { bottom: window.innerHeight - r.top + gap }
+          : { top: r.bottom + gap }),
+        display: 'flex',
+        flexDirection: 'column',
+        zIndex: 40,
+      })
+    }
+    measure()
+    window.addEventListener('resize', measure)
+    window.addEventListener('scroll', measure, true)
+    return () => {
+      window.removeEventListener('resize', measure)
+      window.removeEventListener('scroll', measure, true)
+    }
+  }, [open, anchorRef, width, gap, margin])
+  if (!open) return null
+  // 首帧还没量到尺寸：先藏起来，否则会闪到左上角
+  return style || { position: 'fixed', top: 0, left: 0, visibility: 'hidden' }
+}
+
 /* ---------------------------------------------------------------------------
  * Header：标题 + 副标题 + 刷新按钮
  * ------------------------------------------------------------------------- */
@@ -1455,6 +1751,8 @@ function StatsHeader(props) {
       type: 'button',
       className: 'tsd-icon-btn' + (busy ? ' tsd-spinning' : ''),
       onClick: onRefresh,
+      disabled: busy,
+      'aria-busy': busy || undefined,
       title: t('refresh'),
       'aria-label': t('refresh'),
     }, h(SvgIcon, { name: 'refresh' })))
@@ -1464,8 +1762,9 @@ function StatsHeader(props) {
  * 自定义日期范围浮层
  * ------------------------------------------------------------------------- */
 function CustomRangePopover(props) {
-  const { custom, onApply, onClose } = props
+  const { custom, onApply, onClose, anchorRef } = props
   const t = useT()
+  const panelStyle = useFixedPanel(anchorRef, true, 300)
   const [from, setFrom] = React.useState(custom.from)
   const [to, setTo] = React.useState(custom.to)
   const invalid = !from || !to || from > to
@@ -1479,6 +1778,7 @@ function CustomRangePopover(props) {
   }, [onClose])
   return h('div', {
     className: 'tsd-popover tsd-range-popover',
+    style: panelStyle,
     role: 'dialog',
     'aria-label': t('customRangeAria'),
   },
@@ -1518,6 +1818,7 @@ function ModelDropdown(props) {
   const [open, setOpen] = React.useState(false)
   const [query, setQuery] = React.useState('')
   const anchorRef = React.useRef(null)
+  const panelStyle = useFixedPanel(anchorRef, open, 320)
 
   React.useEffect(() => {
     if (!open) return undefined
@@ -1536,8 +1837,10 @@ function ModelDropdown(props) {
   }, [open])
 
   // 只列出当前范围有数据的模型；已选但掉出候选列表的「补回」，保证可渲染、可清除
+  // 候选键直接用宿主给好的 `key`（compositeModelKey 的结果）：客户端不再自己拼
+  // `provider + '/' + model`，provider 为空时那种拼法会得到 `/model` 而永远选不中。
   const candidates = React.useMemo(() => {
-    const set = new Set((options || []).map((m) => m.provider + '/' + m.model))
+    const set = new Set((options || []).map((m) => m.key || (m.provider ? m.provider + '/' + m.model : m.model)))
     ;(selected || []).forEach((m) => set.add(m))
     const list = Array.from(set)
     list.sort()
@@ -1562,6 +1865,7 @@ function ModelDropdown(props) {
     open
       ? h('div', {
           className: 'tsd-popover tsd-model-popover',
+          style: panelStyle,
           role: 'listbox',
           'aria-label': t('modelFilterGroup'),
           'aria-multiselectable': true,
@@ -1611,6 +1915,7 @@ function FilterBar(props) {
   } = props
   const t = useT()
   const segRef = React.useRef(null)
+  const customBtnRef = React.useRef(null)
   useOutsideClick(customOpen, segRef, onCustomClose)
 
   const customLabel = fmtDateSlash(custom.from) + ' - ' + fmtDateSlash(custom.to)
@@ -1618,6 +1923,7 @@ function FilterBar(props) {
     { key: 'today', label: t('today') },
     { key: '7d', label: t('last7d') },
     { key: '30d', label: t('last30d') },
+    { key: 'all', label: t('all') },
     { key: 'custom', label: t('custom') },
   ]
 
@@ -1631,6 +1937,7 @@ function FilterBar(props) {
           return h('button', {
             key: p.key,
             type: 'button',
+            ref: isCustom ? customBtnRef : undefined,
             className: 'tsd-seg-btn' + (active ? ' tsd-seg-active' : '') + (isCustom ? ' tsd-seg-custom' : ''),
             'aria-pressed': active,
             title: isCustom && active ? customLabel : undefined,
@@ -1638,15 +1945,232 @@ function FilterBar(props) {
           },
             h('span', { className: 'tsd-seg-label' }, label))
         })),
-      customOpen ? h(CustomRangePopover, { custom, onApply: onCustomApply, onClose: onCustomClose }) : null),
+      customOpen
+        ? h(CustomRangePopover, { custom, onApply: onCustomApply, onClose: onCustomClose, anchorRef: customBtnRef })
+        : null),
     h(ModelDropdown, { options: modelOptions, selected: models, onChange: onModelsChange }))
 }
 
 /* ---------------------------------------------------------------------------
- * 汇总指标卡 ×5
+ * 参考成本币种切换（人民币 / 美元，固定 1 USD = 7 CNY）
+ *
+ * 换算在宿主侧完成（价目表是美元价，绝不回写），所以这里只负责选择与持久化：
+ * 换币种即换查询，不重查数字不会变。
+ * ------------------------------------------------------------------------- */
+const CURRENCY_SYMBOLS = { CNY: '¥', USD: '$' }
+const CURRENCY_STORE_KEY = 'dsh-plugin-usage:display-currency'
+
+function readStoredCurrency() {
+  try {
+    return window.localStorage.getItem(CURRENCY_STORE_KEY) === 'USD' ? 'USD' : 'CNY'
+  } catch (e) {
+    return 'CNY' // 无痕模式 / 存储被禁：退回默认
+  }
+}
+function storeCurrency(code) {
+  try {
+    window.localStorage.setItem(CURRENCY_STORE_KEY, code)
+  } catch (e) {
+    // 存不下就只影响下次打开，不影响本次显示
+  }
+}
+
+function CurrencyPicker(props) {
+  const { code, onChange } = props
+  const t = useT()
+  const [open, setOpen] = React.useState(false)
+  const ref = React.useRef(null)
+  const panelStyle = useFixedPanel(ref, open, 180)
+  useOutsideClick(open, ref, () => setOpen(false))
+  const active = CURRENCY_SYMBOLS[code] ? code : 'CNY'
+  const options = ['CNY', 'USD']
+  // 收起时 ↑↓ 直接换值（像原生 select），展开时在两项间移动；Esc 关菜单。
+  const move = (step) => {
+    const i = options.indexOf(active)
+    onChange(options[(i + step + options.length) % options.length])
+  }
+  const onKeyDown = (e) => {
+    if (e.key === 'Escape') { setOpen(false); return }
+    if (!open) {
+      if (e.key === 'ArrowDown' || e.key === 'ArrowUp') { e.preventDefault(); move(e.key === 'ArrowDown' ? 1 : -1); return }
+      if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); setOpen(true) }
+      return
+    }
+    if (e.key === 'ArrowDown') { e.preventDefault(); move(1) }
+    else if (e.key === 'ArrowUp') { e.preventDefault(); move(-1) }
+  }
+  return h('span', { className: 'tsd-cur-anchor', ref },
+    h('button', {
+      type: 'button',
+      className: 'tsd-cur-btn' + (open ? ' tsd-cur-btn-open' : ''),
+      title: t('currencyHint'),
+      'aria-label': t('currencyHint'),
+      'aria-haspopup': 'listbox',
+      'aria-expanded': open,
+      onClick: () => setOpen((v) => !v),
+      onKeyDown,
+    },
+      h('span', null, CURRENCY_SYMBOLS[active]),
+      h(SvgIcon, { name: 'chevron', size: 10, className: 'tsd-cur-chevron' })),
+    open
+      ? h('div', {
+          className: 'tsd-popover tsd-cur-popover',
+          style: panelStyle,
+          role: 'listbox',
+          'aria-label': t('currencyHint'),
+          onKeyDown,
+        },
+        options.map((c) => h('button', {
+          key: c,
+          type: 'button',
+          role: 'option',
+          'aria-selected': c === active,
+          className: 'tsd-cur-option' + (c === active ? ' tsd-cur-option-active' : ''),
+          onClick: () => { onChange(c); setOpen(false) },
+        },
+          h('span', { className: 'tsd-cur-symbol' }, CURRENCY_SYMBOLS[c]),
+          h('span', { className: 'tsd-cur-name' }, t(c === 'CNY' ? 'currencyCNY' : 'currencyUSD')),
+          c === active ? h(SvgIcon, { name: 'check', size: 12, className: 'tsd-cur-check' }) : null)),
+        h('div', { className: 'tsd-popover-note' }, t('currencyHint')))
+      : null)
+}
+
+/* ---------------------------------------------------------------------------
+ * 模型占比（KPI 网格里的第 6 格）
+ *
+ * 数据直接吃宿主 `byModel` 的行（与「按模型明细」表同一份），不另算一遍。
+ * 明细放在各段的原生 title 上而不是浮层：KPI 卡贴着设置面板的裁剪边界，
+ * 再叠一层浮层只会把之前修好的裁剪问题带回来。
+ * ------------------------------------------------------------------------- */
+const SHARE_COLORS = [
+  // 只用主题里真实存在、且彼此分得开的彩色族：深蓝、绿、琥珀、红。
+  // 不用 neutral / 白 / 黑 —— 它们在深浅两套主题里一边会糊进背景，一边会被读成禁用态。
+  'var(--dsw-static-deepseek-500)',
+  'var(--dsw-static-green-500)',
+  'var(--dsw-static-amber-500)',
+  'var(--dsw-static-red-400)',
+]
+const SHARE_TOP = 4
+const SHARE_REST_KEY = '__rest__'
+
+/** `provider/model` → 裸模型名；色带格位放不下全名，全名留给 title 与 aria。 */
+function shortModelName(key) {
+  const s = String(key == null ? '' : key)
+  const i = s.lastIndexOf('/')
+  return i === -1 ? s : s.slice(i + 1)
+}
+/** 宿主行是 `totalTokens`；兼容已映射成 `total` 的形状，空行也不能抛。 */
+function rowTotal(r) {
+  return r ? (r.totalTokens || r.total || 0) : 0
+}
+/** 降序取前 4 段，其余并成「其它」；无数据时返回空段。 */
+function shareSegments(rows) {
+  const list = (rows || []).slice().sort((a, b) => rowTotal(b) - rowTotal(a))
+  const total = list.reduce((s, r) => s + rowTotal(r), 0)
+  if (total <= 0) return { total: 0, segs: [] }
+  const numbers = (r) => ({
+    tokens: rowTotal(r),
+    calls: r.calls || 0,
+    // 与明细表同一口径：输入含缓存读写
+    input: (r.inputTokens || 0) + (r.cacheReadTokens || 0) + (r.cacheWriteTokens || 0),
+    output: r.outputTokens || 0,
+    cost: r.cost || 0,
+  })
+  const segs = list.slice(0, SHARE_TOP).map((r, i) => Object.assign({
+    key: String(r.key),
+    label: shortModelName(r.key),
+    pct: rowTotal(r) / total,
+    color: SHARE_COLORS[i % SHARE_COLORS.length],
+  }, numbers(r)))
+  const restRows = list.slice(SHARE_TOP)
+  const restTokens = restRows.reduce((s, r) => s + rowTotal(r), 0)
+  if (restTokens > 0) {
+    const agg = restRows.reduce((a, r) => {
+      const n = numbers(r)
+      return {
+        tokens: a.tokens + n.tokens,
+        calls: a.calls + n.calls,
+        input: a.input + n.input,
+        output: a.output + n.output,
+        cost: a.cost + n.cost,
+      }
+    }, { tokens: 0, calls: 0, input: 0, output: 0, cost: 0 })
+    segs.push(Object.assign({
+      key: SHARE_REST_KEY,
+      label: null, // 「其它」的文案由渲染层取词典
+      pct: restTokens / total,
+      // 「其它」用同色系的淡色（浅蓝），不用灰/白：那两种在深色卡片上会被读成禁用
+      color: 'var(--dsw-static-deepseek-300)',
+    }, agg))
+  }
+  return { total, segs }
+}
+
+function ModelShareBar(props) {
+  const { rows, currency } = props
+  const t = useT()
+  const [tip, setTip] = React.useState(null) // { key, left, top } in viewport coords
+  const occ = shareSegments(rows)
+  if (occ.total <= 0) return h('div', { className: 'tsd-card-value tsd-share-empty' }, t('noData'))
+  const find = (key) => occ.segs.filter((s) => s.key === key)[0] || null
+  const shown = (tip && find(tip.key)) || occ.segs[0]
+  const labelOf = (s) => (s.key === SHARE_REST_KEY ? t('shareOther') : s.label)
+  const fullOf = (s) => (s.key === SHARE_REST_KEY ? t('shareOther') : s.key)
+  const costOf = (s) => (s.tokens > 0 && !(s.cost > 0) ? t('unpriced') : formatCost(s.cost, currency))
+  // 悬停/聚焦：从段的视口矩形推开，fixed 定位不受设置面板 overflow 裁剪
+  const showTip = (e, s) => {
+    const r = e.currentTarget.getBoundingClientRect()
+    setTip({ key: s.key, left: r.left + r.width / 2, top: r.top })
+  }
+  const hideTip = () => setTip(null)
+  const tipBox = shown && tip
+    ? h('div', {
+        className: 'tsd-tooltip tsd-share-tip',
+        style: { position: 'fixed', left: tip.left + 'px', top: tip.top + 'px', transform: 'translate(-50%, -110%)' },
+      },
+        h('div', { className: 'tsd-tooltip-date' }, fullOf(shown)),
+        h('div', { className: 'tsd-tooltip-row' },
+          h('span', { className: 'tsd-tooltip-dot', style: { background: shown.color } }),
+          h('span', null, t('totalTokens')),
+          h('span', { className: 'tsd-tooltip-val' }, formatInt(shown.tokens))),
+        h('div', { className: 'tsd-tooltip-row' },
+          h('span', null, t('legendInput')),
+          h('span', { className: 'tsd-tooltip-val' }, formatInt(shown.input))),
+        h('div', { className: 'tsd-tooltip-row' },
+          h('span', null, t('legendOutput')),
+          h('span', { className: 'tsd-tooltip-val' }, formatInt(shown.output))),
+        h('div', { className: 'tsd-tooltip-row' },
+          h('span', null, t('cost')),
+          h('span', { className: 'tsd-tooltip-val' }, costOf(shown))))
+    : null
+  return h('div', { className: 'tsd-card-share-body' },
+    h('div', { className: 'tsd-share-track', onMouseLeave: hideTip },
+      occ.segs.map((s) => h('div', {
+        key: s.key,
+        className: 'tsd-share-seg',
+        'data-share-key': s.key,
+        'data-active': shown && shown.key === s.key ? 'true' : undefined,
+        style: { width: s.pct * 100 + '%', background: s.color },
+        role: 'img',
+        tabIndex: 0,
+        'aria-label': fullOf(s) + ' · ' + fmtPct(s.pct) + ' · ' + formatInt(s.tokens) + ' ' + t('totalTokens'),
+        onMouseEnter: (e) => showTip(e, s),
+        onFocus: (e) => showTip(e, s),
+        onBlur: hideTip,
+      }))),
+    // 条下只留一行低调脚注（当前悬浮的那段，否则最大的那段）；
+    // 全名与明细都在悬浮卡片里，所以这里不挂 title。
+    h('div', { className: 'tsd-share-caption' },
+      h('span', { className: 'tsd-share-cap-name' }, labelOf(shown)),
+      h('span', { className: 'tsd-share-cap-pct' }, fmtPct(shown.pct))),
+    tipBox)
+}
+
+/* ---------------------------------------------------------------------------
+ * 汇总指标卡 ×6
  * ------------------------------------------------------------------------- */
 function SummaryCards(props) {
-  const { total, currency, unpricedCalls } = props
+  const { total, currency, unpricedCalls, currencyCode, onCurrencyChange, byModel } = props
   const tt = useT()
   const d = total || {}
   const inputTotal = (d.inputTokens || 0) + (d.cacheReadTokens || 0) + (d.cacheWriteTokens || 0)
@@ -1673,8 +2197,15 @@ function SummaryCards(props) {
     },
     {
       key: 'cost', icon: 'coins', label: tt('cost'),
-      value: formatCost(d.cost, currency), title: formatCost(d.cost, currency),
+      // 符号由 prefix 的币种切换器画（它显示当前币种符号），这里只给数字
+      value: costDigits(d.cost), title: formatCost(d.cost, currency),
       color: 'var(--dsw-static-green-500)',
+      prefix: h(CurrencyPicker, { code: currencyCode, onChange: onCurrencyChange }),
+    },
+    {
+      key: 'share', icon: 'share', label: tt('modelShare'),
+      color: 'var(--dsw-alias-brand-primary)',
+      content: h(ModelShareBar, { rows: byModel, currency }),
     },
   ]
   return h('div', { className: 'tsd-cards' },
@@ -1684,7 +2215,9 @@ function SummaryCards(props) {
           h('span', { className: 'tsd-card-icon', style: { color: c.color } },
             h(SvgIcon, { name: c.icon, size: 14 })),
           h('span', { className: 'tsd-card-label' }, c.label)),
-        h('div', { className: 'tsd-card-value', title: c.title }, c.value),
+        c.content
+          ? c.content
+          : h('div', { className: 'tsd-card-value', title: c.title }, c.prefix || null, c.value),
         c.sub ? h('div', { className: 'tsd-card-sub' }, c.sub) : null,
         c.key === 'cost' && unpricedCalls > 0
           ? h('div', { className: 'tsd-card-note' }, tt('unpricedNote', { count: formatInt(unpricedCalls) }))
@@ -2224,6 +2757,9 @@ function StatsDashboard(props) {
   const [data, setData] = React.useState(null)
   const [error, setError] = React.useState(null)
   const [prices, setPrices] = React.useState({ prices: {}, currency: '¥' })
+  // 展示币种：宿主按它换算成本，所以换币种必须重查；选择记在本地（展示偏好，
+  // 不写插件设置，免得每次取数都在改写用户配置）。
+  const [displayCurrency, setDisplayCurrency] = React.useState(readStoredCurrency)
   // P1-6 backfill 轮询状态：queryKey 变化时重置，仅对同一查询串轮询
   const queryKeyRef = React.useRef(null)
   const backfillSeenRef = React.useRef(false)
@@ -2241,7 +2777,7 @@ function StatsDashboard(props) {
   React.useEffect(() => {
     let current = true
     let backfillTimer = null
-    const queryKey = eff.from + '|' + eff.to + '|' + models.join(',') + '|' + effGran + '|' + stepDays
+    const queryKey = eff.from + '|' + eff.to + '|' + models.join(',') + '|' + effGran + '|' + stepDays + '|' + displayCurrency
     if (queryKeyRef.current !== queryKey) {
       queryKeyRef.current = queryKey
       backfillSeenRef.current = false
@@ -2254,10 +2790,12 @@ function StatsDashboard(props) {
       from: eff.from,
       to: eff.to,
       models: models.slice(),
-      fill: true,
+      // 「全部」不做零填充：真实边界是输出桶数（宿主 MAX_BUCKETS），不是天数。
+      fill: range !== 'all',
       granularity: effGran,
       stepDays,
       heatmap: true,
+      currency: displayCurrency,
     })
       .then((r) => {
         if (!current) return
@@ -2285,7 +2823,7 @@ function StatsDashboard(props) {
       current = false
       if (backfillTimer !== null) clearTimeout(backfillTimer)
     }
-  }, [eff.from, eff.to, models, effGran, stepDays, retry])
+  }, [eff.from, eff.to, models, effGran, stepDays, displayCurrency, retry])
 
   // 价格表：进入页面拉一次 + 每次刷新同步。
   // P0-1：优先官方 settings scope（usage.prices 命名空间），不可用时回退 RPC。
@@ -2336,6 +2874,15 @@ function StatsDashboard(props) {
     setRange('today')
   }, [])
 
+  const changeCurrency = React.useCallback((code) => {
+    storeCurrency(code)
+    setDisplayCurrency(code)
+  }, [])
+  // 符号以宿主回传的实际币种为准（切换后立刻重查，不会出现「换了标志没换数字」）；
+  // 老宿主没有该字段时按本地选择兜底。
+  const currencySymbol = (data && data.currency && data.currency.symbol)
+    || CURRENCY_SYMBOLS[displayCurrency] || prices.currency || '¥'
+
   const busy = status === 'loading' || status === 'refreshing'
   const ready = data !== null
   const isError = status === 'error'
@@ -2374,8 +2921,11 @@ function StatsDashboard(props) {
       ? h('div', { className: 'tsd-content', 'data-busy': busy ? 'true' : undefined },
           h(SummaryCards, {
             total: data.total,
-            currency: prices.currency || '¥',
+            currency: currencySymbol,
             unpricedCalls: data.unpricedCalls || 0,
+            currencyCode: displayCurrency,
+            onCurrencyChange: changeCurrency,
+            byModel: data.byModel,
           }),
           h(DailyChart, {
             daily: data.daily,
@@ -2384,10 +2934,86 @@ function StatsDashboard(props) {
             granLabel,
           }),
           h(HeatmapCard, { days: data.heatmap || [] }),
-          h(ModelTable, { rows: data.byModel, currency: prices.currency || '¥' }))
+          h(ModelTable, { rows: data.byModel, currency: currencySymbol }))
       : null))
 }
 
+/* ---------------------------------------------------------------------------
+ * 设置页导航图标
+ *
+ * `settings.section` 只投影 id/order/label，导航图标由设置页按 id 白名单自己
+ * 决定（dsh-client-ui-settings-general 的 navIcon），第三方没有插口。所以这里
+ * 给「自己那一行」打一个属性标记，再用 CSS mask 把兜底的齿轮换成用量图标：
+ * 不替换节点、不碰 React 管的 svg（替换会让 React 卸载时抛 NotFoundError），
+ * 只加属性、只用 ::before 画字形。
+ *
+ * 认行只能按可见文本：类名是 CSS Modules 哈希，账号行还会条件出现。
+ * 官方一旦给 settings.section 加上 icon 字段，这个模块应整体删除。
+ * ------------------------------------------------------------------------- */
+const NAV_ICON_MASK = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(
+  '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16">'
+  + '<rect x="2.5" y="9" width="2.5" height="5" rx="1"/>'
+  + '<rect x="6.75" y="5.5" width="2.5" height="8.5" rx="1"/>'
+  + '<rect x="11" y="2.5" width="2.5" height="11.5" rx="1"/></svg>',
+)
+// mask 只读 alpha 通道，所以字形必须是纯色实心（icon.svg 的渐变与半透明在这里会丢）
+const NAV_ICON_CSS = [
+  '[data-tsd-nav] > svg { display: none; }',
+  '[data-tsd-nav]::before {',
+  "  content: '';",
+  '  flex: none;',
+  '  width: 16px;',
+  '  height: 16px;',
+  '  background: currentColor;',
+  '  -webkit-mask-image: url("' + NAV_ICON_MASK + '");',
+  '  mask-image: url("' + NAV_ICON_MASK + '");',
+  '  -webkit-mask-size: 16px 16px;',
+  '  mask-size: 16px 16px;',
+  '  -webkit-mask-repeat: no-repeat;',
+  '  mask-repeat: no-repeat;',
+  '}',
+].join('\n')
+
+/** 认不出行、拿不到 DOM，都只是退化成齿轮，绝不抛出。返回 disposer。 */
+function installSettingsNavIcon(label) {
+  if (typeof document === 'undefined' || typeof MutationObserver !== 'function') return null
+  let styleEl = null
+  try {
+    styleEl = document.createElement('style')
+    styleEl.setAttribute('data-plugin', 'dsh-plugin-usage')
+    styleEl.textContent = NAV_ICON_CSS
+    document.head.appendChild(styleEl)
+  } catch (e) {
+    console.warn('[usage] settings nav icon: styles unavailable')
+    return null
+  }
+  const mark = () => {
+    const rows = document.querySelectorAll('[role="dialog"] button')
+    const want = label()
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i]
+      if (row.getAttribute('data-tsd-nav') !== null) continue
+      if (!row.querySelector('svg')) continue // 只标带图标的导航行，别误标普通按钮
+      if ((row.textContent || '').trim() !== want) continue
+      row.setAttribute('data-tsd-nav', '')
+    }
+  }
+  let observer = null
+  try {
+    mark()
+    observer = new MutationObserver(() => { try { mark() } catch (e) {} })
+    observer.observe(document.body, { childList: true, subtree: true })
+  } catch (e) {
+    console.warn('[usage] settings nav icon: observer unavailable', e)
+  }
+  return () => {
+    if (observer) observer.disconnect()
+    if (styleEl) styleEl.remove()
+    const marked = document.querySelectorAll('[data-tsd-nav]')
+    for (let i = 0; i < marked.length; i++) marked[i].removeAttribute('data-tsd-nav')
+  }
+}
+
 /* ---------------------------------------------------------------------------
  * 注册：settings.section 页面
  * ------------------------------------------------------------------------- */
@@ -2408,6 +3034,7 @@ 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
+  ctx.effect(() => installSettingsNavIcon(() => t0('nav')), 'usage: nav-icon')
   // 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
@@ -2447,4 +3074,4 @@ return { inject: ['locale', 'slots'], 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":""}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sources":["/Users/ruanbw/projects/dsh-plugin-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: 28px;\n  height: 28px;\n  padding: 0;\n  border: 1px solid transparent;\n  background: transparent;\n  color: var(--dsw-alias-label-secondary);\n  border-radius: 6px;\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-icon-btn:disabled {\n  cursor: default;\n  opacity: 0.6;\n}\n.tsd-icon-btn:disabled:hover {\n  color: var(--dsw-alias-label-secondary);\n  background: transparent;\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  box-sizing: border-box;\n  width: 320px;\n  max-width: calc(100vw - 24px);\n}\n/* 浮层高度由 useFixedPanel 的 maxHeight 决定：只有列表可伸缩，其余部分不压缩 */\n.tsd-model-popover > .tsd-popover-tools,\n.tsd-model-popover > .tsd-search,\n.tsd-model-popover > .tsd-popover-note,\n.tsd-model-popover > .tsd-popover-empty { flex: none; }\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  flex: 1 1 auto;\n  min-height: 0;\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/* 数值行最前只放一个「符号 + 小箭头」的图标式触发器：符号本身就是读数的一部分，\n   尺寸/字重/基线继承数值行，读起来像数字前缀而不是一个控件。\n   符号只在这里画一次，formatCost 不再重复带符号。 */\n.tsd-cur-anchor {\n  position: relative;\n  display: inline-flex;\n}\n.tsd-cur-btn {\n  display: inline-flex;\n  align-items: baseline;\n  gap: 3px;\n  margin: 0 2px 0 0;\n  padding: 0 2px;\n  border: none;\n  border-radius: 6px;\n  background: transparent;\n  color: inherit;\n  font: inherit;\n  line-height: inherit;\n  vertical-align: baseline;\n  cursor: pointer;\n  transition: color 0.15s ease, background 0.15s ease;\n}\n.tsd-cur-btn:hover,\n.tsd-cur-btn-open {\n  color: var(--dsw-alias-brand-primary);\n  background: var(--dsw-alias-interactive-bg-hover);\n}\n.tsd-cur-btn:focus-visible {\n  outline: 2px solid var(--dsw-alias-brand-primary);\n  outline-offset: 1px;\n}\n.tsd-cur-chevron {\n  flex: none;\n  align-self: center;\n  transition: transform 0.15s ease;\n}\n.tsd-cur-btn-open .tsd-cur-chevron { transform: rotate(180deg); }\n.tsd-cur-popover {\n  box-sizing: border-box;\n  width: 180px;\n  max-width: calc(100vw - 24px);\n  padding: 6px;\n  display: flex;\n  flex-direction: column;\n  gap: 2px;\n  /* 浮层挂在 .tsd-card-value 里，那边为了数值行写了 nowrap；\n     浮层里的菜单项与说明必须恢复换行，否则长文案会横着溢出浮层。 */\n  white-space: normal;\n}\n.tsd-cur-option {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  padding: 7px 9px;\n  border: none;\n  border-radius: 8px;\n  background: transparent;\n  color: var(--dsw-alias-label-primary);\n  font: inherit;\n  font-size: 13px;\n  text-align: left;\n  cursor: pointer;\n}\n.tsd-cur-option:hover { background: var(--dsw-alias-interactive-bg-hover); }\n.tsd-cur-option:focus-visible {\n  outline: 2px solid var(--dsw-alias-brand-primary);\n  outline-offset: 1px;\n}\n.tsd-cur-symbol {\n  flex: none;\n  width: 20px;\n  text-align: center;\n  font-weight: 600;\n}\n.tsd-cur-name {\n  min-width: 0;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  color: var(--dsw-alias-label-secondary);\n  font-size: 12px;\n}\n.tsd-cur-option-active { background: var(--dsw-alias-interactive-bg-hover); }\n.tsd-cur-check {\n  margin-left: auto;\n  color: var(--dsw-alias-brand-primary);\n}\n\n/* ============ 模型占比（KPI 卡第 6 格） ============ */\n/* 主体是占比条，下方模型名与百分比压成脚注（11px tertiary），\n   与其它卡的大数字形成层级差，不抢 KPI 的读数位置。 */\n.tsd-card-share-body {\n  display: flex;\n  flex-direction: column;\n  gap: 8px;\n  min-width: 0;\n  /* 对齐 .tsd-card-value 的上边距，六张卡保持同一基线 */\n  margin-top: 8px;\n}\n.tsd-share-track {\n  display: flex;\n  align-items: stretch;\n  width: 100%;\n  height: 10px;\n  border-radius: 999px;\n  overflow: hidden;\n  background: var(--dsw-alias-interactive-bg-hover);\n}\n.tsd-share-seg {\n  height: 100%;\n  min-width: 2px;\n  outline: none;\n  opacity: 0.9;\n  transition: opacity 0.12s ease;\n}\n.tsd-share-seg:hover,\n.tsd-share-seg:focus-visible,\n.tsd-share-seg[data-active='true'] { opacity: 1; }\n.tsd-share-caption {\n  display: flex;\n  align-items: baseline;\n  gap: 6px;\n  font-size: 11px;\n  line-height: 16px;\n  color: var(--dsw-alias-label-tertiary);\n}\n.tsd-share-cap-name {\n  min-width: 0;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n.tsd-share-cap-pct {\n  flex: none;\n  font-variant-numeric: tabular-nums;\n}\n.tsd-share-empty {\n  font-size: 14px;\n  font-weight: 400;\n  color: var(--dsw-alias-label-tertiary);\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// 0.2+ host transport: POST /api/<channel>/<endpoint>, args as the JSON body,\n// answering { ok, value } | { ok, error } (see src/host/rpc.js). The route is\n// mounted on Connection's shared API channel, so it never needs the plugin's\n// fiber to own `webServer`.\nfunction callFetch(channel, endpoint, args) {\n  const path = '/api/' + String(channel).replace(/^\\/+/, '') + '/' + endpoint\n  return fetch(path, {\n    method: 'POST',\n    credentials: 'same-origin',\n    headers: { 'content-type': 'application/json' },\n    body: JSON.stringify(args === undefined ? null : args),\n  }).then((res) => {\n    const type = res.headers.get('content-type') || ''\n    // Route missing on this host: 404/405 from the shared dispatcher, or the\n    // SPA HTML when no transport route matched the path at all.\n    if (res.status === 404 || res.status === 405 || type.indexOf('application/json') === -1) {\n      const error = new Error('usage Fetch route unavailable (HTTP ' + res.status + ')')\n      error.code = 'usage-route-missing'\n      throw error\n    }\n    return res.json().then((body) => {\n      if (body && body.ok) return body.value\n      throw new Error((body && body.error && body.error.message) || ('RPC ' + endpoint + ' failed'))\n    })\n  })\n}\n\n// RPC bridge: dynamic-plugin runs provide a `host` global; static (bundle)\n// installs provide ctx.get('connection'). 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 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  // Legacy pre-0.2 transport: a `/usage` prefix RPC channel owned by the host\n  // plugin itself.\n  const callRpc = () => {\n    const connection = scope.get('connection')\n    if (connection === undefined || connection.rpc === undefined) {\n      return Promise.reject(new Error('connection service unavailable'))\n    }\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  // Prefer the shared-channel Fetch route; an older host answers \"route\n  // missing\" and we fall back to the legacy channel it does implement.\n  const fetchUsable = typeof fetch === 'function'\n    && !(typeof location !== 'undefined' && location.protocol === 'file:')\n  if (!fetchUsable) return callRpc()\n  return callFetch(channel, endpoint, args).catch((error) => {\n    if (error && error.code === 'usage-route-missing') return callRpc()\n    throw error\n  })\n}\n\n/* ---------------------------------------------------------------------------\n * 设置域定价：官方 `ctx.configForms.get('usage')`（dsh-client-ui-settings）优先，\n * 不可用时回退 usage/prices RPC。绑定只做一次，读写共用同一 form。\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    // 0.2.x: the official config-form surface for this plugin's entry id\n    // (`usage`, the bundle patch row id). `settingsScope` from 0.1.x does not\n    // exist in the shipped client, so probing it only ever returned null.\n    const forms = c.get('configForms')\n    if (!forms || typeof forms.get !== 'function') return null\n    _usagePricesScope = forms.get('usage')\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  currencyHint: '参考成本币种（固定汇率 1 USD = 7 CNY）',\n  currencyCNY: '人民币',\n  currencyUSD: '美元',\n  today: '今日',\n  last7d: '近7天',\n  last30d: '近30天',\n  custom: '自定义',\n  all: '全部',\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: '支持选择任意日期范围，不限跨度',\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  modelShare: '模型占比',\n  shareOther: '其它',\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  currencyHint: 'Reference-cost currency (fixed rate: 1 USD = 7 CNY)',\n  currencyCNY: 'CNY',\n  currencyUSD: 'USD',\n  today: 'Today',\n  last7d: 'Last 7 days',\n  last30d: 'Last 30 days',\n  custom: 'Custom',\n  all: 'All',\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: 'Any date range — no length limit',\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: 'Est. 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: 'Est. cost',\n  colShare: 'Share',\n  modelShare: 'Model share',\n  shareOther: 'Others',\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}\n/** 只要数字部分：成本卡的符号由币种切换器自己画，再带一次就成了「¥ ¥14.78」。 */\nfunction costDigits(n) {\n  if (!Number.isFinite(n)) return '--'\n  // Below half a cent there is nothing to show at 2 decimals; say so instead of\n  // printing a misleading 0.00 (a $0.03 CNY cost becomes $0.004).\n  if (n > 0 && n < 0.005) return '<0.01'\n  return n.toFixed(2)\n}\nfunction formatCost(n, cur) {\n  return (cur || '¥') + costDigits(n)\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 起；全部 = 不限起点；\n// 自定义 = 起日 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  // 全量：0 是有限值，宿主的 fill 判定认它；调用方必须同时传 fill:false，\n  // 否则会去零填充 1970 年至今、撞上 MAX_BUCKETS 退化成只看有数据的桶。\n  if (preset === 'all') return { from: 0, 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  // 刷新图标取自 DSH 原生图形（16 网格、stroke 1.5），与设置页其它图标同一观感；\n  // 其余图标仍是 24 网格（stroke 2），SvgIcon 两种定义都吃。\n  refresh: {\n    viewBox: '0 0 16 16',\n    strokeWidth: 1.5,\n    paths: [\n      'M14.5001 8C14.5 9.28552 14.1188 10.5422 13.4045 11.611C12.6903 12.6799 11.6752 13.5129 10.4875 14.0049C9.29982 14.4968 7.99295 14.6255 6.73212 14.3747C5.4713 14.124 4.31314 13.505 3.4041 12.596C2.49514 11.687 1.87614 10.5288 1.62537 9.26798C1.37459 8.00716 1.50331 6.70028 1.99525 5.51261C2.48719 4.32494 3.32025 3.30981 4.3891 2.59557C5.45795 1.88134 6.71458 1.50008 8.0001 1.5C9.9001 1.5 11.7001 2.3 13.0001 3.6L14.5001 5.1',\n      'M14.4999 1.5V5.1H10.8999',\n    ],\n  },\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  // 饼图（占比）：外圈 + 楔形，与卡片标题的「占比」语义一致\n  share: 'M21.21 15.89A10 10 0 118 2.83M22 12A10 10 0 0012 2v10z',\n  check: 'M20 6L9 17l-5-5',\n}\nfunction SvgIcon(props) {\n  const { name, size, className } = props\n  // 一个名字对应「一串 path + 自己的 viewBox/线宽」；字符串是 24 网格的简写，\n  // 调用方（31 处）无需关心差别。\n  const spec = ICON_PATHS[name] || ICON_PATHS.activity\n  const icon = typeof spec === 'string'\n    ? { viewBox: '0 0 24 24', strokeWidth: 2, paths: [spec] }\n    : spec\n  return h('svg', {\n    className: className || 'tsd-icon',\n    width: size || 16,\n    height: size || 16,\n    viewBox: icon.viewBox || '0 0 24 24',\n    fill: 'none',\n    stroke: 'currentColor',\n    strokeWidth: icon.strokeWidth || 2,\n    strokeLinecap: 'round',\n    strokeLinejoin: 'round',\n    'aria-hidden': true,\n  }, icon.paths.map((d, i) => h('path', { key: i, d })))\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 * 通用 Hook：浮层定位（viewport 定位 + 空间不足上翻 + 高度封顶）\n *\n * 设置面板本身是 `overflow: hidden` 的裁剪容器，贴着过滤栏右端的 absolute\n * 浮层会被整条裁掉（右侧的「清空」看不见）。CSS 无法感知祖先裁剪，只能量一次\n * 视口再定位；滚动或缩放时重算，避免浮层留在原地。\n * ------------------------------------------------------------------------- */\nconst PANEL_MIN_ROOM = 240 // 下方空间小于它且上方更宽裕时上翻\nconst PANEL_MIN_HEIGHT = 160\n\nfunction useFixedPanel(anchorRef, open, width, gap = 6, margin = 12) {\n  const [style, setStyle] = React.useState(null)\n  React.useEffect(() => {\n    if (!open) {\n      setStyle(null)\n      return undefined\n    }\n    function measure() {\n      const el = anchorRef.current\n      if (!el) return\n      const r = el.getBoundingClientRect()\n      const boxW = Math.min(width, window.innerWidth - margin * 2)\n      const left = Math.max(margin, Math.min(r.left, window.innerWidth - margin - boxW))\n      const below = window.innerHeight - r.bottom - gap - margin\n      const above = r.top - gap - margin\n      const flip = below < PANEL_MIN_ROOM && above > below\n      setStyle({\n        position: 'fixed',\n        left,\n        width: boxW,\n        maxHeight: Math.max(PANEL_MIN_HEIGHT, flip ? above : below),\n        ...(flip\n          ? { bottom: window.innerHeight - r.top + gap }\n          : { top: r.bottom + gap }),\n        display: 'flex',\n        flexDirection: 'column',\n        zIndex: 40,\n      })\n    }\n    measure()\n    window.addEventListener('resize', measure)\n    window.addEventListener('scroll', measure, true)\n    return () => {\n      window.removeEventListener('resize', measure)\n      window.removeEventListener('scroll', measure, true)\n    }\n  }, [open, anchorRef, width, gap, margin])\n  if (!open) return null\n  // 首帧还没量到尺寸：先藏起来，否则会闪到左上角\n  return style || { position: 'fixed', top: 0, left: 0, visibility: 'hidden' }\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      disabled: busy,\n      'aria-busy': busy || undefined,\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, anchorRef } = props\n  const t = useT()\n  const panelStyle = useFixedPanel(anchorRef, true, 300)\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    style: panelStyle,\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  const panelStyle = useFixedPanel(anchorRef, open, 320)\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  // 候选键直接用宿主给好的 `key`（compositeModelKey 的结果）：客户端不再自己拼\n  // `provider + '/' + model`，provider 为空时那种拼法会得到 `/model` 而永远选不中。\n  const candidates = React.useMemo(() => {\n    const set = new Set((options || []).map((m) => m.key || (m.provider ? m.provider + '/' + m.model : 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          style: panelStyle,\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  const customBtnRef = 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: 'all', label: t('all') },\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            ref: isCustom ? customBtnRef : undefined,\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\n        ? h(CustomRangePopover, { custom, onApply: onCustomApply, onClose: onCustomClose, anchorRef: customBtnRef })\n        : null),\n    h(ModelDropdown, { options: modelOptions, selected: models, onChange: onModelsChange }))\n}\n\n/* ---------------------------------------------------------------------------\n * 参考成本币种切换（人民币 / 美元，固定 1 USD = 7 CNY）\n *\n * 换算在宿主侧完成（价目表是美元价，绝不回写），所以这里只负责选择与持久化：\n * 换币种即换查询，不重查数字不会变。\n * ------------------------------------------------------------------------- */\nconst CURRENCY_SYMBOLS = { CNY: '¥', USD: '$' }\nconst CURRENCY_STORE_KEY = 'dsh-plugin-usage:display-currency'\n\nfunction readStoredCurrency() {\n  try {\n    return window.localStorage.getItem(CURRENCY_STORE_KEY) === 'USD' ? 'USD' : 'CNY'\n  } catch (e) {\n    return 'CNY' // 无痕模式 / 存储被禁：退回默认\n  }\n}\nfunction storeCurrency(code) {\n  try {\n    window.localStorage.setItem(CURRENCY_STORE_KEY, code)\n  } catch (e) {\n    // 存不下就只影响下次打开，不影响本次显示\n  }\n}\n\nfunction CurrencyPicker(props) {\n  const { code, onChange } = props\n  const t = useT()\n  const [open, setOpen] = React.useState(false)\n  const ref = React.useRef(null)\n  const panelStyle = useFixedPanel(ref, open, 180)\n  useOutsideClick(open, ref, () => setOpen(false))\n  const active = CURRENCY_SYMBOLS[code] ? code : 'CNY'\n  const options = ['CNY', 'USD']\n  // 收起时 ↑↓ 直接换值（像原生 select），展开时在两项间移动；Esc 关菜单。\n  const move = (step) => {\n    const i = options.indexOf(active)\n    onChange(options[(i + step + options.length) % options.length])\n  }\n  const onKeyDown = (e) => {\n    if (e.key === 'Escape') { setOpen(false); return }\n    if (!open) {\n      if (e.key === 'ArrowDown' || e.key === 'ArrowUp') { e.preventDefault(); move(e.key === 'ArrowDown' ? 1 : -1); return }\n      if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); setOpen(true) }\n      return\n    }\n    if (e.key === 'ArrowDown') { e.preventDefault(); move(1) }\n    else if (e.key === 'ArrowUp') { e.preventDefault(); move(-1) }\n  }\n  return h('span', { className: 'tsd-cur-anchor', ref },\n    h('button', {\n      type: 'button',\n      className: 'tsd-cur-btn' + (open ? ' tsd-cur-btn-open' : ''),\n      title: t('currencyHint'),\n      'aria-label': t('currencyHint'),\n      'aria-haspopup': 'listbox',\n      'aria-expanded': open,\n      onClick: () => setOpen((v) => !v),\n      onKeyDown,\n    },\n      h('span', null, CURRENCY_SYMBOLS[active]),\n      h(SvgIcon, { name: 'chevron', size: 10, className: 'tsd-cur-chevron' })),\n    open\n      ? h('div', {\n          className: 'tsd-popover tsd-cur-popover',\n          style: panelStyle,\n          role: 'listbox',\n          'aria-label': t('currencyHint'),\n          onKeyDown,\n        },\n        options.map((c) => h('button', {\n          key: c,\n          type: 'button',\n          role: 'option',\n          'aria-selected': c === active,\n          className: 'tsd-cur-option' + (c === active ? ' tsd-cur-option-active' : ''),\n          onClick: () => { onChange(c); setOpen(false) },\n        },\n          h('span', { className: 'tsd-cur-symbol' }, CURRENCY_SYMBOLS[c]),\n          h('span', { className: 'tsd-cur-name' }, t(c === 'CNY' ? 'currencyCNY' : 'currencyUSD')),\n          c === active ? h(SvgIcon, { name: 'check', size: 12, className: 'tsd-cur-check' }) : null)),\n        h('div', { className: 'tsd-popover-note' }, t('currencyHint')))\n      : null)\n}\n\n/* ---------------------------------------------------------------------------\n * 模型占比（KPI 网格里的第 6 格）\n *\n * 数据直接吃宿主 `byModel` 的行（与「按模型明细」表同一份），不另算一遍。\n * 明细放在各段的原生 title 上而不是浮层：KPI 卡贴着设置面板的裁剪边界，\n * 再叠一层浮层只会把之前修好的裁剪问题带回来。\n * ------------------------------------------------------------------------- */\nconst SHARE_COLORS = [\n  // 只用主题里真实存在、且彼此分得开的彩色族：深蓝、绿、琥珀、红。\n  // 不用 neutral / 白 / 黑 —— 它们在深浅两套主题里一边会糊进背景，一边会被读成禁用态。\n  'var(--dsw-static-deepseek-500)',\n  'var(--dsw-static-green-500)',\n  'var(--dsw-static-amber-500)',\n  'var(--dsw-static-red-400)',\n]\nconst SHARE_TOP = 4\nconst SHARE_REST_KEY = '__rest__'\n\n/** `provider/model` → 裸模型名；色带格位放不下全名，全名留给 title 与 aria。 */\nfunction shortModelName(key) {\n  const s = String(key == null ? '' : key)\n  const i = s.lastIndexOf('/')\n  return i === -1 ? s : s.slice(i + 1)\n}\n/** 宿主行是 `totalTokens`；兼容已映射成 `total` 的形状，空行也不能抛。 */\nfunction rowTotal(r) {\n  return r ? (r.totalTokens || r.total || 0) : 0\n}\n/** 降序取前 4 段，其余并成「其它」；无数据时返回空段。 */\nfunction shareSegments(rows) {\n  const list = (rows || []).slice().sort((a, b) => rowTotal(b) - rowTotal(a))\n  const total = list.reduce((s, r) => s + rowTotal(r), 0)\n  if (total <= 0) return { total: 0, segs: [] }\n  const numbers = (r) => ({\n    tokens: rowTotal(r),\n    calls: r.calls || 0,\n    // 与明细表同一口径：输入含缓存读写\n    input: (r.inputTokens || 0) + (r.cacheReadTokens || 0) + (r.cacheWriteTokens || 0),\n    output: r.outputTokens || 0,\n    cost: r.cost || 0,\n  })\n  const segs = list.slice(0, SHARE_TOP).map((r, i) => Object.assign({\n    key: String(r.key),\n    label: shortModelName(r.key),\n    pct: rowTotal(r) / total,\n    color: SHARE_COLORS[i % SHARE_COLORS.length],\n  }, numbers(r)))\n  const restRows = list.slice(SHARE_TOP)\n  const restTokens = restRows.reduce((s, r) => s + rowTotal(r), 0)\n  if (restTokens > 0) {\n    const agg = restRows.reduce((a, r) => {\n      const n = numbers(r)\n      return {\n        tokens: a.tokens + n.tokens,\n        calls: a.calls + n.calls,\n        input: a.input + n.input,\n        output: a.output + n.output,\n        cost: a.cost + n.cost,\n      }\n    }, { tokens: 0, calls: 0, input: 0, output: 0, cost: 0 })\n    segs.push(Object.assign({\n      key: SHARE_REST_KEY,\n      label: null, // 「其它」的文案由渲染层取词典\n      pct: restTokens / total,\n      // 「其它」用同色系的淡色（浅蓝），不用灰/白：那两种在深色卡片上会被读成禁用\n      color: 'var(--dsw-static-deepseek-300)',\n    }, agg))\n  }\n  return { total, segs }\n}\n\nfunction ModelShareBar(props) {\n  const { rows, currency } = props\n  const t = useT()\n  const [tip, setTip] = React.useState(null) // { key, left, top } in viewport coords\n  const occ = shareSegments(rows)\n  if (occ.total <= 0) return h('div', { className: 'tsd-card-value tsd-share-empty' }, t('noData'))\n  const find = (key) => occ.segs.filter((s) => s.key === key)[0] || null\n  const shown = (tip && find(tip.key)) || occ.segs[0]\n  const labelOf = (s) => (s.key === SHARE_REST_KEY ? t('shareOther') : s.label)\n  const fullOf = (s) => (s.key === SHARE_REST_KEY ? t('shareOther') : s.key)\n  const costOf = (s) => (s.tokens > 0 && !(s.cost > 0) ? t('unpriced') : formatCost(s.cost, currency))\n  // 悬停/聚焦：从段的视口矩形推开，fixed 定位不受设置面板 overflow 裁剪\n  const showTip = (e, s) => {\n    const r = e.currentTarget.getBoundingClientRect()\n    setTip({ key: s.key, left: r.left + r.width / 2, top: r.top })\n  }\n  const hideTip = () => setTip(null)\n  const tipBox = shown && tip\n    ? h('div', {\n        className: 'tsd-tooltip tsd-share-tip',\n        style: { position: 'fixed', left: tip.left + 'px', top: tip.top + 'px', transform: 'translate(-50%, -110%)' },\n      },\n        h('div', { className: 'tsd-tooltip-date' }, fullOf(shown)),\n        h('div', { className: 'tsd-tooltip-row' },\n          h('span', { className: 'tsd-tooltip-dot', style: { background: shown.color } }),\n          h('span', null, t('totalTokens')),\n          h('span', { className: 'tsd-tooltip-val' }, formatInt(shown.tokens))),\n        h('div', { className: 'tsd-tooltip-row' },\n          h('span', null, t('legendInput')),\n          h('span', { className: 'tsd-tooltip-val' }, formatInt(shown.input))),\n        h('div', { className: 'tsd-tooltip-row' },\n          h('span', null, t('legendOutput')),\n          h('span', { className: 'tsd-tooltip-val' }, formatInt(shown.output))),\n        h('div', { className: 'tsd-tooltip-row' },\n          h('span', null, t('cost')),\n          h('span', { className: 'tsd-tooltip-val' }, costOf(shown))))\n    : null\n  return h('div', { className: 'tsd-card-share-body' },\n    h('div', { className: 'tsd-share-track', onMouseLeave: hideTip },\n      occ.segs.map((s) => h('div', {\n        key: s.key,\n        className: 'tsd-share-seg',\n        'data-share-key': s.key,\n        'data-active': shown && shown.key === s.key ? 'true' : undefined,\n        style: { width: s.pct * 100 + '%', background: s.color },\n        role: 'img',\n        tabIndex: 0,\n        'aria-label': fullOf(s) + ' · ' + fmtPct(s.pct) + ' · ' + formatInt(s.tokens) + ' ' + t('totalTokens'),\n        onMouseEnter: (e) => showTip(e, s),\n        onFocus: (e) => showTip(e, s),\n        onBlur: hideTip,\n      }))),\n    // 条下只留一行低调脚注（当前悬浮的那段，否则最大的那段）；\n    // 全名与明细都在悬浮卡片里，所以这里不挂 title。\n    h('div', { className: 'tsd-share-caption' },\n      h('span', { className: 'tsd-share-cap-name' }, labelOf(shown)),\n      h('span', { className: 'tsd-share-cap-pct' }, fmtPct(shown.pct))),\n    tipBox)\n}\n\n/* ---------------------------------------------------------------------------\n * 汇总指标卡 ×6\n * ------------------------------------------------------------------------- */\nfunction SummaryCards(props) {\n  const { total, currency, unpricedCalls, currencyCode, onCurrencyChange, byModel } = 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      // 符号由 prefix 的币种切换器画（它显示当前币种符号），这里只给数字\n      value: costDigits(d.cost), title: formatCost(d.cost, currency),\n      color: 'var(--dsw-static-green-500)',\n      prefix: h(CurrencyPicker, { code: currencyCode, onChange: onCurrencyChange }),\n    },\n    {\n      key: 'share', icon: 'share', label: tt('modelShare'),\n      color: 'var(--dsw-alias-brand-primary)',\n      content: h(ModelShareBar, { rows: byModel, currency }),\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        c.content\n          ? c.content\n          : h('div', { className: 'tsd-card-value', title: c.title }, c.prefix || null, 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  // 展示币种：宿主按它换算成本，所以换币种必须重查；选择记在本地（展示偏好，\n  // 不写插件设置，免得每次取数都在改写用户配置）。\n  const [displayCurrency, setDisplayCurrency] = React.useState(readStoredCurrency)\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 + '|' + displayCurrency\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      // 「全部」不做零填充：真实边界是输出桶数（宿主 MAX_BUCKETS），不是天数。\n      fill: range !== 'all',\n      granularity: effGran,\n      stepDays,\n      heatmap: true,\n      currency: displayCurrency,\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, displayCurrency, 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 changeCurrency = React.useCallback((code) => {\n    storeCurrency(code)\n    setDisplayCurrency(code)\n  }, [])\n  // 符号以宿主回传的实际币种为准（切换后立刻重查，不会出现「换了标志没换数字」）；\n  // 老宿主没有该字段时按本地选择兜底。\n  const currencySymbol = (data && data.currency && data.currency.symbol)\n    || CURRENCY_SYMBOLS[displayCurrency] || prices.currency || '¥'\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: currencySymbol,\n            unpricedCalls: data.unpricedCalls || 0,\n            currencyCode: displayCurrency,\n            onCurrencyChange: changeCurrency,\n            byModel: data.byModel,\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: currencySymbol }))\n      : null))\n}\n\n/* ---------------------------------------------------------------------------\n * 设置页导航图标\n *\n * `settings.section` 只投影 id/order/label，导航图标由设置页按 id 白名单自己\n * 决定（dsh-client-ui-settings-general 的 navIcon），第三方没有插口。所以这里\n * 给「自己那一行」打一个属性标记，再用 CSS mask 把兜底的齿轮换成用量图标：\n * 不替换节点、不碰 React 管的 svg（替换会让 React 卸载时抛 NotFoundError），\n * 只加属性、只用 ::before 画字形。\n *\n * 认行只能按可见文本：类名是 CSS Modules 哈希，账号行还会条件出现。\n * 官方一旦给 settings.section 加上 icon 字段，这个模块应整体删除。\n * ------------------------------------------------------------------------- */\nconst NAV_ICON_MASK = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(\n  '<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\">'\n  + '<rect x=\"2.5\" y=\"9\" width=\"2.5\" height=\"5\" rx=\"1\"/>'\n  + '<rect x=\"6.75\" y=\"5.5\" width=\"2.5\" height=\"8.5\" rx=\"1\"/>'\n  + '<rect x=\"11\" y=\"2.5\" width=\"2.5\" height=\"11.5\" rx=\"1\"/></svg>',\n)\n// mask 只读 alpha 通道，所以字形必须是纯色实心（icon.svg 的渐变与半透明在这里会丢）\nconst NAV_ICON_CSS = [\n  '[data-tsd-nav] > svg { display: none; }',\n  '[data-tsd-nav]::before {',\n  \"  content: '';\",\n  '  flex: none;',\n  '  width: 16px;',\n  '  height: 16px;',\n  '  background: currentColor;',\n  '  -webkit-mask-image: url(\"' + NAV_ICON_MASK + '\");',\n  '  mask-image: url(\"' + NAV_ICON_MASK + '\");',\n  '  -webkit-mask-size: 16px 16px;',\n  '  mask-size: 16px 16px;',\n  '  -webkit-mask-repeat: no-repeat;',\n  '  mask-repeat: no-repeat;',\n  '}',\n].join('\\n')\n\n/** 认不出行、拿不到 DOM，都只是退化成齿轮，绝不抛出。返回 disposer。 */\nfunction installSettingsNavIcon(label) {\n  if (typeof document === 'undefined' || typeof MutationObserver !== 'function') return null\n  let styleEl = null\n  try {\n    styleEl = document.createElement('style')\n    styleEl.setAttribute('data-plugin', 'dsh-plugin-usage')\n    styleEl.textContent = NAV_ICON_CSS\n    document.head.appendChild(styleEl)\n  } catch (e) {\n    console.warn('[usage] settings nav icon: styles unavailable')\n    return null\n  }\n  const mark = () => {\n    const rows = document.querySelectorAll('[role=\"dialog\"] button')\n    const want = label()\n    for (let i = 0; i < rows.length; i++) {\n      const row = rows[i]\n      if (row.getAttribute('data-tsd-nav') !== null) continue\n      if (!row.querySelector('svg')) continue // 只标带图标的导航行，别误标普通按钮\n      if ((row.textContent || '').trim() !== want) continue\n      row.setAttribute('data-tsd-nav', '')\n    }\n  }\n  let observer = null\n  try {\n    mark()\n    observer = new MutationObserver(() => { try { mark() } catch (e) {} })\n    observer.observe(document.body, { childList: true, subtree: true })\n  } catch (e) {\n    console.warn('[usage] settings nav icon: observer unavailable', e)\n  }\n  return () => {\n    if (observer) observer.disconnect()\n    if (styleEl) styleEl.remove()\n    const marked = document.querySelectorAll('[data-tsd-nav]')\n    for (let i = 0; i < marked.length; i++) marked[i].removeAttribute('data-tsd-nav')\n  }\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  ctx.effect(() => installSettingsNavIcon(() => t0('nav')), 'usage: nav-icon')\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":""}