dsh-plugin-usage 0.4.0 → 0.5.0

package/lib/client/index.js

@@ -22,6 +22,7 @@ window.__ModuleLoader__.load({
 const CSS = `
 /* ============ 布局 ============ */
 .tsd-section {
+  position: relative;
   width: 100%;
   display: flex;
   flex-direction: column;
@@ -29,6 +30,38 @@ const CSS = `
   color: var(--dsw-alias-label-primary);
   animation: tsd-fade-in 0.4s var(--ds-ease-in-out);
 }
+/* 刷新中的那条细进度条：贴在本节顶部，绝对定位所以不推动版面、不碰任何数字。
+   用它而不是把整块内容压暗 —— 已有数字本来就是对的，压暗只让人以为在重算。 */
+.tsd-progress {
+  position: absolute;
+  inset: -6px 0 auto 0;
+  height: 2px;
+  overflow: hidden;
+  border-radius: 2px;
+  background: color-mix(in srgb, var(--dsw-alias-brand-primary) 18%, transparent);
+  pointer-events: none;
+}
+.tsd-progress::after {
+  content: '';
+  position: absolute;
+  inset: 0 auto 0 0;
+  width: 35%;
+  border-radius: inherit;
+  background: var(--dsw-alias-brand-primary);
+  animation: tsd-indeterminate 1.2s var(--ds-ease-in-out) infinite;
+}
+/* 知道分母时改成确定进度：宽度就是 done/total，不再来回扫 —— 用户看到的
+   "算到哪了"是真的，而不是一个装忙的动画。 */
+.tsd-progress[data-determinate=true]::after {
+  width: var(--tsd-progress, 0%);
+  animation: none;
+  transform: none;
+  transition: width 240ms var(--ds-ease-in-out);
+}
+@keyframes tsd-indeterminate {
+  from { transform: translateX(-40%); }
+  to { transform: translateX(300%); }
+}
 @keyframes tsd-fade-in {
   from { opacity: 0; transform: translateY(8px); }
   to { opacity: 1; transform: none; }
@@ -549,6 +582,49 @@ const CSS = `
   text-overflow: ellipsis;
   white-space: nowrap;
 }
+/* 标题带提示时给一个可发现的记号：虚线底边 + 感叹号按钮（见 HintTip）。
+   悬浮用原生 title，点击展开浮层；两段规则都在这一个组件里，别处不再各画一份。 */
+.tsd-card-label[title] {
+  cursor: help;
+  text-decoration: underline dotted;
+  text-underline-offset: 2px;
+}
+.tsd-hint {
+  display: inline-flex;
+  align-items: center;
+}
+.tsd-hint-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  padding: 0;
+  border: none;
+  border-radius: 50%;
+  background: transparent;
+  color: var(--dsw-alias-label-tertiary);
+  cursor: help;
+}
+.tsd-hint-btn:hover,
+.tsd-hint-btn-open {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
+}
+.tsd-hint-btn:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 1px;
+}
+/* 浮层里两段规则分段读；行的左右内边距由 .tsd-popover 给，这里只补段间距 */
+.tsd-hint-line {
+  margin: 0;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-secondary);
+}
+.tsd-hint-line + .tsd-hint-line {
+  margin-top: 6px;
+}
 .tsd-card-value {
   margin-top: 8px;
   font-size: 20px;
@@ -568,8 +644,41 @@ const CSS = `
 .tsd-card-note {
   margin-top: 4px;
   font-size: 11px;
+  color: var(--dsw-alias-label-tertiary);
+  line-height: 1.35;
+}
+/* 未定价是「少算了钱」，不是普通提示：其余脚注用三级灰，这一行用警示色 */
+.tsd-card-note-warn {
   color: var(--dsw-alias-state-warn-primary);
 }
+.tsd-card-notes {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+/* 参考成本卡的入口按钮：跟着标题走，不抢数值行的位置 */
+.tsd-card-action {
+  margin-left: auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  padding: 0;
+  border: none;
+  border-radius: 5px;
+  background: transparent;
+  color: var(--dsw-alias-label-tertiary);
+  cursor: pointer;
+}
+.tsd-card-action:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
+}
+.tsd-card-action:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 1px;
+}
 
 /* ============ 卡片头部（图表 / 表格共用） ============ */
 .tsd-card-header {
@@ -929,13 +1038,23 @@ const CSS = `
 }
 
 /* ============ 刷新时的内容态 ============ */
+/* 不再 opacity: .55：那会让每次轮询都闪一下，且暗示"数字正在重算" ——
+   事实上数字是上一轮的正确答案。刷新的信号交给顶部那条 2px 进度条与按钮转圈。 */
 .tsd-content {
   display: flex;
   flex-direction: column;
   gap: 16px;
-  transition: opacity var(--ds-transition-duration) var(--ds-ease-in-out);
 }
-.tsd-content[data-busy=true] { opacity: 0.55; }
+
+/* ============ 减少动态效果 ============ */
+/* 官方客户端同样这么写（spinner / skeletonFill 都在 prefers-reduced-motion 下关动画），
+   我们这两个无限动画（呼吸、旋转）此前一条都没关。 */
+@media (prefers-reduced-motion: reduce) {
+  .tsd-section { animation: none; }
+  .tsd-spinning svg { animation: none; }
+  .tsd-skeleton, .tsd-skeleton-row { animation: none; }
+  .tsd-progress::after { animation: none; width: 100%; opacity: 0.55; }
+}
 
 /* ============ 无障碍 ============ */
 .tsd-visually-hidden {
@@ -1159,6 +1278,394 @@ const CSS = `
   font-variant-numeric: tabular-nums;
   color: var(--dsw-alias-label-primary);
 }
+/* ============ 定价匹配弹窗 ============ */
+/* 遮罩铺满视口：设置面板是 overflow:hidden 的裁剪容器，弹窗不能挂在面板内部，
+   否则宽屏下左右各被切掉一块。层级压过 popover(40)，低于任何系统级浮窗。 */
+.tsd-price-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 60;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 24px;
+  background: var(--dsw-alias-bg-mask, rgba(0, 0, 0, 0.4));
+}
+.tsd-price-dialog {
+  display: flex;
+  flex-direction: column;
+  width: min(760px, 100%);
+  max-height: 100%;
+  padding: 16px 18px 14px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 14px;
+  background: var(--dsw-alias-bg-layer-1);
+  box-shadow: var(--dsw-shadow-lv3);
+  color: var(--dsw-alias-label-primary);
+  font-size: 13px;
+}
+.tsd-price-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.tsd-price-title {
+  margin: 0;
+  font-size: 15px;
+  font-weight: 600;
+}
+.tsd-price-close {
+  margin-left: auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  padding: 0;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--dsw-alias-label-tertiary);
+  cursor: pointer;
+}
+.tsd-price-close:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
+}
+.tsd-price-desc {
+  margin: 6px 0 10px;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-secondary);
+}
+/* 只有中段滚动：标题与底部按钮必须常驻，否则长表里够不到「确定」 */
+.tsd-price-body {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow: auto;
+}
+.tsd-price-meta {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 4px 12px;
+  margin-bottom: 8px;
+  font-size: 11px;
+  color: var(--dsw-alias-label-tertiary);
+}
+.tsd-price-counts { color: var(--dsw-alias-label-secondary); }
+.tsd-price-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+}
+.tsd-price-table-sub {
+  margin-top: 10px;
+}
+.tsd-price-table th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  padding: 6px 8px;
+  background: var(--dsw-alias-bg-layer-1);
+  border-bottom: 1px solid var(--dsw-alias-border-l2);
+  font-weight: 500;
+  font-size: 11px;
+  color: var(--dsw-alias-label-tertiary);
+  text-align: left;
+  white-space: nowrap;
+}
+.tsd-price-table td {
+  padding: 6px 8px;
+  border-bottom: 1px solid var(--dsw-alias-border-l2);
+  vertical-align: middle;
+}
+.tsd-price-row[data-dirty='true'] td {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+.tsd-price-model {
+  max-width: 240px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.tsd-price-model-name {
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 11.5px;
+  font-weight: 500;
+}
+.tsd-price-model-provider {
+  margin-left: 6px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 10.5px;
+  color: var(--dsw-alias-label-tertiary);
+}
+/* 匹配目标格：整格是一颗紧凑的「选择」按钮（未匹配时虚线、文案是提示语），
+   比每行摊两颗文字按钮安静得多；可搜索的下拉挂在它下面展开。 */
+.tsd-price-target { max-width: 230px; }
+.tsd-price-target-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  max-width: 100%;
+  padding: 3px 6px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 6px;
+  background: var(--dsw-alias-bg-layer-2);
+  color: var(--dsw-alias-label-secondary);
+  font: inherit;
+  font-size: 12px;
+  cursor: pointer;
+}
+.tsd-price-target-btn:hover {
+  border-color: var(--dsw-alias-label-tertiary);
+  color: var(--dsw-alias-label-primary);
+}
+.tsd-price-target-btn:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 1px;
+}
+.tsd-price-target-btn[data-empty='true'] {
+  border-style: dashed;
+  color: var(--dsw-alias-label-tertiary);
+}
+.tsd-price-target-id {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.tsd-price-target-chev { flex: none; opacity: 0.7; }
+/* 参考模型的来源标签：DeepSeek / Zen / 自定义。10px、无边框、只在格尾占一点点，
+   免得把 id 挤掉 —— id 自己已经会 ellipsis。 */
+.tsd-price-src {
+  margin-left: 4px;
+  padding: 0 3px;
+  border-radius: 4px;
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 10px;
+  white-space: nowrap;
+}
+.tsd-price-src[data-source='deepseek'] { color: var(--dsw-static-blue-500); }
+.tsd-price-src[data-source='custom'] { color: var(--dsw-static-green-500); }
+/* 候选列表里的分组表头：粘在滚动容器顶部，滚到哪都知道自己在看哪一类。 */
+.tsd-price-pick-group {
+  position: sticky;
+  top: 0;
+  padding: 4px 4px 2px;
+  background: var(--dsw-alias-bg-layer-1);
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 10.5px;
+  letter-spacing: 0.02em;
+}
+/* 空组（目前只有「自定义」）给一行说明，别让这一类隐形。 */
+.tsd-price-pick-sep {
+  margin: 4px 0;
+  border-top: 1px solid var(--dsw-alias-border-l2);
+}
+/* 「自定义」选项：顶部固定的一条，带一行说明。 */
+.tsd-price-pick-custom {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 2px;
+  border: 1px dashed var(--dsw-alias-border-l2);
+}
+.tsd-price-pick-custom-label { font-weight: 500; color: var(--dsw-alias-label-primary); }
+.tsd-price-pick-custom-hint { font-size: 11px; color: var(--dsw-alias-label-tertiary); }
+/* 手填单价的三格：一行一个字段，输入框占满剩余宽度。 */
+.tsd-price-custom-box { gap: 8px; }
+.tsd-price-custom-title { font-weight: 500; }
+.tsd-price-custom-field {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.tsd-price-custom-field > span {
+  flex: none;
+  width: 52px;
+  color: var(--dsw-alias-label-secondary);
+}
+.tsd-price-custom-input {
+  box-sizing: border-box;
+  flex: 1 1 auto;
+  min-width: 0;
+  height: 26px;
+  padding: 0 8px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 6px;
+  background: var(--dsw-alias-bg-layer-1);
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 12px;
+}
+.tsd-price-custom-hint { color: var(--dsw-alias-label-tertiary); font-size: 11px; }
+.tsd-price-stale {
+  margin-left: 6px;
+  font-size: 11px;
+  color: var(--dsw-alias-state-warn-primary);
+}
+.tsd-price-rate {
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+  color: var(--dsw-alias-label-secondary);
+}
+/* 操作格：默认空着，只有「自定义 / 有改动」的行才给一颗还原图标。
+   注意别给 td 设 display:flex —— 那会把单元格块级化，整列失去对齐。 */
+.tsd-price-ops {
+  width: 34px;
+  text-align: right;
+  white-space: nowrap;
+}
+.tsd-price-reset {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  padding: 0;
+  border: 1px solid transparent;
+  border-radius: 6px;
+  background: none;
+  color: var(--dsw-alias-label-tertiary);
+  cursor: pointer;
+}
+.tsd-price-reset:hover {
+  border-color: var(--dsw-alias-border-l2);
+  color: var(--dsw-alias-label-primary);
+}
+.tsd-price-reset:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 1px;
+}
+.tsd-btn-xs {
+  height: 24px;
+  padding: 0 8px;
+  font-size: 12px;
+  border-radius: 6px;
+}
+/* 带图标的按钮：图标与文字同一行，间距由 gap 给，别在文案里塞空格 */
+.tsd-btn-icon-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+/* 参考模型候选是一座浮层（DSH 自己的模型选择器就是这种交互），不再塞进表格里：
+   内联面板会把所在行撑高、把下面的行整体推走，看起来像表格坏了。 */
+.tsd-price-pick-box {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  min-height: 0;
+  padding: 6px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 10px;
+  background: var(--dsw-alias-bg-layer-1);
+  box-shadow: var(--dsw-shadow-lv3);
+}
+/* 四态徽标：精确(蓝) / 模糊(琥珀) / 未匹配(灰) / 自定义(绿)，颜色族都用真实 token */
+.tsd-price-badge {
+  display: inline-block;
+  padding: 1px 7px;
+  border-radius: 10px;
+  font-size: 11px;
+  line-height: 16px;
+  white-space: nowrap;
+  background: var(--dsw-static-neutral-200, rgba(128, 128, 128, 0.14));
+  color: var(--dsw-alias-label-secondary);
+}
+.tsd-price-badge[data-state='exact'] {
+  background: color-mix(in oklab, var(--dsw-static-deepseek-500) 16%, transparent);
+  color: var(--dsw-static-deepseek-500);
+}
+.tsd-price-badge[data-state='fuzzy'] {
+  background: color-mix(in oklab, var(--dsw-static-amber-500) 18%, transparent);
+  color: var(--dsw-static-amber-500);
+}
+.tsd-price-badge[data-state='custom'] {
+  background: color-mix(in oklab, var(--dsw-static-green-500) 16%, transparent);
+  color: var(--dsw-static-green-500);
+}
+/* 未匹配态没有主题色可用：容器那层 background: none 把徽标底色抹掉了，只剩
+   白字压在白底上。这里给它自己的底与字色，四态才都能看见。 */
+.tsd-price-row[data-state='none'] .tsd-price-badge {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-secondary);
+}
+.tsd-price-pick-input {
+  box-sizing: border-box;
+  width: 100%;
+  height: 28px;
+  padding: 0 8px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: 6px;
+  background: var(--dsw-alias-bg-layer-1);
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 12px;
+}
+/* 候选列表自己滚，且必须自己封顶：useFixedPanel 只给位置和宽度，不给高度，
+   89 个 id 摊开有近 2000px，不封顶就是一个超出视口的浮层。 */
+.tsd-price-pick-list {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  max-height: 260px;
+  overflow: auto;
+}
+.tsd-price-pick-item {
+  padding: 4px 8px;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 12px;
+  text-align: left;
+  cursor: pointer;
+}
+.tsd-price-pick-item:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.tsd-price-pick-item-active { color: var(--dsw-static-deepseek-500); font-weight: 600; }
+.tsd-price-history {
+  margin-top: 14px;
+  padding-top: 10px;
+  border-top: 1px solid var(--dsw-alias-border-l2);
+}
+.tsd-price-history-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 2px 0;
+  border: none;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  font: inherit;
+  font-size: 12px;
+  cursor: pointer;
+}
+.tsd-price-history-chev { transition: transform 0.15s ease; }
+.tsd-price-history-chev-open { transform: rotate(180deg); }
+.tsd-price-empty,
+.tsd-price-loading {
+  padding: 18px 0;
+  font-size: 12px;
+  color: var(--dsw-alias-label-tertiary);
+  text-align: center;
+}
+.tsd-price-foot {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 12px;
+  padding-top: 10px;
+  border-top: 1px solid var(--dsw-alias-border-l2);
+}
+.tsd-price-hint {
+  margin-left: auto;
+  font-size: 11px;
+  color: var(--dsw-alias-state-warn-primary);
+}
 `
 
 // 0.2+ host transport: POST /api/<channel>/<endpoint>, args as the JSON body,
@@ -1183,43 +1690,147 @@ function callFetch(channel, endpoint, args) {
     }
     return res.json().then((body) => {
       if (body && body.ok) return body.value
-      throw new Error((body && body.error && body.error.message) || ('RPC ' + endpoint + ' failed'))
+      throw rpcError(body && body.error, 'RPC ' + endpoint + ' failed')
     })
   })
 }
 
+/**
+ * 把宿主返回的 `{code, message}` 变成可显示的错误。
+ *
+ * 宿主对未处理的异常只发稳定的 `internal`，细节写在宿主日志里；界面上显示本插件的
+ * 一句话，而不是原始堆栈（原始错误不上页面）。
+ */
+function rpcError(error, fallback) {
+  const code = error && error.code
+  const message = code === 'internal' ? fallbackT('rpcInternalError') : ((error && error.message) || fallback)
+  const wrapped = new Error(message)
+  if (code) wrapped.code = code
+  return wrapped
+}
+
 // RPC bridge: dynamic-plugin runs provide a `host` global; static (bundle)
 // installs provide ctx.get('connection'). Keep one UI source for both.
+//
+// Channel preference, native first: the plugin's own typert Remote namespace
+// (`remote['dsh-plugin-usage']`, registered by src/host/typert.js), then the
+// Fetch routes on Connection's shared /api channel, then the legacy /usage
+// prefix channel. A Remote namespace that exists but fails (host restarted
+// mid-flight, receiver gone) must fall through instead of bricking the page.
+const USAGE_REMOTE_NAMESPACE = 'dsh-plugin-usage'
+
+/**
+ * Descriptors for the client-side mount.
+ *
+ * The gateway's browser half wants a `src-json` result (a direct invocation is
+ * not result-decoded), while the host contribution declares a strict codec.
+ * Everything else must match the host field for field.
+ */
+function remoteDescriptors(packageName, names) {
+  const argsCodec = () => ({
+    mode: 'strict',
+    typeSymbol: packageName + '/typert#EndpointArgs',
+    create: () => ({ parse: (value) => value }),
+  })
+  return names.map((name) => ({
+    id: packageName + '#' + packageName + '/' + name,
+    service: packageName,
+    namespace: packageName,
+    method: name,
+    invocation: { kind: 'direct' },
+    parameters: [{ name: 'args', wire: 'args', source: 'json', codec: argsCodec() }],
+    result: { mode: 'src-json' },
+  }))
+}
+
+/**
+ * Join the native Remote channel on the browser side.
+ *
+ * A face registered at runtime on the host is invisible to the client's `remote`
+ * proxy until the consumer mounts it. Until the mount lands — or if it never
+ * does — hostCall keeps using the Fetch routes, so this is an optimization,
+ * never a hard dependency.
+ */
+function mountRemoteChannel(scope) {
+  let remote = null
+  try {
+    remote = scope.get('remote')
+  } catch (e) {
+    return
+  }
+  if (!remote || typeof remote.$mount !== 'function') return
+  fetchCall('usage/contract', {}).then((contract) => {
+    const names = contract && Array.isArray(contract.names) ? contract.names : []
+    if (names.length === 0) return null
+    const packageName = contract.package || USAGE_REMOTE_NAMESPACE
+    return Promise.resolve(remote.$mount({ package: packageName, descriptors: remoteDescriptors(packageName, names) }))
+  }).catch(() => {
+    // Stay on the Fetch routes; the host reports which channel it opened.
+  })
+}
+
+function remoteCall(scope, method, args) {
+  const name = String(method)
+  const slash = name.indexOf('/')
+  const endpoint = slash === -1 ? name : name.slice(slash + 1)
+  const camel = endpoint.replace(/-([a-z])/g, (m, c) => c.toUpperCase())
+  for (const service of [USAGE_REMOTE_NAMESPACE, 'usage']) {
+    // `ctx.get('remote.<namespace>')` is the service key the gateway creates per
+    // face (dsh-api-gateway client: remoteServiceKey). The `remote[namespace]`
+    // property is the older shape and throws on the strict proxy, so it is a
+    // guarded second choice.
+    let namespace = null
+    try {
+      namespace = scope.get('remote.' + service)
+    } catch (e) {
+      namespace = null
+    }
+    if (!namespace) {
+      try {
+        const remote = scope.get('remote')
+        namespace = remote ? remote[service] : null
+      } catch (e) {
+        namespace = null
+      }
+    }
+    if (!namespace) continue
+    const fn = (typeof namespace[camel] === 'function' && namespace[camel])
+      || (typeof namespace[endpoint] === 'function' && namespace[endpoint])
+    if (!fn) continue
+    return Promise.resolve()
+      .then(() => fn(args))
+      .then((res) => {
+        if (res && res.ok) return res.value
+        throw rpcError(res && res.error, 'RPC ' + method + ' failed')
+      })
+  }
+  return null
+}
+
 function hostCall(method, args) {
-  // P0-3: prefer the official `remote` service when it exposes the usage API;
-  // otherwise fall through to the host/connection fallbacks unchanged.
   const remoteScope = (typeof ctx !== 'undefined' && ctx && typeof ctx.get === 'function')
     ? ctx
     : (typeof _usageCtx !== 'undefined' && _usageCtx && typeof _usageCtx.get === 'function' ? _usageCtx : null)
   if (remoteScope && typeof remoteScope.get === 'function') {
+    let pending = null
     try {
-      const remote = remoteScope.get('remote')
-      if (remote && remote.usage) {
-        const rName = String(method)
-        const rSlash = rName.indexOf('/')
-        const rEp = rSlash === -1 ? rName : rName.slice(rSlash + 1)
-        const rCamel = rEp.replace(/-([a-z])/g, (m, c) => c.toUpperCase())
-        const fn = (typeof remote.usage[rCamel] === 'function' && remote.usage[rCamel])
-          || (typeof remote.usage[rEp] === 'function' && remote.usage[rEp])
-        if (fn) {
-          return Promise.resolve().then(() => fn(args)).then((res) => {
-            if (res && res.ok) return res.value
-            throw new Error((res && res.error && res.error.message) || ('RPC ' + method + ' failed'))
-          })
-        }
-      }
+      pending = remoteCall(remoteScope, method, args)
     } catch (e) {
-      // remote probing failed — fall through to the existing fallbacks
+      pending = null
+    }
+    if (pending !== null) {
+      // Fall through to the Fetch routes when the Remote namespace turns out to
+      // be unreachable — the two channels answer the same question.
+      return pending.catch(() => fetchCall(method, args))
     }
   }
   if (typeof host !== 'undefined' && host && typeof host.call === 'function') {
     return Promise.resolve(host.call(method, args))
   }
+  return fetchCall(method, args)
+}
+
+function fetchCall(method, args) {
   // Static bundle installs have no ctx/host globals: the entry apply() stores
   // the real context in _usageCtx (declared by the build wrapper).
   const scope = (typeof ctx !== 'undefined' && ctx && typeof ctx.get === 'function')
@@ -1241,7 +1852,7 @@ function hostCall(method, args) {
     }
     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'))
+      throw rpcError(res && res.error, 'RPC ' + method + ' failed')
     })
   }
   // Prefer the shared-channel Fetch route; an older host answers "route
@@ -1259,6 +1870,20 @@ function hostCall(method, args) {
  * 设置域定价：官方 `ctx.configForms.get('usage')`（dsh-client-ui-settings）优先，
  * 不可用时回退 usage/prices RPC。绑定只做一次，读写共用同一 form。
  * ------------------------------------------------------------------------- */
+/**
+ * 原生日志通道：宿主有 logger 就写它（官方插件都走 ctx.logger），否则退回 console。
+ * ctx 是严格代理，未注入的属性能抛，所以整段包在 try 里。
+ */
+function logWarn(message, detail) {
+  try {
+    const scope = (typeof _usageCtx !== 'undefined' && _usageCtx) ? _usageCtx : null
+    const logger = scope && typeof scope.get === 'function' ? scope.get('logger') : null
+    if (logger && typeof logger.warn === 'function') { logger.warn(message, detail); return }
+    if (scope && scope.logger && typeof scope.logger.warn === 'function') { scope.logger.warn(message, detail); return }
+  } catch (e) { /* no logger on this composition */ }
+  console.warn(message, detail)
+}
+
 let usageCtx = null
 let _usagePricesScope = null
 
@@ -1358,6 +1983,55 @@ const ZH = {
   cost: '参考成本',
   approxIO: '≈ 输入+输出',
   unpricedNote: '{count} 次调用未定价',
+  // 参考成本卡上的常驻脚注：口径（卡片是估算而不是账单）+ 高峰规则（单价按
+  // 北京时间分峰谷，不说清楚就等于藏了一条计价条件）。
+  costSourceNote: '按 opencode Zen 和 DeepSeek 最新定价口径估算',
+  peakRuleShort: '北京时间周一至周五 9:00-12:00、14:00-18:00 为高峰，法定节假日除外',
+  holidayNote: '节假日数据：{range}',
+  holidayNoteUnpublished: '节假日数据：{range}；{years} 尚未公布，该年按周末判定（落在高峰窗口的节假日可能被算高）',
+  pricingOpen: '拉取最新定价匹配',
+  pricingTitle: '定价匹配',
+  pricingDesc: '本会话出现过的模型会按名称逐级匹配到定价表；未匹配的按 0 计价，计入「未定价」。',
+  pricingPull: '更新匹配表',
+  pricingHistory: '历史匹配（{n}）',
+  pricingHistoryEmpty: '还没有确认过的匹配',
+  pricingColModel: '模型',
+  pricingColMatch: '匹配到',
+  pricingColState: '状态',
+  pricingColPrice: '单价（{unit} / 1M）',
+  pricingSave: '确定',
+  pricingClear: '恢复自动匹配',
+  pricingApplyHint: '改完点「确定」才生效',
+  pricingHowAlias: '按别名',
+  // 模糊态的徽标：别名、孪生、变体后缀（-fast / -1017 / -free）都落在这一态，
+  // 所以文案说「推测」而不是某一种推断的名字；具体依据看徽标的 tooltip。
+  pricingHowTwin: '按名称推测',
+  pricingHowLiteral: '按名称精确',
+  pricingHowCustom: '用户指定',
+  // 未匹配态的徽标文案。原来 MATCH_STATE_LABEL 指向一个不存在的键
+  // 'unmatched'，t() 缺键时原样返回 key，于是徽标上印着英文 "unmatched"。
+  pricingHowNone: '未匹配',
+  pricingStale: '定价表里已没有这个模型',
+  pricingTableMeta: '数据源 {source} · 读取于 {date}',
+  pricingCounts: '精确 {exact} · 模糊 {fuzzy} · 未匹配 {none} · 自定义 {custom}',
+  pricingBothTiers: '高峰 {peak} · 空闲 {off}',
+  pricingSourceDeepseek: 'DeepSeek',
+  pricingSourceZen: 'Zen',
+  pricingSourceCustom: '自定义',
+  // 「自定义」是选择器顶部的一个选项，不是一组参考模型：选它就直接给这一行填三个单价。
+  pricingCustomOption: '自定义',
+  pricingCustomHint: '直接填每百万 Token 的单价',
+  pricingCustomInput: '输入',
+  pricingCustomOutput: '输出',
+  pricingCustomCacheRead: '缓存读',
+  pricingCustomUnit: '单位：{unit} / 1M Token',
+  pricingCustomPending: '待填写',
+  rpcInternalError: '统计服务出错了，细节已写进宿主日志',
+  done: '完成',
+  pricingCardNoteTip: '参考成本的算法、匹配范围与高峰时段规则',
+  askEmpty: '暂无待匹配的模型',
+  askPick: '选择参考模型',
+  pricingFailed: '定价表拉取失败：{message}',
   dailyTrend: '每日用量趋势',
   barView: '柱状图',
   lineView: '折线图',
@@ -1393,14 +2067,16 @@ const ZH = {
   unpriced: '未定价',
   unpricedRowHint: '该模型未配置定价，按 0 计价',
   noData: '暂无数据',
+  loading: '正在加载用量数据…',
+  computing: '正在统计 {done}/{total} 个会话…',
   emptyDesc: '该时间段内没有调用记录',
   emptyFiltered: '当前筛选条件下没有数据，试试调整时间范围或模型',
   resetFilters: '重置筛选',
   loadFailed: '数据加载失败：{message}',
   loadFailedTitle: '数据加载失败',
   retry: '重试',
-  barAria: '{key}，输入 {in} Token，输出 {out} Token，合计 {tot} Token',
-  hmTitle: '{key}：{tokens} Token{calls}',
+  barAria: '{key}，输入 {in} Token，输出 {out} Token，合计 {tot} Token，参考成本 {cost}',
+  hmTitle: '{key}：{tokens} Token{calls}，参考成本 {cost}',
   hmCalls: '，{count} 次调用',
   wd0: '周日',
   wd1: '周一',
@@ -1449,6 +2125,48 @@ const EN = {
   cost: 'Est. cost',
   approxIO: '≈ input+output',
   unpricedNote: '{count} calls unpriced',
+  costSourceNote: 'Estimated from the current opencode Zen and DeepSeek price lists',
+  peakRuleShort: 'Peak: Mon-Fri 09:00-12:00 and 14:00-18:00 Beijing time, excluding public holidays',
+  holidayNote: 'Holiday calendar: {range}',
+  holidayNoteUnpublished: 'Holiday calendar: {range}; {years} is not published yet, so that year falls back to the weekend rule (a holiday inside a peak window may be billed high)',
+  pricingOpen: 'Pull the latest price matching',
+  pricingTitle: 'Price matching',
+  pricingDesc: 'Models seen in this session are matched to the price list by name, one level at a time. Anything unmatched is billed at 0 and listed under unpriced.',
+  pricingPull: 'Update matches',
+  pricingHistory: 'Confirmed matches ({n})',
+  pricingHistoryEmpty: 'No match has been confirmed yet',
+  pricingColModel: 'Model',
+  pricingColMatch: 'Matched to',
+  pricingColState: 'State',
+  pricingColPrice: 'Rate ({unit} / 1M)',
+  pricingSave: 'Apply',
+  pricingClear: 'Back to automatic',
+  pricingApplyHint: 'Nothing changes until you press Apply',
+  pricingHowAlias: 'by alias',
+  pricingHowTwin: 'inferred from the name',
+  pricingHowLiteral: 'by exact name',
+  pricingHowCustom: 'set by you',
+  pricingHowNone: 'unmatched',
+  pricingStale: 'This model is no longer in the price list',
+  pricingTableMeta: 'Sources {source} · read {date}',
+  pricingCounts: 'exact {exact} · fuzzy {fuzzy} · unmatched {none} · custom {custom}',
+  pricingBothTiers: 'Peak {peak} · off-peak {off}',
+  pricingSourceDeepseek: 'DeepSeek',
+  pricingSourceZen: 'Zen',
+  pricingSourceCustom: 'Custom',
+  pricingCustomOption: 'Custom',
+  pricingCustomHint: 'Type the per-million rates by hand',
+  pricingCustomInput: 'Input',
+  pricingCustomOutput: 'Output',
+  pricingCustomCacheRead: 'Cache read',
+  pricingCustomUnit: 'Unit: {unit} per 1M tokens',
+  pricingCustomPending: 'not set',
+  rpcInternalError: 'The usage service failed — details are in the host log',
+  done: 'Done',
+  pricingCardNoteTip: 'How the reference cost is estimated, which models it covers, and the peak-hour rule',
+  askEmpty: 'No model is waiting to be matched',
+  askPick: 'Choose a reference model',
+  pricingFailed: 'Could not load the price lists: {message}',
   dailyTrend: 'Daily usage trend',
   barView: 'Bars',
   lineView: 'Line',
@@ -1484,14 +2202,16 @@ const EN = {
   unpriced: 'Unpriced',
   unpricedRowHint: 'No pricing configured; counted as 0',
   noData: 'No data',
+  loading: 'Loading usage data…',
+  computing: 'Computing {done}/{total} sessions…',
   emptyDesc: 'No calls in this period',
   emptyFiltered: 'No data for the current filters, try adjusting the range or models',
   resetFilters: 'Reset filters',
   loadFailed: 'Failed to load data: {message}',
   loadFailedTitle: 'Failed to load data',
   retry: 'Retry',
-  barAria: '{key}, input {in} tokens, output {out} tokens, total {tot} tokens',
-  hmTitle: '{key}: {tokens} tokens{calls}',
+  barAria: '{key}, input {in} tokens, output {out} tokens, total {tot} tokens, {cost} reference cost',
+  hmTitle: '{key}: {tokens} tokens{calls}, {cost} reference cost',
   hmCalls: ', {count} calls',
   wd0: 'Sun',
   wd1: 'Mon',
@@ -1678,6 +2398,31 @@ const ICON_PATHS = {
   // 饼图（占比）：外圈 + 楔形，与卡片标题的「占比」语义一致
   share: 'M21.21 15.89A10 10 0 118 2.83M22 12A10 10 0 0012 2v10z',
   check: 'M20 6L9 17l-5-5',
+  x: 'M6 6l12 12M18 6L6 18',
+  // 拉取匹配表按钮的图标：DSH 原生 icon-context-injection-outline。16 网格、
+  // 线宽 1.5；图形是「剪贴板 + 从顶部穿入的下载箭头 + 一条内容线」，描边沿用
+  // 外层的 currentColor，所以每条 path 只给 d。
+  contextInjection: {
+    viewBox: '0 0 16 16',
+    strokeWidth: 1.5,
+    paths: [
+      'M5 2.5H3.5C3.23478 2.5 2.98043 2.60536 2.79289 2.79289C2.60536 2.98043 2.5 3.23478 2.5 3.5V13.5C2.5 13.7652 2.60536 14.0196 2.79289 14.2071C2.98043 14.3946 3.23478 14.5 3.5 14.5H12.5C12.7652 14.5 13.0196 14.3946 13.2071 14.2071C13.3946 14.0196 13.5 13.7652 13.5 13.5V3.5C13.5 3.23478 13.3946 2.98043 13.2071 2.79289C13.0196 2.60536 12.7652 2.5 12.5 2.5H11',
+      'M8 0.5V7.5',
+      'M5.5 5L8 7.5L10.5 5',
+      'M5.5 11H10.5',
+    ],
+  },
+  // 提示记号：圆圈 + 感叹号（16 网格、线宽 1.5）。原来用一个 CSS 伪元素画「?」，
+  // 字重太小、缩到 10px 后几乎看不见，也不能点；换成真图标后可以当按钮用。
+  hint: {
+    viewBox: '0 0 16 16',
+    strokeWidth: 1.5,
+    paths: [
+      'M8 1.75a6.25 6.25 0 1 1 0 12.5a6.25 6.25 0 1 1 0-12.5Z',
+      'M8 4.9v3.5',
+      'M8 11.15h.01',
+    ],
+  },
 }
 function SvgIcon(props) {
   const { name, size, className } = props
@@ -1771,18 +2516,25 @@ function useFixedPanel(anchorRef, open, width, gap = 6, margin = 12) {
  * Header：标题 + 副标题 + 刷新按钮
  * ------------------------------------------------------------------------- */
 function StatsHeader(props) {
-  const { busy, onRefresh } = props
+  // `computing` 表示"统计还没算完"（宿主 backfill.status === 'running'），
+  // 和 `busy`（这一轮请求在飞）不是一回事：请求几十毫秒就结束，而全量统计要几秒。
+  // 只在请求在飞时转圈，用户就会看到"页面明明没算完却什么都不动"。
+  const { busy, onRefresh, computing, computeDone, computeTotal } = props
   const t = useT()
+  const subtitle = computing
+    ? t('computing', { done: formatInt(computeDone || 0), total: formatInt(computeTotal || 0) })
+    : t('subtitle')
   return h('div', { className: 'tsd-header' },
     h('div', { className: 'tsd-header-text' },
       h('h2', { className: 'tsd-title' }, t('nav')),
-      h('p', { className: 'tsd-subtitle' }, t('subtitle'))),
+      // 副标题这一句直接换成进度句：同一个位置、同样的行高，所以不算完→算完不跳版。
+      h('p', { className: 'tsd-subtitle', role: computing ? 'status' : null }, subtitle)),
     h('button', {
       type: 'button',
-      className: 'tsd-icon-btn' + (busy ? ' tsd-spinning' : ''),
+      className: 'tsd-icon-btn' + (busy || computing ? ' tsd-spinning' : ''),
       onClick: onRefresh,
       disabled: busy,
-      'aria-busy': busy || undefined,
+      'aria-busy': busy || computing || undefined,
       title: t('refresh'),
       'aria-label': t('refresh'),
     }, h(SvgIcon, { name: 'refresh' })))
@@ -2089,6 +2841,20 @@ function shortModelName(key) {
   const i = s.lastIndexOf('/')
   return i === -1 ? s : s.slice(i + 1)
 }
+/**
+ * 「读取于」要的是真实时刻，不是日期。
+ *
+ * 价目表里存的是抓取那一刻的 ISO 时间（带秒、UTC）；这里换成浏览器本地时区
+ * 显示，精确到秒。早期只有日期（`2026-10-19`）的表也认得，补 00:00:00。
+ */
+function stampText(v) {
+  if (!v) return '—'
+  const d = new Date(v)
+  if (Number.isNaN(d.getTime())) return String(v)
+  const p = (n) => (n < 10 ? '0' + n : String(n))
+  return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) +
+    ' ' + p(d.getHours()) + ':' + p(d.getMinutes()) + ':' + p(d.getSeconds())
+}
 /** 宿主行是 `totalTokens`；兼容已映射成 `total` 的形状，空行也不能抛。 */
 function rowTotal(r) {
   return r ? (r.totalTokens || r.total || 0) : 0
@@ -2146,7 +2912,7 @@ function ModelShareBar(props) {
   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))
+  const costOf = (s) => (s.unpriced === true ? t('unpriced') : formatCost(s.cost, currency))
   // 悬停/聚焦：从段的视口矩形推开，fixed 定位不受设置面板 overflow 裁剪
   const showTip = (e, s) => {
     const r = e.currentTarget.getBoundingClientRect()
@@ -2196,11 +2962,76 @@ function ModelShareBar(props) {
     tipBox)
 }
 
+/* ---------------------------------------------------------------------------
+ * 标题旁的提示记号
+ *
+ * 「点击 / 悬浮双显示」是硬要求：
+ *  - 悬浮走原生 title（浏览器自己弹，不依赖脚本，也不会被设置面板的 overflow 裁掉）；
+ *  - 点击展开同一个浮层 —— 触屏没有 hover，键盘也要能读到，且浮层里两段规则换行
+ *    读起来比一整行 tooltip 清楚得多。
+ * 原生 title 与浮层共用同一份文本（宿主/调用方只传一次），不维护第二份文案。
+ * ------------------------------------------------------------------------- */
+function HintTip(props) {
+  const { text, label } = props
+  const [open, setOpen] = React.useState(false)
+  const ref = React.useRef(null)
+  const panelStyle = useFixedPanel(ref, open, 260)
+  useOutsideClick(open, ref, () => setOpen(false))
+  const lines = String(text == null ? '' : text).split('\n').filter((s) => s.trim().length > 0)
+  return h('span', { className: 'tsd-hint', ref },
+    h('button', {
+      type: 'button',
+      className: 'tsd-hint-btn' + (open ? ' tsd-hint-btn-open' : ''),
+      title: text || null,
+      'aria-label': label || text || '',
+      'aria-expanded': open,
+      onClick: () => setOpen((v) => !v),
+      onKeyDown: (e) => {
+        if (e.key === 'Escape' && open) { e.stopPropagation(); setOpen(false) }
+      },
+    }, h(SvgIcon, { name: 'hint', size: 12 })),
+    open
+      ? h('div', {
+          className: 'tsd-popover tsd-hint-popover',
+          style: panelStyle,
+          role: 'note',
+        }, lines.map((s, i) => h('p', { key: i, className: 'tsd-hint-line' }, s)))
+      : null)
+}
+
 /* ---------------------------------------------------------------------------
  * 汇总指标卡 ×6
  * ------------------------------------------------------------------------- */
+
+/**
+ * 节假日覆盖说明：哪些年份在手、哪一年还没公布。
+ *
+ * 峰谷价依赖中国法定节假日表；未公布的年份只能按「周末 + 时段」判定，节假日
+ * 落在高峰窗口内的调用会被算高。与其让这个误差隐身，不如在「参考成本」的提示
+ * 里把覆盖范围写清楚。
+ */
+function holidayNote(pricing, t) {
+  const years = pricing && pricing.holidays && typeof pricing.holidays === 'object'
+    ? Object.keys(pricing.holidays).map(Number).filter((n) => Number.isFinite(n)).sort((a, b) => a - b)
+    : []
+  if (years.length === 0) return null
+  const range = years.length === 1 ? String(years[0]) : years[0] + '–' + years[years.length - 1]
+  const missing = years.filter((year) => pricing.holidays[year] && pricing.holidays[year].unpublished === true)
+  if (missing.length === 0) return t('holidayNote', { range })
+  return t('holidayNoteUnpublished', { range, years: missing.join('、') })
+}
+
+/* 统计卡的槽位表：骨架屏按它画占位块。
+ *
+ * 这张表存在的唯一理由是**别再漂**：骨架屏曾经写死 5 个占位块，而真实卡片已经
+ * 6 张（补了「模型占比」），结果加载态少一格、数据到达时整行重排。
+ * 槽位顺序必须与 `SummaryCards` 里的 `cards` 数组一致 —— `tests/client-slots.test.js`
+ * 会逐字比对两边的 key 列表，改一处漏另一处直接变红。
+ */
+const SUMMARY_CARD_SLOTS = ['total', 'input', 'output', 'calls', 'cost', 'share']
+
 function SummaryCards(props) {
-  const { total, currency, unpricedCalls, currencyCode, onCurrencyChange, byModel } = props
+  const { total, currency, unpricedCalls, currencyCode, onCurrencyChange, byModel, pricing, onOpenPricing } = props
   const tt = useT()
   const d = total || {}
   const inputTotal = (d.inputTokens || 0) + (d.cacheReadTokens || 0) + (d.cacheWriteTokens || 0)
@@ -2226,11 +3057,15 @@ function SummaryCards(props) {
       color: 'var(--dsw-static-deepseek-500)',
     },
     {
-      key: 'cost', icon: 'coins', label: tt('cost'),
+      key: 'cost', icon: 'coins', label: tt('cost'), action: true,
       // 符号由 prefix 的币种切换器画（它显示当前币种符号），这里只给数字
       value: costDigits(d.cost), title: formatCost(d.cost, currency),
       color: 'var(--dsw-static-green-500)',
       prefix: h(CurrencyPicker, { code: currencyCode, onChange: onCurrencyChange }),
+      // 「这个数怎么来的」：口径句与高峰规则原本是两行常驻小字，把小卡挤满了，
+      // 改成标题的悬浮提示 —— 不在视野里占位，指一下就能读到全文。
+      // 未定价条数仍然留在卡面上：它是一条待办，不是解释。
+      tip: [tt('costSourceNote'), tt('peakRuleShort'), holidayNote(pricing, tt)].filter(Boolean).join('\n'),
     },
     {
       key: 'share', icon: 'share', label: tt('modelShare'),
@@ -2244,21 +3079,602 @@ function SummaryCards(props) {
         h('div', { className: 'tsd-card-head' },
           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('span', { className: 'tsd-card-label', title: c.tip || null }, c.label),
+          // 提示记号是独立按钮：悬浮有原生 title，点击展开浮层。
+          c.tip ? h(HintTip, { text: c.tip, label: tt('pricingCardNoteTip') }) : null,
+          // 参考成本卡的「怎么算出来的」入口：打开匹配弹窗。图标与弹窗里的
+          // 「更新匹配表」同款（剪贴板），一眼看出两者是同一件事。
+          c.action
+            ? h('button', {
+                type: 'button',
+                className: 'tsd-card-action',
+                title: tt('pricingOpen'),
+                'aria-label': tt('pricingOpen'),
+                onClick: onOpenPricing,
+              }, h(SvgIcon, { name: 'contextInjection', size: 12 }))
+            : null),
         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) }))
-          : null)))
+          ? h('div', { className: 'tsd-card-notes' },
+              h('div', { className: 'tsd-card-note tsd-card-note-warn' }, tt('unpricedNote', { count: formatInt(unpricedCalls) })))
+          : null,
+        c.sub ? h('div', { className: 'tsd-card-sub' }, c.sub) : null)))
+}
+
+/* ---------------------------------------------------------------------------
+ * 定价匹配弹窗
+ *
+ * 解决的是「参考成本为什么是这个数」：每个模型按名称逐级匹配到定价表，匹配
+ * 结果分四态（精确 / 模糊 / 未匹配 / 自定义），四态都能改、都能收回。
+ *
+ * 两条硬规则写在这里，别处不要各写一份：
+ *  1. 打开弹窗、拉取匹配表都**不落盘**。只有「确定」才写，写入的是脏行和被
+ *     收回的 key —— 没动过的行不写，免得把别人刚确认的匹配覆盖掉。
+ *  2. 候选来自当前定价表的 id（宿主 propose 一并带回），不在前端另存一份名单。
+ * ------------------------------------------------------------------------- */
+const MATCH_STATE_LABEL = { exact: 'pricingHowLiteral', fuzzy: 'pricingHowTwin', none: 'pricingHowNone', custom: 'pricingHowCustom' }
+
+/*
+ * 四态由宿主给（priceRow.state），前端不再解释 how。
+ * 这里曾经有一份 matchStateOf(row)，把 how 映射成四态；它写死了一个阶梯里不存在
+ * 的值（'literal'），于是所有精确命中都显示成「未匹配」——两个词表，两处维护，
+ * 一处错就全错。现在只有一处：pricing.js 的 resolvePrice。
+ */
+
+/** 弹窗里改动的草稿：key → { target, cleared, dirty }。 */
+function mergeDraft(prev, key, patch) {
+  const next = { ...prev }
+  const cur = next[key] || { target: null, cleared: false, dirty: false }
+  next[key] = { ...cur, ...patch, dirty: true }
+  return next
+}
+
+/** 一行提交时会带什么：`undefined` = 没动过，不提交。 */
+function decisionOf(draft) {
+  if (!draft || !draft.dirty) return undefined
+  if (draft.cleared) return { key: draft.key, clear: true }
+  if (typeof draft.target === 'string' && draft.target !== '') return { key: draft.key, target: draft.target }
+  return undefined
+}
+
+function PricingDialog(props) {
+  const { onClose, onApplied, currency } = props
+  const t = useT()
+  const [rows, setRows] = React.useState([])
+  const [table, setTable] = React.useState(null)
+  const [saved, setSaved] = React.useState({})
+  const [draft, setDraft] = React.useState({})
+  const [status, setStatus] = React.useState('loading') // loading | ready | error
+  const [error, setError] = React.useState(null)
+  const [saving, setSaving] = React.useState(false)
+  const [pickFor, setPickFor] = React.useState(null) // 正在选参考模型的 key
+  const [pickText, setPickText] = React.useState('')
+  const [editFor, setEditFor] = React.useState(null) // 正在手填单价的 key（自定义选项）
+  const [historyOpen, setHistoryOpen] = React.useState(false)
+  // 候选列表挂在行内「匹配到」那一格上：浮层是 position: fixed，撑不开表格；
+  // 但 DOM 上仍留在那一格里 —— useOutsideClick 用 contains 判内外，必须这样挂。
+  const pickAnchor = React.useRef(null)
+  const closePick = React.useCallback(() => {
+    setPickFor(null)
+    setPickText('')
+  }, [])
+  const pickStyle = useFixedPanel(pickAnchor, pickFor !== null, 300, 4, 12)
+  const customStyle = useFixedPanel(pickAnchor, editFor !== null, 280, 4, 12)
+  useOutsideClick(pickFor !== null, pickAnchor, closePick)
+
+  const pull = React.useCallback(() => {
+    setStatus('loading')
+    setError(null)
+    hostCall('usage/query', { fill: false, models: [], heatmap: false, backfill: false })
+      .then((r) => {
+        const seen = Array.isArray(r && r.models) ? r.models : []
+        return hostCall('usage/pricing', { action: 'propose', models: seen })
+      })
+      .then((v) => {
+        setRows(Array.isArray(v && v.rows) ? v.rows : [])
+        setTable(v && v.table ? v.table : null)
+        setSaved(v && v.matchMap ? v.matchMap : {})
+        setDraft({})
+        setStatus('ready')
+      }, (e) => {
+        setError(e)
+        setStatus('error')
+      })
+  }, [])
+
+  React.useEffect(() => { pull() }, [pull])
+
+  const counts = React.useMemo(() => {
+    const n = { exact: 0, fuzzy: 0, none: 0, custom: 0 }
+    // 每一行都自带 state（宿主 priceRow 给的），前端不再从 how 反推 —— 反推过
+    // 一次，写死的 'literal' 阶梯里根本不存在，所有精确命中都显示成「未匹配」。
+    for (const r of rows) n[r.state] += 1
+    return n
+  }, [rows])
+
+  // 单价本身是美元价（价目表就是美元），显示时套用当前展示币种，和卡片同一个数。
+  const moneyPerUsd = React.useCallback(() => (currency && currency.code === 'USD' ? 1 : 7), [currency])
+  const moneyOf = React.useCallback((usd) => {
+    const code = currency && currency.code === 'USD' ? 'USD' : 'CNY'
+    const symbol = currency && currency.symbol ? currency.symbol : (CURRENCY_SYMBOLS[code] || '¥')
+    return typeof usd === 'number' ? formatCost(usd * (code === 'USD' ? 1 : 7), symbol) : '—'
+  }, [currency])
+  // 表头单位必须和单元格用的是同一个符号，否则会出现「单价（$ / 1M）」配「¥2.10」。
+  const priceUnit = (currency && currency.symbol) || '¥'
+
+  // 待选 = 阶梯没找到价的行。判据用 state 而不是 unpriced：`unpriced` 是查询那边
+  // 「某条记录没价」的字段，propose 的行从来没有它 —— 拿它当过滤条件的后果是待选
+  // 表永远是空的，未匹配的模型一行都露不出来。
+  const pending = rows.filter((r) => r.state === 'none')
+  // 历史表 = 已经写进 matchMap 的 confirmed 记录。判据只看 matchMap：目标若已从
+  // 价目表下线，这一行仍然留在这里（还能收回），主表里则按「未匹配」显示并标 stale。
+  const historyRows = rows.filter((r) => saved[r.key] !== undefined)
+  const pendingRows = pending.filter((r) => !historyRows.includes(r))
+  const matchedRows = rows.filter((r) => r.state !== 'none' && !historyRows.includes(r))
+  // 空状态判的是主表有没有行。此前判的是 `pending.length` —— 只要有模型按阶梯
+  // 命中了价，第一张表就整块消失，于是「精确 / 模糊」两种状态永远没机会露面。
+  const hasMainRows = pendingRows.length > 0 || matchedRows.length > 0
+
+  // 注意：组件里的 `setDraft` 是 useState 的 setter，不是上面那个纯函数。
+  // 写成 setDraft((prev) => setDraft(prev, ...)) 会递归调自己（初值 undefined），
+  // 所以这里用纯函数的名字 `mergeDraft` 区分开。
+  const choose = (key, target) => {
+    setDraft((prev) => mergeDraft(prev, key, { target, cleared: false, custom: null, key }))
+    setEditFor(null)
+    closePick()
+  }
+  const clearRow = (key) => {
+    setDraft((prev) => mergeDraft(prev, key, { target: null, cleared: true, custom: null, key }))
+    setEditFor((k) => (k === key ? null : k))
+  }
+
+  /** 手填单价：三格，都是「每百万 Token」的展示币种金额。 */
+  const CUSTOM_FIELDS = [['input', 'pricingCustomInput'], ['output', 'pricingCustomOutput'], ['cacheRead', 'pricingCustomCacheRead']]
+  /** 某个 key 当前的手填值（草稿优先，其次宿主已有的自定义价）。 */
+  const customOf = (r) => {
+    const d = draft[r.key]
+    if (d && d.custom) return d.custom
+    // 宿主已按自定义价计过账：用它当前的费率回填，方便改。
+    if (r.how === 'custom' && r.rates) {
+      const per = moneyPerUsd()
+      const at = r.rates.peak || r.rates.offPeak
+      return {
+        input: String(Number((at.input * per).toFixed(4))),
+        output: String(Number((at.output * per).toFixed(4))),
+        cacheRead: String(Number((at.cacheRead * per).toFixed(4))),
+      }
+    }
+    return { input: '', output: '', cacheRead: '' }
+  }
+  /** 开始手填：把这一行切成编辑态，草稿里先放一份可编辑的值。 */
+  const startCustom = (key) => {
+    const row = rows.find((x) => x.key === key)
+    const seed = row ? customOf(row) : { input: '', output: '', cacheRead: '' }
+    setDraft((prev) => mergeDraft(prev, key, { target: null, cleared: false, custom: seed, key }))
+    setEditFor(key)
+    closePick()
+  }
+  const setCustomField = (key, field, value) => {
+    setDraft((prev) => {
+      const cur = (prev[key] && prev[key].custom) || { input: '', output: '', cacheRead: '' }
+      return mergeDraft(prev, key, { target: null, cleared: false, custom: { ...cur, [field]: value }, key })
+    })
+  }
+
+  const dirtyKeys = Object.keys(draft).filter((k) => draft[k].dirty)
+  /** 三格都能读成非负数字才算一条手填价，否则不发出去（避免把空串写成 0）。 */
+  const customOfDraft = (d) => {
+    if (!d || !d.custom) return null
+    const out = {}
+    for (const [field] of CUSTOM_FIELDS) {
+      const raw = String(d.custom[field] == null ? '' : d.custom[field]).trim()
+      if (raw === '') return null
+      const v = Number(raw)
+      if (!Number.isFinite(v) || v < 0) return null
+      out[field] = v
+    }
+    return out
+  }
+  const submit = () => {
+    if (dirtyKeys.length === 0 || saving) { if (dirtyKeys.length === 0) onClose(); return }
+    const decisions = []
+    const cleared = []
+    const customs = []
+    for (const k of dirtyKeys) {
+      const d = draft[k]
+      if (d.cleared) cleared.push(k)
+      else if (d.custom) {
+        const rate = customOfDraft(d)
+        if (rate !== null) customs.push({ key: k, ...rate })
+      } else if (typeof d.target === 'string' && d.target !== '') decisions.push({ key: k, target: d.target })
+    }
+    setSaving(true)
+    hostCall('usage/pricing', { action: 'commit', decisions, cleared, customs, currency: currency && currency.code ? currency.code : 'CNY' })
+      .then((v) => {
+        setSaving(false)
+        setDraft({})
+        setEditFor(null)
+        if (onApplied) onApplied(v)
+        onClose()
+      }, (e) => {
+        setSaving(false)
+        setError(e)
+        setStatus('error')
+      })
+  }
+
+  const onKeyDown = (e) => {
+    if (e.key === 'Escape') {
+      // 一路退出：先收候选列表，再关弹窗
+      if (pickFor !== null) { closePick(); return }
+      onClose()
+    }
+  }
+
+  // 单价：宿主给的是两档费率（rates），tier 是它自己算的「现在按哪档显示」。
+  // 前端只查表、不猜档 —— 之前宿主把档折成一行再发过来，另一档就凭空消失了。
+  const rateLine = (rates) => [rates.input, rates.output, rates.cacheRead].map(moneyOf).join(' / ')
+  const priceLine = (r) => {
+    // 手填价：三格都填好就照填的印（它们本来就是展示币种），否则提示还没填完。
+    const d = r ? draft[r.key] : null
+    if (d && d.custom) {
+      const vals = CUSTOM_FIELDS.map(([field]) => String(d.custom[field] == null ? '' : d.custom[field]).trim())
+      if (vals.every((v) => v !== '' && Number.isFinite(Number(v)))) {
+        return vals.map((v) => priceUnit + Number(v).toFixed(2)).join(' / ')
+      }
+      return t('pricingCustomPending')
+    }
+    return r && r.rates ? rateLine(r.rates[r.tier] || r.rates.peak) : t('unpriced')
+  }
+  /** 悬停时把两档都列出来：同一格只印一档，但不能让另一半价格看不见。 */
+  const priceTitle = (r) => {
+    if (!r || !r.rates) return null
+    return t('pricingBothTiers', { peak: rateLine(r.rates.peak), off: rateLine(r.rates.offPeak) })
+  }
+
+  // 参考模型候选按来源分组：DeepSeek 官方、opencode Zen。「自定义」不是一个组，
+  // 而是列表顶部的一个单独选项 —— 选它不是挑一个参考模型，而是直接给这一行填
+  // 三个单价（输入 / 输出 / 缓存读），存进 `prices`。
+  const SOURCE_LABEL = { deepseek: 'pricingSourceDeepseek', zen: 'pricingSourceZen', custom: 'pricingSourceCustom' }
+  const candidateGroups = () => {
+    if (!table || !Array.isArray(table.groups)) return []
+    const q = pickText.trim().toLowerCase()
+    let budget = 80
+    const out = []
+    for (const group of table.groups) {
+      const all = Array.isArray(group.ids) ? group.ids : []
+      const ids = all.filter((id) => (q === '' ? true : id.toLowerCase().includes(q)))
+      if (ids.length === 0) continue
+      const kept = ids.slice(0, Math.max(0, budget))
+      budget -= kept.length
+      out.push({ source: group.source, ids: kept })
+      if (budget <= 0) break
+    }
+    return out
+  }
+
+  /** 某组里的 id 属于哪个来源（草稿刚选的目标也查得到）。 */
+  const sourceOf = (id) => {
+    if (!id || !table || !Array.isArray(table.groups)) return null
+    for (const group of table.groups) {
+      if (Array.isArray(group.ids) && group.ids.includes(id)) return group.source
+    }
+    return null
+  }
+
+  /**
+   * 当前行要显示的匹配目标：草稿优先于宿主的答案。
+   *
+   * 用户刚选完目标就要立刻看见，否则读起来像「点了没反应」；已收回的显示为空。
+   */
+  const shownOf = (r) => {
+    const d = draft[r.key]
+    if (!d) return r.target
+    if (d.cleared) return null
+    if (d.custom) return null // 手填价没有参考模型 id，格子显示「自定义」
+    return d.target
+  }
+
+  /** 一行的四态：收回即未匹配，选了目标或手填价即自定义，其余用宿主给的 state。 */
+  const stateOf = (r) => {
+    const d = draft[r.key]
+    if (d && d.cleared) return 'none'
+    if (d && (d.target || d.custom)) return 'custom'
+    return r.state
+  }
+
+  /**
+   * 选择器本体。
+   *
+   * 未匹配的行不再要求先点一次「选择参考模型」：展开的那一刻输入框就带焦点，
+   * 选完直接落进草稿（仍然要按「确定」才写盘）。
+   */
+  const pickerFor = (key) => {
+    const row = rows.find((x) => x.key === key)
+    const cur = row ? shownOf(row) : null
+    return [
+      h('input', {
+        key: 'q',
+        type: 'text',
+        className: 'tsd-price-pick-input',
+        value: pickText,
+        placeholder: t('askPick'),
+        autoFocus: true,
+        onChange: (e) => setPickText(e.target.value),
+      }),
+      h('div', { key: 'l', className: 'tsd-price-pick-list', role: 'listbox' },
+        // 顶部固定一条「自定义」：选它不是挑参考模型，而是给这一行手填三个单价。
+        h('button', {
+          key: 'custom',
+          type: 'button',
+          role: 'option',
+          'aria-selected': 'false',
+          className: 'tsd-price-pick-item tsd-price-pick-custom',
+          onClick: () => startCustom(key),
+        },
+          h('span', { className: 'tsd-price-pick-custom-label' }, t('pricingCustomOption')),
+          h('span', { className: 'tsd-price-pick-custom-hint' }, t('pricingCustomHint'))),
+        h('div', { key: 'sep', className: 'tsd-price-pick-sep', role: 'presentation' }),
+        // 一组一个表头 + 若干选项。role 保持 listbox/option，表头只是分组标签。
+        candidateGroups().map((group) => [
+          h('div', {
+            key: 'g:' + group.source,
+            className: 'tsd-price-pick-group',
+            role: 'presentation',
+          }, t(SOURCE_LABEL[group.source] || group.source)),
+          ...group.ids.map((id) => h('button', {
+            key: id,
+            type: 'button',
+            role: 'option',
+            'aria-selected': id === (cur || ''),
+            className: 'tsd-price-pick-item' + (id === cur ? ' tsd-price-pick-item-active' : ''),
+            onClick: () => choose(key, id),
+          }, id)),
+        ])),
+    ]
+  }
+
+  const bindPickAnchor = (el) => { if (el) pickAnchor.current = el }
+
+  const renderRow = (r) => {
+    const d = draft[r.key]
+    const state = stateOf(r)
+    const shown = shownOf(r)
+    const picking = pickFor === r.key
+    const editing = editFor === r.key
+    const openPick = () => { if (picking) { closePick(); return } setEditFor(null); setPickFor(r.key); setPickText('') }
+    // 还原只在真的改过（或历史确认过）的行上出现：精确/模糊命中的行本来就没有
+    // 可还原的东西，每行都挂一颗按钮只会把表格挤成表单。
+    const canReset = state === 'custom' || (d && d.dirty)
+    // 弹窗遮罩是 z-index 60，浮层必须压在它上面；其余定位（上翻、封高）交给 hook。
+    const pickPanel = picking
+      ? h('div', {
+          className: 'tsd-price-pick-box',
+          style: Object.assign({}, pickStyle, { zIndex: 70 }),
+          onKeyDown: (e) => { if (e.key === 'Escape') { e.stopPropagation(); closePick() } },
+        }, pickerFor(r.key))
+      : null
+    // 手填单价的浮层：三格（输入 / 输出 / 缓存读），单位就是表格的展示币种。
+    const cur = editing ? customOf(r) : null
+    const customPanel = editing
+      ? h('div', {
+          className: 'tsd-price-pick-box tsd-price-custom-box',
+          style: Object.assign({}, customStyle, { zIndex: 70 }),
+          onKeyDown: (e) => { if (e.key === 'Escape') { e.stopPropagation(); setEditFor(null) } },
+        },
+          h('div', { className: 'tsd-price-custom-title' }, t('pricingCustomOption')),
+          ...CUSTOM_FIELDS.map(([field, label]) => h('label', { key: field, className: 'tsd-price-custom-field' },
+            h('span', null, t(label)),
+            h('input', {
+              type: 'number',
+              min: '0',
+              step: '0.001',
+              className: 'tsd-price-custom-input',
+              'data-field': field,
+              value: cur[field],
+              autoFocus: field === 'input',
+              onChange: (e) => setCustomField(r.key, field, e.target.value),
+            }))),
+          h('div', { className: 'tsd-price-custom-hint' }, t('pricingCustomUnit', { unit: priceUnit })),
+          h('button', {
+            type: 'button',
+            className: 'tsd-btn tsd-btn-ghost tsd-btn-xs',
+            onClick: () => setEditFor(null),
+          }, t('done')))
+      : null
+    // 这一行匹配到的参考模型属于哪一类（DeepSeek / Zen / 自定义）。草稿里刚选的
+    // 目标也查得到：候选名单本来就按来源分好了组，不用再问宿主一次。
+    // 「自定义」不仅指草稿：从 `prices` 计价的行也没有参考模型 id（target 为空），
+    // 它的目标格要写「自定义」，不然会显示成待选。
+    const isCustom = Boolean(d && d.custom) || (r.how === 'custom' && !r.target)
+    const src = shown ? (sourceOf(shown) || r.source) : (isCustom ? 'custom' : null)
+    return h('tr', { key: r.key, className: 'tsd-price-row', 'data-state': state, 'data-model': r.key, 'data-dirty': d && d.dirty ? 'true' : undefined },
+      h('td', { className: 'tsd-price-model', title: r.key },
+        h('span', { className: 'tsd-price-model-name' }, shortModelName(r.key)),
+        r.provider ? h('span', { className: 'tsd-price-model-provider' }, r.provider) : null),
+      // 匹配目标格本身就是选择器入口：一颗紧凑按钮，未匹配时虚线 + 提示语。
+      h('td', { className: 'tsd-price-target', ref: picking || editing ? bindPickAnchor : undefined },
+        h('button', {
+          type: 'button',
+          className: 'tsd-price-target-btn',
+          'data-empty': shown || isCustom ? undefined : 'true',
+          'aria-expanded': picking || editing ? 'true' : 'false',
+          'aria-haspopup': 'listbox',
+          title: shown ? shown + (src ? ' · ' + t(SOURCE_LABEL[src] || src) : '') : null,
+          onClick: openPick,
+        },
+          h('span', { className: 'tsd-price-target-id' }, shown || (isCustom ? t('pricingCustomOption') : t('askPick'))),
+          h(SvgIcon, { name: 'chevron', size: 12, className: 'tsd-price-target-chev' })),
+        src
+          ? h('span', { className: 'tsd-price-src', 'data-source': src }, t(SOURCE_LABEL[src] || src))
+          : null,
+        state !== 'none' && !r.rates && !isCustom
+          ? h('span', { className: 'tsd-price-stale' }, t('pricingStale'))
+          : null,
+        pickPanel,
+        customPanel),
+      h('td', null, h('span', { className: 'tsd-price-badge', 'data-state': state, title: r.why || null }, t(MATCH_STATE_LABEL[state]))),
+      h('td', { className: 'tsd-price-rate', title: priceTitle(r) }, priceLine(r)),
+      h('td', { className: 'tsd-price-ops' },
+        canReset
+          ? h('button', {
+              type: 'button',
+              className: 'tsd-price-reset',
+              title: t('pricingClear'),
+              'aria-label': t('pricingClear'),
+              onClick: () => clearRow(r.key),
+            }, h(SvgIcon, { name: 'refresh', size: 12 }))
+          : null))
+  }
+
+  const body = status === 'loading'
+    ? h('div', { className: 'tsd-price-loading' }, t('loading'))
+    : status === 'error'
+      ? h('div', { className: 'tsd-alert-banner', role: 'alert' },
+          h('span', null, t('pricingFailed', { message: String((error && error.message) || error) })),
+          h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: pull }, t('retry')))
+      : h('div', { className: 'tsd-price-body' },
+          h('div', { className: 'tsd-price-meta' },
+            table && table.source
+              ? t('pricingTableMeta', { source: table.source, date: stampText(table.capturedAt) })
+              : null,
+            h('span', { className: 'tsd-price-counts' }, t('pricingCounts', {
+              exact: counts.exact, fuzzy: counts.fuzzy, none: counts.none, custom: counts.custom,
+            }))),
+          // 一张表装两段行：待选的未定价行在前，已按阶梯命中的行在后。
+          // 分成两张表会出现两行表头，看起来像两份数据。
+          !hasMainRows
+            ? h('div', { className: 'tsd-price-empty' }, t('askEmpty'))
+            : h('table', { className: 'tsd-price-table' },
+                h('thead', null, h('tr', null,
+                  h('th', null, t('pricingColModel')),
+                  h('th', null, t('pricingColMatch')),
+                  h('th', null, t('pricingColState')),
+                  h('th', null, t('pricingColPrice', { unit: priceUnit })),
+                  h('th', null, ''))),
+                h('tbody', null,
+                  pendingRows.map((r) => renderRow(r)),
+                  matchedRows.map((r) => renderRow(r)))),
+          h('div', { className: 'tsd-price-history' },
+            h('button', {
+              type: 'button',
+              className: 'tsd-price-history-toggle',
+              'aria-expanded': historyOpen,
+              onClick: () => setHistoryOpen((v) => !v),
+            },
+              h(SvgIcon, { name: 'chevron', size: 12, className: 'tsd-price-history-chev' + (historyOpen ? ' tsd-price-history-chev-open' : '') }),
+              h('span', null, t('pricingHistory', { n: historyRows.length }))),
+            historyOpen
+              ? historyRows.length === 0
+                ? h('div', { className: 'tsd-price-empty' }, t('pricingHistoryEmpty'))
+                : h('div', null,
+                    h('table', { className: 'tsd-price-table tsd-price-table-sub' },
+                      h('thead', null, h('tr', null,
+                        h('th', null, t('pricingColModel')),
+                        h('th', null, t('pricingColMatch')),
+                        h('th', null, t('pricingColState')),
+                        h('th', null, t('pricingColPrice', { unit: priceUnit })),
+                        h('th', null, ''))),
+                      h('tbody', null, historyRows.map((r) => renderRow(r)))))
+              : null))
+
+  return h('div', { className: 'tsd-price-overlay', role: 'presentation', onMouseDown: (e) => { if (e.target === e.currentTarget) onClose() } },
+    h('div', {
+      className: 'tsd-price-dialog',
+      role: 'dialog',
+      'aria-modal': 'true',
+      'aria-label': t('pricingTitle'),
+      onKeyDown,
+    },
+      h('div', { className: 'tsd-price-head' },
+        h('h3', { className: 'tsd-price-title' }, t('pricingTitle')),
+        h('button', {
+          type: 'button',
+          className: 'tsd-price-close',
+          title: t('cancel'),
+          'aria-label': t('cancel'),
+          onClick: onClose,
+        }, h(SvgIcon, { name: 'x', size: 14 }))),
+      h('p', { className: 'tsd-price-desc' }, t('pricingDesc')),
+      body,
+      h('div', { className: 'tsd-price-foot' },
+        h('button', {
+          type: 'button',
+          className: 'tsd-btn tsd-btn-ghost tsd-btn-icon-label',
+          onClick: pull,
+          disabled: status === 'loading' || saving,
+        },
+          h(SvgIcon, { name: 'contextInjection', size: 14 }),
+          h('span', null, t('pricingPull'))),
+        h('span', { className: 'tsd-price-hint' }, dirtyKeys.length > 0 ? t('pricingApplyHint') : ''),
+        h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: onClose, disabled: saving }, t('cancel')),
+        h('button', {
+          type: 'button',
+          className: 'tsd-btn tsd-btn-primary',
+          onClick: submit,
+          disabled: saving,
+        }, saving ? t('loading') : t('pricingSave')))))
 }
 
 /* ---------------------------------------------------------------------------
  * 每日用量柱状图（手写 div 堆叠柱：下段输入蓝 / 上段输出绿）
  * ------------------------------------------------------------------------- */
+/**
+ * One hover-tip content block, shared by the trend chart (bar + line) and the
+ * yearly heatmap: date, input, output, total, reference cost.
+ *
+ * Cost comes from the host bucket (`cost`, already converted to the display
+ * currency), so all three tips show the same number as the summary card and the
+ * model table. A zero is printed as ¥0.00 — "0" is a price, "unpriced" is a
+ * different verdict, and it is the host's to give.
+ */
+function TipRows(props) {
+  const { row, t, currency, withSplit } = props
+  const inT = row.inputTokens || 0
+  const outT = row.outputTokens || 0
+  const totT = row.totalTokens || 0
+  return [
+    withSplit
+      ? h('div', { key: 'in', className: 'tsd-tooltip-row' },
+          h('span', { className: 'tsd-tooltip-dot tsd-legend-in' }),
+          h('span', null, t('legendInput')),
+          h('span', { className: 'tsd-tooltip-val' }, formatInt(inT)))
+      : h('div', { key: 'in', className: 'tsd-tooltip-row' },
+          h('span', { className: 'tsd-tooltip-dot', style: { background: 'var(--dsw-static-deepseek-500)' } }),
+          h('span', null, t('totalTokens')),
+          h('span', { className: 'tsd-tooltip-val' }, formatInt(totT))),
+    withSplit
+      ? h('div', { key: 'out', className: 'tsd-tooltip-row' },
+          h('span', { className: 'tsd-tooltip-dot tsd-legend-out' }),
+          h('span', null, t('legendOutput')),
+          h('span', { className: 'tsd-tooltip-val' }, formatInt(outT)))
+      : null,
+    // 成本与调用次数没有对应图例，所以只留 10px 的空白占位（.tsd-tooltip-dot 本身无底色），
+    // 不画色块：色块的含义是「这一行对应图例里的哪个颜色」。
+    h('div', { key: 'cost', className: 'tsd-tooltip-row' },
+      h('span', { className: 'tsd-tooltip-dot', 'aria-hidden': 'true' }),
+      h('span', null, t('cost')),
+      h('span', { className: 'tsd-tooltip-val' }, formatCost(row.cost || 0, currency))),
+    row.calls > 0
+      ? h('div', { key: 'calls', className: 'tsd-tooltip-row' },
+          h('span', { className: 'tsd-tooltip-dot', 'aria-hidden': 'true' }),
+          h('span', null, t('calls')),
+          h('span', { className: 'tsd-tooltip-val' }, formatInt(row.calls)))
+      : null,
+    withSplit
+      ? h('div', { key: 'total', className: 'tsd-tooltip-total' },
+          h('span', null, t('tooltipTotal')),
+          h('span', null, formatInt(totT)))
+      : null,
+  ]
+}
+
 function DailyChart(props) {
-  const { daily, gran, stepDays, granLabel } = props
+  const { daily, gran, stepDays, granLabel, currency } = props
   const t = useT()
   const chartRef = React.useRef(null)
   const [tip, setTip] = React.useState(null) // { row, x }
@@ -2308,21 +3724,11 @@ function DailyChart(props) {
   const barTip = tip
     ? h('div', { className: 'tsd-tooltip', style: { left: tip.x + 'px' } },
         h('div', { className: 'tsd-tooltip-date' }, tip.row.key + ' ' + weekdayName(tip.row.key, t)),
-        h('div', { className: 'tsd-tooltip-row' },
-          h('span', { className: 'tsd-tooltip-dot tsd-legend-in' }),
-          h('span', null, t('legendInput')),
-          h('span', { className: 'tsd-tooltip-val' }, formatInt(inOf(tip.row)))),
-        h('div', { className: 'tsd-tooltip-row' },
-          h('span', { className: 'tsd-tooltip-dot tsd-legend-out' }),
-          h('span', null, t('legendOutput')),
-          h('span', { className: 'tsd-tooltip-val' }, formatInt(outOf(tip.row)))),
-        h('div', { className: 'tsd-tooltip-total' },
-          h('span', null, t('tooltipTotal')),
-          h('span', null, formatInt(totOf(tip.row)))))
+        h(TipRows, { row: tip.row, t, currency, withSplit: true }))
     : null
 
   const body = view === 'line'
-    ? h(LineChart, { rows, gran, stepDays, showTip, tip, setTip, chartRef })
+    ? h(LineChart, { rows, gran, stepDays, showTip, tip, setTip, chartRef, currency })
     : h('div', { className: 'tsd-chart', ref: chartRef },
         rows.map((row, i) => {
           const inT = inOf(row)
@@ -2339,7 +3745,7 @@ function DailyChart(props) {
             onMouseLeave: () => setTip(null),
             onFocus: (e) => showTip(e, row),
             onBlur: () => setTip(null),
-            'aria-label': t('barAria', { key: row.key, in: formatInt(inT), out: formatInt(outT), tot: formatInt(totT) }),
+            'aria-label': t('barAria', { key: row.key, in: formatInt(inT), out: formatInt(outT), tot: formatInt(totT), cost: formatCost(row.cost || 0, currency) }),
           },
             h('div', { className: 'tsd-chart-plot' },
               h('div', { className: 'tsd-chart-stack' },
@@ -2390,7 +3796,7 @@ function smoothPath(pts) {
 }
 
 function LineChart(props) {
-  const { rows, gran, stepDays, showTip, tip, setTip, chartRef } = props
+  const { rows, gran, stepDays, showTip, tip, setTip, chartRef, currency } = props
   const t = useT()
   const W = 620
   const H = 240
@@ -2508,17 +3914,7 @@ function LineChart(props) {
     tip
       ? h('div', { className: 'tsd-tooltip', style: { left: tip.x + 'px' } },
           h('div', { className: 'tsd-tooltip-date' }, tip.row.key + (stepDays > 1 ? ' ' + t('startNDays', { n: stepDays }) : '') + ' ' + weekdayName(tip.row.key, t)),
-          h('div', { className: 'tsd-tooltip-row' },
-            h('span', { className: 'tsd-tooltip-dot tsd-legend-in' }),
-            h('span', null, t('legendInput')),
-            h('span', { className: 'tsd-tooltip-val' }, formatInt(inOf(tip.row)))),
-          h('div', { className: 'tsd-tooltip-row' },
-            h('span', { className: 'tsd-tooltip-dot tsd-legend-out' }),
-            h('span', null, t('legendOutput')),
-            h('span', { className: 'tsd-tooltip-val' }, formatInt(outOf(tip.row)))),
-          h('div', { className: 'tsd-tooltip-total' },
-            h('span', null, t('tooltipTotal')),
-            h('span', null, formatInt(totOf(tip.row)))))
+          h(TipRows, { row: tip.row, t, currency, withSplit: true }))
       : null)
 }
 
@@ -2526,7 +3922,7 @@ function LineChart(props) {
  * 年度用量热力图（GitHub 风格）
  * ------------------------------------------------------------------------- */
 function HeatmapCard(props) {
-  const { days } = props
+  const { days, currency } = props
   const t = useT()
   const [htip, setHtip] = React.useState(null) // { cell, left, top } in viewport coords
   const grid = React.useMemo(() => {
@@ -2575,16 +3971,7 @@ function HeatmapCard(props) {
         style: { position: 'fixed', left: htip.left + 'px', top: htip.top + 'px', transform: 'translate(-50%, -110%)' },
       },
         h('div', { className: 'tsd-tooltip-date' }, htip.cell.key + ' ' + weekdayName(htip.cell.key, t)),
-        h('div', { className: 'tsd-tooltip-row' },
-          h('span', { className: 'tsd-tooltip-dot', style: { background: 'var(--dsw-static-deepseek-500)' } }),
-          h('span', null, t('totalTokens')),
-          h('span', { className: 'tsd-tooltip-val' }, formatInt(htip.cell.totalTokens || 0))),
-        htip.cell.calls > 0
-          ? h('div', { className: 'tsd-tooltip-row' },
-              h('span', { className: 'tsd-tooltip-dot', style: { background: 'var(--dsw-alias-label-tertiary)' } }),
-              h('span', null, t('calls')),
-              h('span', { className: 'tsd-tooltip-val' }, formatInt(htip.cell.calls)))
-          : null)
+        h(TipRows, { row: htip.cell, t, currency, withSplit: false }))
     : null
 
   const dayNames = ['', t('weekdayMon'), '', t('weekdayWed'), '', t('weekdayFri'), '']
@@ -2616,7 +4003,7 @@ function HeatmapCard(props) {
                         key: c.key,
                         className: 'tsd-heatmap-cell',
                         style: { background: heatColor(c.totalTokens || 0, grid.max) },
-                        title: t('hmTitle', { key: c.key, tokens: formatInt(c.totalTokens || 0), calls: c.calls ? t('hmCalls', { count: formatInt(c.calls) }) : '' }),
+                        title: t('hmTitle', { key: c.key, tokens: formatInt(c.totalTokens || 0), calls: c.calls ? t('hmCalls', { count: formatInt(c.calls) }) : '', cost: formatCost(c.cost || 0, currency) }),
                         onMouseEnter: (e) => showCellTip(e, c),
                         onMouseLeave: () => setHtip(null),
                         onFocus: (e) => showCellTip(e, c),
@@ -2653,7 +4040,11 @@ function ModelTable(props) {
     output: r.outputTokens || 0,
     total: r.totalTokens || 0,
     cost: r.cost || 0,
-    unpriced: (r.totalTokens || 0) > 0 && !(r.cost > 0),
+    // The verdict comes from the host, which knows whether a price was found.
+    // This used to be re-derived here as `tokens > 0 && !(cost > 0)`, which
+    // labels every 0-cost row 未定价 — including a model the user explicitly
+    // priced at 0 (a real price, cost 0, so ¥0.00 is the honest answer).
+    unpriced: r.unpriced === true,
   })), [all])
 
   const sumTotal = React.useMemo(() => view.reduce((s, r) => s + r.total, 0), [view])
@@ -2736,12 +4127,19 @@ function ModelTable(props) {
 /* ---------------------------------------------------------------------------
  * 三态：加载 / 错误 / 空
  * ------------------------------------------------------------------------- */
-function LoadingState() {
+function LoadingState(props) {
   const t = useT()
-  return h('div', { className: 'tsd-loading' },
+  // 统计中（computing）时头部副标题已经在播报进度，这里就不再做第二个 live 区域，
+  // 否则屏幕阅读器会把「正在加载」和「正在统计 12/258」各念一遍。
+  const announce = !props || props.announce !== false
+  return h('div', { className: 'tsd-loading', role: 'status', 'aria-live': announce ? 'polite' : 'off' },
+    // 骨架屏对眼睛是"正在来"，对屏幕阅读器什么都不是：给它一句可读的状态。
+    announce ? h('span', { className: 'tsd-visually-hidden' }, t('loading')) : null,
     h('div', { className: 'tsd-cards' },
-      [0, 1, 2, 3, 4].map((i) =>
-        h('div', { key: i, className: 'tsd-card tsd-card-skeleton' },
+      // 一张卡一个占位块，张数取自 SUMMARY_CARD_SLOTS —— 与真实卡片同一份顺序表，
+      // 所以补卡片时骨架自动跟上（这里曾经写死 5 个，真实是 6 个）。
+      SUMMARY_CARD_SLOTS.map((slot) =>
+        h('div', { key: slot, className: 'tsd-card tsd-card-skeleton' },
           h('div', { className: 'tsd-skeleton', style: { width: '40%', height: 12 } }),
           h('div', { className: 'tsd-skeleton', style: { width: '70%', height: 22, marginTop: 10 } })))),
     h('div', { className: 'tsd-card' },
@@ -2790,10 +4188,17 @@ function StatsDashboard(props) {
   // 展示币种：宿主按它换算成本，所以换币种必须重查；选择记在本地（展示偏好，
   // 不写插件设置，免得每次取数都在改写用户配置）。
   const [displayCurrency, setDisplayCurrency] = React.useState(readStoredCurrency)
+  // 定价匹配弹窗：只在这里开着，关掉即卸载（它的内部状态随之丢弃，
+  // 所以「不确定就不生效」不需要额外清理逻辑）。
+  const [pricingOpen, setPricingOpen] = React.useState(false)
   // P1-6 backfill 轮询状态：queryKey 变化时重置，仅对同一查询串轮询
   const queryKeyRef = React.useRef(null)
   const backfillSeenRef = React.useRef(false)
   const finalRefreshRef = React.useRef(false)
+  // 轮询节奏：统计窗口短则快问、长则慢问。固定 3 s 时，暖缓存 ~0.8 s 就跑完，
+  // 客户端要等 3 s 才更新 —— 进度条先躺着再跳一格，比没有更糟。
+  const pollStepRef = React.useRef(0)
+  const POLL_DELAYS = [600, 1500, 3000]
 
   const eff = React.useMemo(() => rangeFor(range, custom), [range, custom])
   // Fixed step policy: today = hourly; 7d/30d/custom = daily, custom uses a
@@ -2812,6 +4217,7 @@ function StatsDashboard(props) {
       queryKeyRef.current = queryKey
       backfillSeenRef.current = false
       finalRefreshRef.current = false
+      pollStepRef.current = 0
     }
     const isFinalRun = finalRefreshRef.current
     finalRefreshRef.current = false
@@ -2835,10 +4241,14 @@ function StatsDashboard(props) {
         const bs = r && r.backfill ? r.backfill.status : null
         if (bs === 'running') {
           backfillSeenRef.current = true
-          // 同一 effect 至多挂一个定时器；重查复用 retry 计数器触发 effect 重跑
+          // 同一 effect 至多挂一个定时器；重查复用 retry 计数器触发 effect 重跑。
+          // 先快后慢：600 ms 起步能跟上 0.8 s 的暖缓存窗口，长任务再退到 3 s，
+          // 不至于把宿主问成压力测试。
+          const delay = POLL_DELAYS[Math.min(pollStepRef.current, POLL_DELAYS.length - 1)]
+          pollStepRef.current += 1
           backfillTimer = setTimeout(() => {
             if (current) setRetry((v) => v + 1)
-          }, 3000)
+          }, delay)
         } else if (bs === 'done' && backfillSeenRef.current && !isFinalRun) {
           // 回填收尾：恰好再查一次拿到完整数据后停止
           finalRefreshRef.current = true
@@ -2917,10 +4327,38 @@ function StatsDashboard(props) {
   const ready = data !== null
   const isError = status === 'error'
   const isEmpty = ready && data.daily.length === 0 && data.byModel.length === 0
+  // "统计没算完"：宿主还在回填历史（backfill.status === 'running'）。
+  // 它比 busy 长得多（全量 258 个会话要几秒），所以进度条与文案都以它为准；
+  // 请求在飞（busy）只是刷新，不该被当成"在算"。
+  const backfill = (data && data.backfill) || null
+  const computing = Boolean(backfill && backfill.status === 'running')
+  const computeTotal = (backfill && backfill.total) || 0
+  const computeDone = (backfill && backfill.done) || 0
+  const computePct = computing && computeTotal > 0
+    ? Math.min(100, Math.round((computeDone / computeTotal) * 100))
+    : null
+  const showProgress = computing || (busy && ready && !isError)
 
   return h(T.Provider, { value: t },
-    h('div', { className: 'tsd-section', 'aria-busy': busy || undefined },
-    h(StatsHeader, { busy, onRefresh: reload }),
+    h('div', { className: 'tsd-section', 'aria-busy': busy || computing || undefined },
+    // 首屏走后骨架屏（见 LoadingState）；这里管"有数据但没算完"与"正在刷新"：
+    // 一条 2px 的细进度条，绝对定位，不推动版面也不碰任何数字。
+    // 算得完的时候它是确定进度（宽度 = done/total），否则是不确定扫动。
+    showProgress
+      ? h('div', {
+          className: 'tsd-progress',
+          'aria-hidden': 'true',
+          'data-determinate': computePct === null ? undefined : 'true',
+          style: computePct === null ? undefined : { '--tsd-progress': computePct + '%' },
+        })
+      : null,
+    h(StatsHeader, {
+      busy,
+      computing,
+      computeDone,
+      computeTotal,
+      onRefresh: reload,
+    }),
     h(FilterBar, {
       range,
       custom,
@@ -2936,19 +4374,27 @@ function StatsDashboard(props) {
     isError && !ready
       ? h(ErrorState, { error, onRetry: reload })
       : null,
-    !ready && !isError
-      ? h(LoadingState, null)
+    // **从 DSH 启动到统计算完，整段都是加载态。**
+    // 覆盖两种"还没东西可看"：
+    //  ① 首屏请求还没回来（!ready）；
+    //  ② 宿主还在回填历史（computing）—— 哪怕是第二次进来、手里已经有半份数据。
+    // 半份数字比骨架更误导：它看起来像"你只有这么多用量"，而且会一格一格往上爬。
+    // 这也正是「数字一点点往上爬」那个抱怨的来源，所以宁可等，也不要给残缺的答案。
+    (!ready || computing) && !isError
+      ? h(LoadingState, { announce: !computing })
       : null,
     ready && isError
       ? h('div', { className: 'tsd-alert-banner', role: 'alert' },
           h('span', null, t('loadFailed', { message: String((error && error.message) || error) })),
           h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: reload }, t('retry')))
       : null,
-    ready && !isError && isEmpty
+    // 空态只在"确实算完了还没有记录"时出现。统计中不落到空态。
+    ready && !isError && isEmpty && !computing
       ? h(EmptyState, { filtered: models.length > 0, onReset: resetFilters })
       : null,
-    ready && !isError && !isEmpty
-      ? h('div', { className: 'tsd-content', 'data-busy': busy ? 'true' : undefined },
+    // 数据区同理：算完之前不渲染，免得残缺数字先出现再跳变。
+    ready && !isError && !isEmpty && !computing
+      ? h('div', { className: 'tsd-content' },
           h(SummaryCards, {
             total: data.total,
             currency: currencySymbol,
@@ -2956,26 +4402,44 @@ function StatsDashboard(props) {
             currencyCode: displayCurrency,
             onCurrencyChange: changeCurrency,
             byModel: data.byModel,
+            pricing: data.pricing,
+            onOpenPricing: () => setPricingOpen(true),
           }),
           h(DailyChart, {
             daily: data.daily,
             gran: effGran,
             stepDays,
             granLabel,
+            currency: currencySymbol,
           }),
-          h(HeatmapCard, { days: data.heatmap || [] }),
+          h(HeatmapCard, { days: data.heatmap || [], currency: currencySymbol }),
           h(ModelTable, { rows: data.byModel, currency: currencySymbol }))
+      : null,
+    pricingOpen
+      ? h(PricingDialog, {
+          currency: { code: displayCurrency, symbol: currencySymbol },
+          onClose: () => setPricingOpen(false),
+          // 确定后重查一次：匹配改了，卡片上的数字必须跟着变，否则用户会以为没保存成功。
+          onApplied: reload,
+        })
       : null))
 }
 
 /* ---------------------------------------------------------------------------
  * 设置页导航图标
  *
- * `settings.section` 只投影 id/order/label，导航图标由设置页按 id 白名单自己
- * 决定（dsh-client-ui-settings-general 的 navIcon），第三方没有插口。所以这里
- * 给「自己那一行」打一个属性标记，再用 CSS mask 把兜底的齿轮换成用量图标：
- * 不替换节点、不碰 React 管的 svg（替换会让 React 卸载时抛 NotFoundError），
- * 只加属性、只用 ::before 画字形。
+ * 原生确实没有这个插口 —— 取证过的，不是"我觉得"：
+ *   · 官方设置页把 `settings.section` 的条目投影成 `{id, order, label}` 三字段，
+ *     没有 icon（`@deepseek-ai/dsh-client-ui-settings-general` 的 nav rows
+ *     getSnapshot：`ctx.slots.entries("settings.section").map(e => ({id, order,
+ *     label: resolveSlotLabel(e.options.label)}))`）；
+ *   · 图标由该包自己的 `navIcon(id)` 按 id 白名单选，未列出的 id 回落到设置齿轮
+ *     （同包 `function navIcon(id)`，其注释原文 "unknown ids fall back to the
+ *     settings gear"）。
+ * 所以第三方只能给自己的那一行打属性标记、用 CSS mask 换字形：不替换节点、不碰
+ * React 管的 svg（替换会让 React 卸载时抛 NotFoundError），只加属性、只用 ::before
+ * 画字形。官方一旦给 `settings.section` 加上 icon 字段，这个模块应整体删除 ——
+ * 那时它是可引用的 L0，不该再留 L2 补缺。
  *
  * 认行只能按可见文本：类名是 CSS Modules 哈希，账号行还会条件出现。
  * 官方一旦给 settings.section 加上 icon 字段，这个模块应整体删除。
@@ -3014,7 +4478,7 @@ function installSettingsNavIcon(label) {
     styleEl.textContent = NAV_ICON_CSS
     document.head.appendChild(styleEl)
   } catch (e) {
-    console.warn('[usage] settings nav icon: styles unavailable')
+    logWarn('[usage] settings nav icon: styles unavailable')
     return null
   }
   const mark = () => {
@@ -3034,7 +4498,7 @@ function installSettingsNavIcon(label) {
     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)
+    logWarn('[usage] settings nav icon: observer unavailable', e)
   }
   return () => {
     if (observer) observer.disconnect()
@@ -3140,6 +4604,9 @@ function CostPill(props) {
  * ------------------------------------------------------------------------- */
 function apply(ctx) {
   usageCtx = ctx
+  // Mount the native Remote face once the page is up; the Fetch routes carry
+  // every call until it lands.
+  mountRemoteChannel(ctx)
   _usagePricesScope = null // 每次激活重绑，避免复用已释放的 scope
   ctx.effect(() => {
     if (typeof styles !== 'undefined' && styles && typeof styles.insert === 'function') {
@@ -3175,7 +4642,7 @@ function apply(ctx) {
     }
   }
   if (!slots || typeof slots.inject !== 'function' || typeof slots.register !== 'function') {
-    console.warn('[usage] settings.section slot unavailable')
+    logWarn('[usage] settings.section slot unavailable')
     return
   }
   slots.inject('settings.section', () => slots.register(
@@ -3206,4 +4673,4 @@ return { inject: ['locale', 'slots'], apply }
     return module.exports;
   }
 });
-//# 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/* ============ 输入区成本 pill（composer dock）============ */\n.tsd-dock {\n  box-sizing: border-box;\n  display: inline-flex;\n  align-items: center;\n  gap: 4px;\n  height: 22px;\n  padding: 0 8px;\n  border-radius: 999px;\n  border: 0.5px solid var(--dsw-alias-border-l1);\n  background: var(--dsw-alias-bg-base);\n  color: var(--dsw-alias-label-secondary);\n  font-size: 12px;\n  line-height: 1;\n  white-space: nowrap;\n  cursor: default;\n}\n.tsd-dock-label {\n  color: var(--dsw-alias-label-tertiary);\n}\n.tsd-dock-value {\n  font-weight: 600;\n  font-variant-numeric: tabular-nums;\n  color: var(--dsw-alias-label-primary);\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  dockHint: '今日 {cost} · {calls} 次调用 · {tokens} Token',\n  dockUnpriced: '未定价',\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  dockHint: 'Today {cost} · {calls} calls · {tokens} tokens',\n  dockUnpriced: 'unpriced',\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 * 输入区成本 pill（composer dock）\n *\n * DSH 0.2.1-rc.1 把输入区统计拆成 `activity` / `usage` 两个 composer dock 条目，\n * 宿主自己的 `usage` pill 显示 token 数（读官方 `tokenUsage` 投影）。官方投影只有\n * 会话内合计、**不带模型归因**，而成本必须按模型单价算（本插件自 v0.3 起坚持\n * 不混价），所以这里不走投影，改走本插件自己的 `query`：记录里带 provider/model，\n * 宿主侧按模型精确计价。\n *\n * 口径取「今日」而不是「本会话」：dock 条目拿不到会话标识（宿主渲染这个 slot 时\n * 是 `renderSlot(\"conversation.composer.dock\", {})`，不传 props），而今日成本与\n * 宿主的 token pill 正好互补。\n * ------------------------------------------------------------------------- */\nconst DOCK_REFRESH_MS = 30000\n/** 回填（backfill）进行中的快重试间隔，与设置页一致。 */\nconst DOCK_BACKFILL_RETRY_MS = 3000\n\nfunction CostPill(props) {\n  const tr = props && typeof props.t === 'function' ? props.t : fallbackT\n  const [state, setState] = React.useState({ status: 'loading' })\n  React.useEffect(() => {\n    let alive = true\n    let timer = null\n    const schedule = (ms) => {\n      if (timer !== null) clearTimeout(timer)\n      timer = setTimeout(load, ms)\n    }\n    const load = () => {\n      if (!alive) return\n      const now = new Date()\n      hostCall('usage/query', {\n        from: startOfDay(now).getTime(),\n        to: now.getTime(),\n        // 「今日」是有限区间，但不需零填充：空桶对成本没意义。\n        fill: false,\n        granularity: 'day',\n        currency: readStoredCurrency(),\n      })\n        .then((r) => {\n          if (!alive) return\n          const total = (r && r.total) || null\n          setState({\n            status: 'ready',\n            calls: total ? total.calls : 0,\n            tokens: total ? total.totalTokens : 0,\n            cost: total ? total.cost : 0,\n            symbol: (r && r.currency && r.currency.symbol)\n              || CURRENCY_SYMBOLS[readStoredCurrency()]\n              || '¥',\n          })\n          const backfilling = Boolean(r && r.backfill && r.backfill.status === 'running')\n          schedule(backfilling ? DOCK_BACKFILL_RETRY_MS : DOCK_REFRESH_MS)\n        })\n        .catch(() => {\n          // 路由不可用 / 宿主未就绪：不猜数字，也不报错弹窗（dock 常驻，不能刷屏）。\n          if (alive) {\n            setState({ status: 'error' })\n            schedule(DOCK_REFRESH_MS)\n          }\n        })\n    }\n    load()\n    const onVisible = () => {\n      if (typeof document !== 'undefined' && document.visibilityState === 'visible') load()\n    }\n    if (typeof document !== 'undefined') document.addEventListener('visibilitychange', onVisible)\n    return () => {\n      alive = false\n      if (timer !== null) clearTimeout(timer)\n      if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', onVisible)\n    }\n  }, [])\n  // 今日无调用（或还没查到）就不占位：dock 是常驻区，空 pill 比没有更吵。\n  if (state.status !== 'ready' || !state.calls) return null\n  const priced = state.cost > 0\n  const value = priced ? state.symbol + costDigits(state.cost) : tr('dockUnpriced')\n  const hint = tr('dockHint', {\n    cost: value,\n    calls: formatInt(state.calls),\n    tokens: formatInt(state.tokens),\n  })\n  return h('span', {\n    className: 'tsd-dock',\n    title: hint,\n    'aria-label': hint,\n    'data-usage-cost': true,\n  },\n    h('span', { className: 'tsd-dock-label' }, tr('today')),\n    h('span', { className: 'tsd-dock-value' }, value))\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  // 输入区成本 pill。0.2.1 的 composer dock 是 list slot，宿主自己占了 activity(0)\n  // 与 usage(1)，插件排在它们之后；0.2.0 没有这个 slot，注入失败不能拖垮设置页。\n  try {\n    slots.inject('conversation.composer.dock', () => slots.register(\n      { name: 'conversation.composer.dock', id: 'usage-cost', order: 2, locale: NS },\n      (props) => h(CostPill, props),\n    ))\n  } catch (e) {\n    console.warn('[usage] composer dock slot unavailable', e)\n  }\n}\n\nreturn { inject: ['locale', 'slots'], apply }\n"],"names":[],"mappings":""}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sources":["/private/tmp/npmrel/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  position: relative;\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/* 刷新中的那条细进度条：贴在本节顶部，绝对定位所以不推动版面、不碰任何数字。\n   用它而不是把整块内容压暗 —— 已有数字本来就是对的，压暗只让人以为在重算。 */\n.tsd-progress {\n  position: absolute;\n  inset: -6px 0 auto 0;\n  height: 2px;\n  overflow: hidden;\n  border-radius: 2px;\n  background: color-mix(in srgb, var(--dsw-alias-brand-primary) 18%, transparent);\n  pointer-events: none;\n}\n.tsd-progress::after {\n  content: '';\n  position: absolute;\n  inset: 0 auto 0 0;\n  width: 35%;\n  border-radius: inherit;\n  background: var(--dsw-alias-brand-primary);\n  animation: tsd-indeterminate 1.2s var(--ds-ease-in-out) infinite;\n}\n/* 知道分母时改成确定进度：宽度就是 done/total，不再来回扫 —— 用户看到的\n   \"算到哪了\"是真的，而不是一个装忙的动画。 */\n.tsd-progress[data-determinate=true]::after {\n  width: var(--tsd-progress, 0%);\n  animation: none;\n  transform: none;\n  transition: width 240ms var(--ds-ease-in-out);\n}\n@keyframes tsd-indeterminate {\n  from { transform: translateX(-40%); }\n  to { transform: translateX(300%); }\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/* 标题带提示时给一个可发现的记号：虚线底边 + 感叹号按钮（见 HintTip）。\n   悬浮用原生 title，点击展开浮层；两段规则都在这一个组件里，别处不再各画一份。 */\n.tsd-card-label[title] {\n  cursor: help;\n  text-decoration: underline dotted;\n  text-underline-offset: 2px;\n}\n.tsd-hint {\n  display: inline-flex;\n  align-items: center;\n}\n.tsd-hint-btn {\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  width: 16px;\n  height: 16px;\n  padding: 0;\n  border: none;\n  border-radius: 50%;\n  background: transparent;\n  color: var(--dsw-alias-label-tertiary);\n  cursor: help;\n}\n.tsd-hint-btn:hover,\n.tsd-hint-btn-open {\n  background: var(--dsw-alias-interactive-bg-hover);\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-hint-btn:focus-visible {\n  outline: 2px solid var(--dsw-alias-brand-primary);\n  outline-offset: 1px;\n}\n/* 浮层里两段规则分段读；行的左右内边距由 .tsd-popover 给，这里只补段间距 */\n.tsd-hint-line {\n  margin: 0;\n  font-size: 12px;\n  line-height: 1.5;\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-hint-line + .tsd-hint-line {\n  margin-top: 6px;\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-label-tertiary);\n  line-height: 1.35;\n}\n/* 未定价是「少算了钱」，不是普通提示：其余脚注用三级灰，这一行用警示色 */\n.tsd-card-note-warn {\n  color: var(--dsw-alias-state-warn-primary);\n}\n.tsd-card-notes {\n  display: flex;\n  flex-direction: column;\n  gap: 2px;\n}\n/* 参考成本卡的入口按钮：跟着标题走，不抢数值行的位置 */\n.tsd-card-action {\n  margin-left: auto;\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  width: 20px;\n  height: 20px;\n  padding: 0;\n  border: none;\n  border-radius: 5px;\n  background: transparent;\n  color: var(--dsw-alias-label-tertiary);\n  cursor: pointer;\n}\n.tsd-card-action:hover {\n  background: var(--dsw-alias-interactive-bg-hover);\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-card-action:focus-visible {\n  outline: 2px solid var(--dsw-alias-brand-primary);\n  outline-offset: 1px;\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/* 不再 opacity: .55：那会让每次轮询都闪一下，且暗示\"数字正在重算\" ——\n   事实上数字是上一轮的正确答案。刷新的信号交给顶部那条 2px 进度条与按钮转圈。 */\n.tsd-content {\n  display: flex;\n  flex-direction: column;\n  gap: 16px;\n}\n\n/* ============ 减少动态效果 ============ */\n/* 官方客户端同样这么写（spinner / skeletonFill 都在 prefers-reduced-motion 下关动画），\n   我们这两个无限动画（呼吸、旋转）此前一条都没关。 */\n@media (prefers-reduced-motion: reduce) {\n  .tsd-section { animation: none; }\n  .tsd-spinning svg { animation: none; }\n  .tsd-skeleton, .tsd-skeleton-row { animation: none; }\n  .tsd-progress::after { animation: none; width: 100%; opacity: 0.55; }\n}\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/* ============ 输入区成本 pill（composer dock）============ */\n.tsd-dock {\n  box-sizing: border-box;\n  display: inline-flex;\n  align-items: center;\n  gap: 4px;\n  height: 22px;\n  padding: 0 8px;\n  border-radius: 999px;\n  border: 0.5px solid var(--dsw-alias-border-l1);\n  background: var(--dsw-alias-bg-base);\n  color: var(--dsw-alias-label-secondary);\n  font-size: 12px;\n  line-height: 1;\n  white-space: nowrap;\n  cursor: default;\n}\n.tsd-dock-label {\n  color: var(--dsw-alias-label-tertiary);\n}\n.tsd-dock-value {\n  font-weight: 600;\n  font-variant-numeric: tabular-nums;\n  color: var(--dsw-alias-label-primary);\n}\n/* ============ 定价匹配弹窗 ============ */\n/* 遮罩铺满视口：设置面板是 overflow:hidden 的裁剪容器，弹窗不能挂在面板内部，\n   否则宽屏下左右各被切掉一块。层级压过 popover(40)，低于任何系统级浮窗。 */\n.tsd-price-overlay {\n  position: fixed;\n  inset: 0;\n  z-index: 60;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  padding: 24px;\n  background: var(--dsw-alias-bg-mask, rgba(0, 0, 0, 0.4));\n}\n.tsd-price-dialog {\n  display: flex;\n  flex-direction: column;\n  width: min(760px, 100%);\n  max-height: 100%;\n  padding: 16px 18px 14px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  border-radius: 14px;\n  background: var(--dsw-alias-bg-layer-1);\n  box-shadow: var(--dsw-shadow-lv3);\n  color: var(--dsw-alias-label-primary);\n  font-size: 13px;\n}\n.tsd-price-head {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n}\n.tsd-price-title {\n  margin: 0;\n  font-size: 15px;\n  font-weight: 600;\n}\n.tsd-price-close {\n  margin-left: auto;\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  width: 24px;\n  height: 24px;\n  padding: 0;\n  border: none;\n  border-radius: 6px;\n  background: transparent;\n  color: var(--dsw-alias-label-tertiary);\n  cursor: pointer;\n}\n.tsd-price-close:hover {\n  background: var(--dsw-alias-interactive-bg-hover);\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-price-desc {\n  margin: 6px 0 10px;\n  font-size: 12px;\n  line-height: 1.5;\n  color: var(--dsw-alias-label-secondary);\n}\n/* 只有中段滚动：标题与底部按钮必须常驻，否则长表里够不到「确定」 */\n.tsd-price-body {\n  flex: 1 1 auto;\n  min-height: 0;\n  overflow: auto;\n}\n.tsd-price-meta {\n  display: flex;\n  flex-wrap: wrap;\n  align-items: baseline;\n  gap: 4px 12px;\n  margin-bottom: 8px;\n  font-size: 11px;\n  color: var(--dsw-alias-label-tertiary);\n}\n.tsd-price-counts { color: var(--dsw-alias-label-secondary); }\n.tsd-price-table {\n  width: 100%;\n  border-collapse: collapse;\n  font-size: 12px;\n}\n.tsd-price-table-sub {\n  margin-top: 10px;\n}\n.tsd-price-table th {\n  position: sticky;\n  top: 0;\n  z-index: 1;\n  padding: 6px 8px;\n  background: var(--dsw-alias-bg-layer-1);\n  border-bottom: 1px solid var(--dsw-alias-border-l2);\n  font-weight: 500;\n  font-size: 11px;\n  color: var(--dsw-alias-label-tertiary);\n  text-align: left;\n  white-space: nowrap;\n}\n.tsd-price-table td {\n  padding: 6px 8px;\n  border-bottom: 1px solid var(--dsw-alias-border-l2);\n  vertical-align: middle;\n}\n.tsd-price-row[data-dirty='true'] td {\n  background: var(--dsw-alias-interactive-bg-hover);\n}\n.tsd-price-model {\n  max-width: 240px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n.tsd-price-model-name {\n  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;\n  font-size: 11.5px;\n  font-weight: 500;\n}\n.tsd-price-model-provider {\n  margin-left: 6px;\n  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;\n  font-size: 10.5px;\n  color: var(--dsw-alias-label-tertiary);\n}\n/* 匹配目标格：整格是一颗紧凑的「选择」按钮（未匹配时虚线、文案是提示语），\n   比每行摊两颗文字按钮安静得多；可搜索的下拉挂在它下面展开。 */\n.tsd-price-target { max-width: 230px; }\n.tsd-price-target-btn {\n  display: inline-flex;\n  align-items: center;\n  gap: 4px;\n  max-width: 100%;\n  padding: 3px 6px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  border-radius: 6px;\n  background: var(--dsw-alias-bg-layer-2);\n  color: var(--dsw-alias-label-secondary);\n  font: inherit;\n  font-size: 12px;\n  cursor: pointer;\n}\n.tsd-price-target-btn:hover {\n  border-color: var(--dsw-alias-label-tertiary);\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-price-target-btn:focus-visible {\n  outline: 2px solid var(--dsw-alias-brand-primary);\n  outline-offset: 1px;\n}\n.tsd-price-target-btn[data-empty='true'] {\n  border-style: dashed;\n  color: var(--dsw-alias-label-tertiary);\n}\n.tsd-price-target-id {\n  min-width: 0;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n.tsd-price-target-chev { flex: none; opacity: 0.7; }\n/* 参考模型的来源标签：DeepSeek / Zen / 自定义。10px、无边框、只在格尾占一点点，\n   免得把 id 挤掉 —— id 自己已经会 ellipsis。 */\n.tsd-price-src {\n  margin-left: 4px;\n  padding: 0 3px;\n  border-radius: 4px;\n  background: var(--dsw-alias-interactive-bg-hover);\n  color: var(--dsw-alias-label-tertiary);\n  font-size: 10px;\n  white-space: nowrap;\n}\n.tsd-price-src[data-source='deepseek'] { color: var(--dsw-static-blue-500); }\n.tsd-price-src[data-source='custom'] { color: var(--dsw-static-green-500); }\n/* 候选列表里的分组表头：粘在滚动容器顶部，滚到哪都知道自己在看哪一类。 */\n.tsd-price-pick-group {\n  position: sticky;\n  top: 0;\n  padding: 4px 4px 2px;\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-tertiary);\n  font-size: 10.5px;\n  letter-spacing: 0.02em;\n}\n/* 空组（目前只有「自定义」）给一行说明，别让这一类隐形。 */\n.tsd-price-pick-sep {\n  margin: 4px 0;\n  border-top: 1px solid var(--dsw-alias-border-l2);\n}\n/* 「自定义」选项：顶部固定的一条，带一行说明。 */\n.tsd-price-pick-custom {\n  display: flex;\n  flex-direction: column;\n  align-items: flex-start;\n  gap: 2px;\n  border: 1px dashed var(--dsw-alias-border-l2);\n}\n.tsd-price-pick-custom-label { font-weight: 500; color: var(--dsw-alias-label-primary); }\n.tsd-price-pick-custom-hint { font-size: 11px; color: var(--dsw-alias-label-tertiary); }\n/* 手填单价的三格：一行一个字段，输入框占满剩余宽度。 */\n.tsd-price-custom-box { gap: 8px; }\n.tsd-price-custom-title { font-weight: 500; }\n.tsd-price-custom-field {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n}\n.tsd-price-custom-field > span {\n  flex: none;\n  width: 52px;\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-price-custom-input {\n  box-sizing: border-box;\n  flex: 1 1 auto;\n  min-width: 0;\n  height: 26px;\n  padding: 0 8px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  border-radius: 6px;\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-primary);\n  font: inherit;\n  font-size: 12px;\n}\n.tsd-price-custom-hint { color: var(--dsw-alias-label-tertiary); font-size: 11px; }\n.tsd-price-stale {\n  margin-left: 6px;\n  font-size: 11px;\n  color: var(--dsw-alias-state-warn-primary);\n}\n.tsd-price-rate {\n  font-variant-numeric: tabular-nums;\n  white-space: nowrap;\n  color: var(--dsw-alias-label-secondary);\n}\n/* 操作格：默认空着，只有「自定义 / 有改动」的行才给一颗还原图标。\n   注意别给 td 设 display:flex —— 那会把单元格块级化，整列失去对齐。 */\n.tsd-price-ops {\n  width: 34px;\n  text-align: right;\n  white-space: nowrap;\n}\n.tsd-price-reset {\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  width: 22px;\n  height: 22px;\n  padding: 0;\n  border: 1px solid transparent;\n  border-radius: 6px;\n  background: none;\n  color: var(--dsw-alias-label-tertiary);\n  cursor: pointer;\n}\n.tsd-price-reset:hover {\n  border-color: var(--dsw-alias-border-l2);\n  color: var(--dsw-alias-label-primary);\n}\n.tsd-price-reset:focus-visible {\n  outline: 2px solid var(--dsw-alias-brand-primary);\n  outline-offset: 1px;\n}\n.tsd-btn-xs {\n  height: 24px;\n  padding: 0 8px;\n  font-size: 12px;\n  border-radius: 6px;\n}\n/* 带图标的按钮：图标与文字同一行，间距由 gap 给，别在文案里塞空格 */\n.tsd-btn-icon-label {\n  display: inline-flex;\n  align-items: center;\n  gap: 6px;\n}\n/* 参考模型候选是一座浮层（DSH 自己的模型选择器就是这种交互），不再塞进表格里：\n   内联面板会把所在行撑高、把下面的行整体推走，看起来像表格坏了。 */\n.tsd-price-pick-box {\n  display: flex;\n  flex-direction: column;\n  gap: 6px;\n  min-height: 0;\n  padding: 6px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  border-radius: 10px;\n  background: var(--dsw-alias-bg-layer-1);\n  box-shadow: var(--dsw-shadow-lv3);\n}\n/* 四态徽标：精确(蓝) / 模糊(琥珀) / 未匹配(灰) / 自定义(绿)，颜色族都用真实 token */\n.tsd-price-badge {\n  display: inline-block;\n  padding: 1px 7px;\n  border-radius: 10px;\n  font-size: 11px;\n  line-height: 16px;\n  white-space: nowrap;\n  background: var(--dsw-static-neutral-200, rgba(128, 128, 128, 0.14));\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-price-badge[data-state='exact'] {\n  background: color-mix(in oklab, var(--dsw-static-deepseek-500) 16%, transparent);\n  color: var(--dsw-static-deepseek-500);\n}\n.tsd-price-badge[data-state='fuzzy'] {\n  background: color-mix(in oklab, var(--dsw-static-amber-500) 18%, transparent);\n  color: var(--dsw-static-amber-500);\n}\n.tsd-price-badge[data-state='custom'] {\n  background: color-mix(in oklab, var(--dsw-static-green-500) 16%, transparent);\n  color: var(--dsw-static-green-500);\n}\n/* 未匹配态没有主题色可用：容器那层 background: none 把徽标底色抹掉了，只剩\n   白字压在白底上。这里给它自己的底与字色，四态才都能看见。 */\n.tsd-price-row[data-state='none'] .tsd-price-badge {\n  background: var(--dsw-alias-interactive-bg-hover);\n  color: var(--dsw-alias-label-secondary);\n}\n.tsd-price-pick-input {\n  box-sizing: border-box;\n  width: 100%;\n  height: 28px;\n  padding: 0 8px;\n  border: 1px solid var(--dsw-alias-border-l2);\n  border-radius: 6px;\n  background: var(--dsw-alias-bg-layer-1);\n  color: var(--dsw-alias-label-primary);\n  font: inherit;\n  font-size: 12px;\n}\n/* 候选列表自己滚，且必须自己封顶：useFixedPanel 只给位置和宽度，不给高度，\n   89 个 id 摊开有近 2000px，不封顶就是一个超出视口的浮层。 */\n.tsd-price-pick-list {\n  display: flex;\n  flex-direction: column;\n  min-height: 0;\n  max-height: 260px;\n  overflow: auto;\n}\n.tsd-price-pick-item {\n  padding: 4px 8px;\n  border: none;\n  border-radius: 6px;\n  background: transparent;\n  color: var(--dsw-alias-label-primary);\n  font: inherit;\n  font-size: 12px;\n  text-align: left;\n  cursor: pointer;\n}\n.tsd-price-pick-item:hover { background: var(--dsw-alias-interactive-bg-hover); }\n.tsd-price-pick-item-active { color: var(--dsw-static-deepseek-500); font-weight: 600; }\n.tsd-price-history {\n  margin-top: 14px;\n  padding-top: 10px;\n  border-top: 1px solid var(--dsw-alias-border-l2);\n}\n.tsd-price-history-toggle {\n  display: inline-flex;\n  align-items: center;\n  gap: 6px;\n  padding: 2px 0;\n  border: none;\n  background: transparent;\n  color: var(--dsw-alias-label-secondary);\n  font: inherit;\n  font-size: 12px;\n  cursor: pointer;\n}\n.tsd-price-history-chev { transition: transform 0.15s ease; }\n.tsd-price-history-chev-open { transform: rotate(180deg); }\n.tsd-price-empty,\n.tsd-price-loading {\n  padding: 18px 0;\n  font-size: 12px;\n  color: var(--dsw-alias-label-tertiary);\n  text-align: center;\n}\n.tsd-price-foot {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  margin-top: 12px;\n  padding-top: 10px;\n  border-top: 1px solid var(--dsw-alias-border-l2);\n}\n.tsd-price-hint {\n  margin-left: auto;\n  font-size: 11px;\n  color: var(--dsw-alias-state-warn-primary);\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 rpcError(body && body.error, 'RPC ' + endpoint + ' failed')\n    })\n  })\n}\n\n/**\n * 把宿主返回的 `{code, message}` 变成可显示的错误。\n *\n * 宿主对未处理的异常只发稳定的 `internal`，细节写在宿主日志里；界面上显示本插件的\n * 一句话，而不是原始堆栈（原始错误不上页面）。\n */\nfunction rpcError(error, fallback) {\n  const code = error && error.code\n  const message = code === 'internal' ? fallbackT('rpcInternalError') : ((error && error.message) || fallback)\n  const wrapped = new Error(message)\n  if (code) wrapped.code = code\n  return wrapped\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.\n//\n// Channel preference, native first: the plugin's own typert Remote namespace\n// (`remote['dsh-plugin-usage']`, registered by src/host/typert.js), then the\n// Fetch routes on Connection's shared /api channel, then the legacy /usage\n// prefix channel. A Remote namespace that exists but fails (host restarted\n// mid-flight, receiver gone) must fall through instead of bricking the page.\nconst USAGE_REMOTE_NAMESPACE = 'dsh-plugin-usage'\n\n/**\n * Descriptors for the client-side mount.\n *\n * The gateway's browser half wants a `src-json` result (a direct invocation is\n * not result-decoded), while the host contribution declares a strict codec.\n * Everything else must match the host field for field.\n */\nfunction remoteDescriptors(packageName, names) {\n  const argsCodec = () => ({\n    mode: 'strict',\n    typeSymbol: packageName + '/typert#EndpointArgs',\n    create: () => ({ parse: (value) => value }),\n  })\n  return names.map((name) => ({\n    id: packageName + '#' + packageName + '/' + name,\n    service: packageName,\n    namespace: packageName,\n    method: name,\n    invocation: { kind: 'direct' },\n    parameters: [{ name: 'args', wire: 'args', source: 'json', codec: argsCodec() }],\n    result: { mode: 'src-json' },\n  }))\n}\n\n/**\n * Join the native Remote channel on the browser side.\n *\n * A face registered at runtime on the host is invisible to the client's `remote`\n * proxy until the consumer mounts it. Until the mount lands — or if it never\n * does — hostCall keeps using the Fetch routes, so this is an optimization,\n * never a hard dependency.\n */\nfunction mountRemoteChannel(scope) {\n  let remote = null\n  try {\n    remote = scope.get('remote')\n  } catch (e) {\n    return\n  }\n  if (!remote || typeof remote.$mount !== 'function') return\n  fetchCall('usage/contract', {}).then((contract) => {\n    const names = contract && Array.isArray(contract.names) ? contract.names : []\n    if (names.length === 0) return null\n    const packageName = contract.package || USAGE_REMOTE_NAMESPACE\n    return Promise.resolve(remote.$mount({ package: packageName, descriptors: remoteDescriptors(packageName, names) }))\n  }).catch(() => {\n    // Stay on the Fetch routes; the host reports which channel it opened.\n  })\n}\n\nfunction remoteCall(scope, method, args) {\n  const name = String(method)\n  const slash = name.indexOf('/')\n  const endpoint = slash === -1 ? name : name.slice(slash + 1)\n  const camel = endpoint.replace(/-([a-z])/g, (m, c) => c.toUpperCase())\n  for (const service of [USAGE_REMOTE_NAMESPACE, 'usage']) {\n    // `ctx.get('remote.<namespace>')` is the service key the gateway creates per\n    // face (dsh-api-gateway client: remoteServiceKey). The `remote[namespace]`\n    // property is the older shape and throws on the strict proxy, so it is a\n    // guarded second choice.\n    let namespace = null\n    try {\n      namespace = scope.get('remote.' + service)\n    } catch (e) {\n      namespace = null\n    }\n    if (!namespace) {\n      try {\n        const remote = scope.get('remote')\n        namespace = remote ? remote[service] : null\n      } catch (e) {\n        namespace = null\n      }\n    }\n    if (!namespace) continue\n    const fn = (typeof namespace[camel] === 'function' && namespace[camel])\n      || (typeof namespace[endpoint] === 'function' && namespace[endpoint])\n    if (!fn) continue\n    return Promise.resolve()\n      .then(() => fn(args))\n      .then((res) => {\n        if (res && res.ok) return res.value\n        throw rpcError(res && res.error, 'RPC ' + method + ' failed')\n      })\n  }\n  return null\n}\n\nfunction hostCall(method, args) {\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    let pending = null\n    try {\n      pending = remoteCall(remoteScope, method, args)\n    } catch (e) {\n      pending = null\n    }\n    if (pending !== null) {\n      // Fall through to the Fetch routes when the Remote namespace turns out to\n      // be unreachable — the two channels answer the same question.\n      return pending.catch(() => fetchCall(method, args))\n    }\n  }\n  if (typeof host !== 'undefined' && host && typeof host.call === 'function') {\n    return Promise.resolve(host.call(method, args))\n  }\n  return fetchCall(method, args)\n}\n\nfunction fetchCall(method, args) {\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 rpcError(res && res.error, '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 * ------------------------------------------------------------------------- */\n/**\n * 原生日志通道：宿主有 logger 就写它（官方插件都走 ctx.logger），否则退回 console。\n * ctx 是严格代理，未注入的属性能抛，所以整段包在 try 里。\n */\nfunction logWarn(message, detail) {\n  try {\n    const scope = (typeof _usageCtx !== 'undefined' && _usageCtx) ? _usageCtx : null\n    const logger = scope && typeof scope.get === 'function' ? scope.get('logger') : null\n    if (logger && typeof logger.warn === 'function') { logger.warn(message, detail); return }\n    if (scope && scope.logger && typeof scope.logger.warn === 'function') { scope.logger.warn(message, detail); return }\n  } catch (e) { /* no logger on this composition */ }\n  console.warn(message, detail)\n}\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  dockHint: '今日 {cost} · {calls} 次调用 · {tokens} Token',\n  dockUnpriced: '未定价',\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  // 参考成本卡上的常驻脚注：口径（卡片是估算而不是账单）+ 高峰规则（单价按\n  // 北京时间分峰谷，不说清楚就等于藏了一条计价条件）。\n  costSourceNote: '按 opencode Zen 和 DeepSeek 最新定价口径估算',\n  peakRuleShort: '北京时间周一至周五 9:00-12:00、14:00-18:00 为高峰，法定节假日除外',\n  holidayNote: '节假日数据：{range}',\n  holidayNoteUnpublished: '节假日数据：{range}；{years} 尚未公布，该年按周末判定（落在高峰窗口的节假日可能被算高）',\n  pricingOpen: '拉取最新定价匹配',\n  pricingTitle: '定价匹配',\n  pricingDesc: '本会话出现过的模型会按名称逐级匹配到定价表；未匹配的按 0 计价，计入「未定价」。',\n  pricingPull: '更新匹配表',\n  pricingHistory: '历史匹配（{n}）',\n  pricingHistoryEmpty: '还没有确认过的匹配',\n  pricingColModel: '模型',\n  pricingColMatch: '匹配到',\n  pricingColState: '状态',\n  pricingColPrice: '单价（{unit} / 1M）',\n  pricingSave: '确定',\n  pricingClear: '恢复自动匹配',\n  pricingApplyHint: '改完点「确定」才生效',\n  pricingHowAlias: '按别名',\n  // 模糊态的徽标：别名、孪生、变体后缀（-fast / -1017 / -free）都落在这一态，\n  // 所以文案说「推测」而不是某一种推断的名字；具体依据看徽标的 tooltip。\n  pricingHowTwin: '按名称推测',\n  pricingHowLiteral: '按名称精确',\n  pricingHowCustom: '用户指定',\n  // 未匹配态的徽标文案。原来 MATCH_STATE_LABEL 指向一个不存在的键\n  // 'unmatched'，t() 缺键时原样返回 key，于是徽标上印着英文 \"unmatched\"。\n  pricingHowNone: '未匹配',\n  pricingStale: '定价表里已没有这个模型',\n  pricingTableMeta: '数据源 {source} · 读取于 {date}',\n  pricingCounts: '精确 {exact} · 模糊 {fuzzy} · 未匹配 {none} · 自定义 {custom}',\n  pricingBothTiers: '高峰 {peak} · 空闲 {off}',\n  pricingSourceDeepseek: 'DeepSeek',\n  pricingSourceZen: 'Zen',\n  pricingSourceCustom: '自定义',\n  // 「自定义」是选择器顶部的一个选项，不是一组参考模型：选它就直接给这一行填三个单价。\n  pricingCustomOption: '自定义',\n  pricingCustomHint: '直接填每百万 Token 的单价',\n  pricingCustomInput: '输入',\n  pricingCustomOutput: '输出',\n  pricingCustomCacheRead: '缓存读',\n  pricingCustomUnit: '单位：{unit} / 1M Token',\n  pricingCustomPending: '待填写',\n  rpcInternalError: '统计服务出错了，细节已写进宿主日志',\n  done: '完成',\n  pricingCardNoteTip: '参考成本的算法、匹配范围与高峰时段规则',\n  askEmpty: '暂无待匹配的模型',\n  askPick: '选择参考模型',\n  pricingFailed: '定价表拉取失败：{message}',\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  loading: '正在加载用量数据…',\n  computing: '正在统计 {done}/{total} 个会话…',\n  emptyDesc: '该时间段内没有调用记录',\n  emptyFiltered: '当前筛选条件下没有数据，试试调整时间范围或模型',\n  resetFilters: '重置筛选',\n  loadFailed: '数据加载失败：{message}',\n  loadFailedTitle: '数据加载失败',\n  retry: '重试',\n  barAria: '{key}，输入 {in} Token，输出 {out} Token，合计 {tot} Token，参考成本 {cost}',\n  hmTitle: '{key}：{tokens} Token{calls}，参考成本 {cost}',\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  dockHint: 'Today {cost} · {calls} calls · {tokens} tokens',\n  dockUnpriced: 'unpriced',\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  costSourceNote: 'Estimated from the current opencode Zen and DeepSeek price lists',\n  peakRuleShort: 'Peak: Mon-Fri 09:00-12:00 and 14:00-18:00 Beijing time, excluding public holidays',\n  holidayNote: 'Holiday calendar: {range}',\n  holidayNoteUnpublished: 'Holiday calendar: {range}; {years} is not published yet, so that year falls back to the weekend rule (a holiday inside a peak window may be billed high)',\n  pricingOpen: 'Pull the latest price matching',\n  pricingTitle: 'Price matching',\n  pricingDesc: 'Models seen in this session are matched to the price list by name, one level at a time. Anything unmatched is billed at 0 and listed under unpriced.',\n  pricingPull: 'Update matches',\n  pricingHistory: 'Confirmed matches ({n})',\n  pricingHistoryEmpty: 'No match has been confirmed yet',\n  pricingColModel: 'Model',\n  pricingColMatch: 'Matched to',\n  pricingColState: 'State',\n  pricingColPrice: 'Rate ({unit} / 1M)',\n  pricingSave: 'Apply',\n  pricingClear: 'Back to automatic',\n  pricingApplyHint: 'Nothing changes until you press Apply',\n  pricingHowAlias: 'by alias',\n  pricingHowTwin: 'inferred from the name',\n  pricingHowLiteral: 'by exact name',\n  pricingHowCustom: 'set by you',\n  pricingHowNone: 'unmatched',\n  pricingStale: 'This model is no longer in the price list',\n  pricingTableMeta: 'Sources {source} · read {date}',\n  pricingCounts: 'exact {exact} · fuzzy {fuzzy} · unmatched {none} · custom {custom}',\n  pricingBothTiers: 'Peak {peak} · off-peak {off}',\n  pricingSourceDeepseek: 'DeepSeek',\n  pricingSourceZen: 'Zen',\n  pricingSourceCustom: 'Custom',\n  pricingCustomOption: 'Custom',\n  pricingCustomHint: 'Type the per-million rates by hand',\n  pricingCustomInput: 'Input',\n  pricingCustomOutput: 'Output',\n  pricingCustomCacheRead: 'Cache read',\n  pricingCustomUnit: 'Unit: {unit} per 1M tokens',\n  pricingCustomPending: 'not set',\n  rpcInternalError: 'The usage service failed — details are in the host log',\n  done: 'Done',\n  pricingCardNoteTip: 'How the reference cost is estimated, which models it covers, and the peak-hour rule',\n  askEmpty: 'No model is waiting to be matched',\n  askPick: 'Choose a reference model',\n  pricingFailed: 'Could not load the price lists: {message}',\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  loading: 'Loading usage data…',\n  computing: 'Computing {done}/{total} sessions…',\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, {cost} reference cost',\n  hmTitle: '{key}: {tokens} tokens{calls}, {cost} reference cost',\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  x: 'M6 6l12 12M18 6L6 18',\n  // 拉取匹配表按钮的图标：DSH 原生 icon-context-injection-outline。16 网格、\n  // 线宽 1.5；图形是「剪贴板 + 从顶部穿入的下载箭头 + 一条内容线」，描边沿用\n  // 外层的 currentColor，所以每条 path 只给 d。\n  contextInjection: {\n    viewBox: '0 0 16 16',\n    strokeWidth: 1.5,\n    paths: [\n      'M5 2.5H3.5C3.23478 2.5 2.98043 2.60536 2.79289 2.79289C2.60536 2.98043 2.5 3.23478 2.5 3.5V13.5C2.5 13.7652 2.60536 14.0196 2.79289 14.2071C2.98043 14.3946 3.23478 14.5 3.5 14.5H12.5C12.7652 14.5 13.0196 14.3946 13.2071 14.2071C13.3946 14.0196 13.5 13.7652 13.5 13.5V3.5C13.5 3.23478 13.3946 2.98043 13.2071 2.79289C13.0196 2.60536 12.7652 2.5 12.5 2.5H11',\n      'M8 0.5V7.5',\n      'M5.5 5L8 7.5L10.5 5',\n      'M5.5 11H10.5',\n    ],\n  },\n  // 提示记号：圆圈 + 感叹号（16 网格、线宽 1.5）。原来用一个 CSS 伪元素画「?」，\n  // 字重太小、缩到 10px 后几乎看不见，也不能点；换成真图标后可以当按钮用。\n  hint: {\n    viewBox: '0 0 16 16',\n    strokeWidth: 1.5,\n    paths: [\n      'M8 1.75a6.25 6.25 0 1 1 0 12.5a6.25 6.25 0 1 1 0-12.5Z',\n      'M8 4.9v3.5',\n      'M8 11.15h.01',\n    ],\n  },\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  // `computing` 表示\"统计还没算完\"（宿主 backfill.status === 'running'），\n  // 和 `busy`（这一轮请求在飞）不是一回事：请求几十毫秒就结束，而全量统计要几秒。\n  // 只在请求在飞时转圈，用户就会看到\"页面明明没算完却什么都不动\"。\n  const { busy, onRefresh, computing, computeDone, computeTotal } = props\n  const t = useT()\n  const subtitle = computing\n    ? t('computing', { done: formatInt(computeDone || 0), total: formatInt(computeTotal || 0) })\n    : t('subtitle')\n  return h('div', { className: 'tsd-header' },\n    h('div', { className: 'tsd-header-text' },\n      h('h2', { className: 'tsd-title' }, t('nav')),\n      // 副标题这一句直接换成进度句：同一个位置、同样的行高，所以不算完→算完不跳版。\n      h('p', { className: 'tsd-subtitle', role: computing ? 'status' : null }, subtitle)),\n    h('button', {\n      type: 'button',\n      className: 'tsd-icon-btn' + (busy || computing ? ' tsd-spinning' : ''),\n      onClick: onRefresh,\n      disabled: busy,\n      'aria-busy': busy || computing || 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/**\n * 「读取于」要的是真实时刻，不是日期。\n *\n * 价目表里存的是抓取那一刻的 ISO 时间（带秒、UTC）；这里换成浏览器本地时区\n * 显示，精确到秒。早期只有日期（`2026-10-19`）的表也认得，补 00:00:00。\n */\nfunction stampText(v) {\n  if (!v) return '—'\n  const d = new Date(v)\n  if (Number.isNaN(d.getTime())) return String(v)\n  const p = (n) => (n < 10 ? '0' + n : String(n))\n  return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate()) +\n    ' ' + p(d.getHours()) + ':' + p(d.getMinutes()) + ':' + p(d.getSeconds())\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.unpriced === true ? 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 * 标题旁的提示记号\n *\n * 「点击 / 悬浮双显示」是硬要求：\n *  - 悬浮走原生 title（浏览器自己弹，不依赖脚本，也不会被设置面板的 overflow 裁掉）；\n *  - 点击展开同一个浮层 —— 触屏没有 hover，键盘也要能读到，且浮层里两段规则换行\n *    读起来比一整行 tooltip 清楚得多。\n * 原生 title 与浮层共用同一份文本（宿主/调用方只传一次），不维护第二份文案。\n * ------------------------------------------------------------------------- */\nfunction HintTip(props) {\n  const { text, label } = props\n  const [open, setOpen] = React.useState(false)\n  const ref = React.useRef(null)\n  const panelStyle = useFixedPanel(ref, open, 260)\n  useOutsideClick(open, ref, () => setOpen(false))\n  const lines = String(text == null ? '' : text).split('\\n').filter((s) => s.trim().length > 0)\n  return h('span', { className: 'tsd-hint', ref },\n    h('button', {\n      type: 'button',\n      className: 'tsd-hint-btn' + (open ? ' tsd-hint-btn-open' : ''),\n      title: text || null,\n      'aria-label': label || text || '',\n      'aria-expanded': open,\n      onClick: () => setOpen((v) => !v),\n      onKeyDown: (e) => {\n        if (e.key === 'Escape' && open) { e.stopPropagation(); setOpen(false) }\n      },\n    }, h(SvgIcon, { name: 'hint', size: 12 })),\n    open\n      ? h('div', {\n          className: 'tsd-popover tsd-hint-popover',\n          style: panelStyle,\n          role: 'note',\n        }, lines.map((s, i) => h('p', { key: i, className: 'tsd-hint-line' }, s)))\n      : null)\n}\n\n/* ---------------------------------------------------------------------------\n * 汇总指标卡 ×6\n * ------------------------------------------------------------------------- */\n\n/**\n * 节假日覆盖说明：哪些年份在手、哪一年还没公布。\n *\n * 峰谷价依赖中国法定节假日表；未公布的年份只能按「周末 + 时段」判定，节假日\n * 落在高峰窗口内的调用会被算高。与其让这个误差隐身，不如在「参考成本」的提示\n * 里把覆盖范围写清楚。\n */\nfunction holidayNote(pricing, t) {\n  const years = pricing && pricing.holidays && typeof pricing.holidays === 'object'\n    ? Object.keys(pricing.holidays).map(Number).filter((n) => Number.isFinite(n)).sort((a, b) => a - b)\n    : []\n  if (years.length === 0) return null\n  const range = years.length === 1 ? String(years[0]) : years[0] + '–' + years[years.length - 1]\n  const missing = years.filter((year) => pricing.holidays[year] && pricing.holidays[year].unpublished === true)\n  if (missing.length === 0) return t('holidayNote', { range })\n  return t('holidayNoteUnpublished', { range, years: missing.join('、') })\n}\n\n/* 统计卡的槽位表：骨架屏按它画占位块。\n *\n * 这张表存在的唯一理由是**别再漂**：骨架屏曾经写死 5 个占位块，而真实卡片已经\n * 6 张（补了「模型占比」），结果加载态少一格、数据到达时整行重排。\n * 槽位顺序必须与 `SummaryCards` 里的 `cards` 数组一致 —— `tests/client-slots.test.js`\n * 会逐字比对两边的 key 列表，改一处漏另一处直接变红。\n */\nconst SUMMARY_CARD_SLOTS = ['total', 'input', 'output', 'calls', 'cost', 'share']\n\nfunction SummaryCards(props) {\n  const { total, currency, unpricedCalls, currencyCode, onCurrencyChange, byModel, pricing, onOpenPricing } = 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'), action: true,\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      // 未定价条数仍然留在卡面上：它是一条待办，不是解释。\n      tip: [tt('costSourceNote'), tt('peakRuleShort'), holidayNote(pricing, tt)].filter(Boolean).join('\\n'),\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', title: c.tip || null }, c.label),\n          // 提示记号是独立按钮：悬浮有原生 title，点击展开浮层。\n          c.tip ? h(HintTip, { text: c.tip, label: tt('pricingCardNoteTip') }) : null,\n          // 参考成本卡的「怎么算出来的」入口：打开匹配弹窗。图标与弹窗里的\n          // 「更新匹配表」同款（剪贴板），一眼看出两者是同一件事。\n          c.action\n            ? h('button', {\n                type: 'button',\n                className: 'tsd-card-action',\n                title: tt('pricingOpen'),\n                'aria-label': tt('pricingOpen'),\n                onClick: onOpenPricing,\n              }, h(SvgIcon, { name: 'contextInjection', size: 12 }))\n            : null),\n        c.content\n          ? c.content\n          : h('div', { className: 'tsd-card-value', title: c.title }, c.prefix || null, c.value),\n        // 参考成本卡的脚注：口径与高峰规则已移到标题的悬浮提示，这里只剩\n        // 「还有几次调用没定价」这条待办（有事才出现）。\n        c.key === 'cost' && unpricedCalls > 0\n          ? h('div', { className: 'tsd-card-notes' },\n              h('div', { className: 'tsd-card-note tsd-card-note-warn' }, tt('unpricedNote', { count: formatInt(unpricedCalls) })))\n          : null,\n        c.sub ? h('div', { className: 'tsd-card-sub' }, c.sub) : null)))\n}\n\n/* ---------------------------------------------------------------------------\n * 定价匹配弹窗\n *\n * 解决的是「参考成本为什么是这个数」：每个模型按名称逐级匹配到定价表，匹配\n * 结果分四态（精确 / 模糊 / 未匹配 / 自定义），四态都能改、都能收回。\n *\n * 两条硬规则写在这里，别处不要各写一份：\n *  1. 打开弹窗、拉取匹配表都**不落盘**。只有「确定」才写，写入的是脏行和被\n *     收回的 key —— 没动过的行不写，免得把别人刚确认的匹配覆盖掉。\n *  2. 候选来自当前定价表的 id（宿主 propose 一并带回），不在前端另存一份名单。\n * ------------------------------------------------------------------------- */\nconst MATCH_STATE_LABEL = { exact: 'pricingHowLiteral', fuzzy: 'pricingHowTwin', none: 'pricingHowNone', custom: 'pricingHowCustom' }\n\n/*\n * 四态由宿主给（priceRow.state），前端不再解释 how。\n * 这里曾经有一份 matchStateOf(row)，把 how 映射成四态；它写死了一个阶梯里不存在\n * 的值（'literal'），于是所有精确命中都显示成「未匹配」——两个词表，两处维护，\n * 一处错就全错。现在只有一处：pricing.js 的 resolvePrice。\n */\n\n/** 弹窗里改动的草稿：key → { target, cleared, dirty }。 */\nfunction mergeDraft(prev, key, patch) {\n  const next = { ...prev }\n  const cur = next[key] || { target: null, cleared: false, dirty: false }\n  next[key] = { ...cur, ...patch, dirty: true }\n  return next\n}\n\n/** 一行提交时会带什么：`undefined` = 没动过，不提交。 */\nfunction decisionOf(draft) {\n  if (!draft || !draft.dirty) return undefined\n  if (draft.cleared) return { key: draft.key, clear: true }\n  if (typeof draft.target === 'string' && draft.target !== '') return { key: draft.key, target: draft.target }\n  return undefined\n}\n\nfunction PricingDialog(props) {\n  const { onClose, onApplied, currency } = props\n  const t = useT()\n  const [rows, setRows] = React.useState([])\n  const [table, setTable] = React.useState(null)\n  const [saved, setSaved] = React.useState({})\n  const [draft, setDraft] = React.useState({})\n  const [status, setStatus] = React.useState('loading') // loading | ready | error\n  const [error, setError] = React.useState(null)\n  const [saving, setSaving] = React.useState(false)\n  const [pickFor, setPickFor] = React.useState(null) // 正在选参考模型的 key\n  const [pickText, setPickText] = React.useState('')\n  const [editFor, setEditFor] = React.useState(null) // 正在手填单价的 key（自定义选项）\n  const [historyOpen, setHistoryOpen] = React.useState(false)\n  // 候选列表挂在行内「匹配到」那一格上：浮层是 position: fixed，撑不开表格；\n  // 但 DOM 上仍留在那一格里 —— useOutsideClick 用 contains 判内外，必须这样挂。\n  const pickAnchor = React.useRef(null)\n  const closePick = React.useCallback(() => {\n    setPickFor(null)\n    setPickText('')\n  }, [])\n  const pickStyle = useFixedPanel(pickAnchor, pickFor !== null, 300, 4, 12)\n  const customStyle = useFixedPanel(pickAnchor, editFor !== null, 280, 4, 12)\n  useOutsideClick(pickFor !== null, pickAnchor, closePick)\n\n  const pull = React.useCallback(() => {\n    setStatus('loading')\n    setError(null)\n    hostCall('usage/query', { fill: false, models: [], heatmap: false, backfill: false })\n      .then((r) => {\n        const seen = Array.isArray(r && r.models) ? r.models : []\n        return hostCall('usage/pricing', { action: 'propose', models: seen })\n      })\n      .then((v) => {\n        setRows(Array.isArray(v && v.rows) ? v.rows : [])\n        setTable(v && v.table ? v.table : null)\n        setSaved(v && v.matchMap ? v.matchMap : {})\n        setDraft({})\n        setStatus('ready')\n      }, (e) => {\n        setError(e)\n        setStatus('error')\n      })\n  }, [])\n\n  React.useEffect(() => { pull() }, [pull])\n\n  const counts = React.useMemo(() => {\n    const n = { exact: 0, fuzzy: 0, none: 0, custom: 0 }\n    // 每一行都自带 state（宿主 priceRow 给的），前端不再从 how 反推 —— 反推过\n    // 一次，写死的 'literal' 阶梯里根本不存在，所有精确命中都显示成「未匹配」。\n    for (const r of rows) n[r.state] += 1\n    return n\n  }, [rows])\n\n  // 单价本身是美元价（价目表就是美元），显示时套用当前展示币种，和卡片同一个数。\n  const moneyPerUsd = React.useCallback(() => (currency && currency.code === 'USD' ? 1 : 7), [currency])\n  const moneyOf = React.useCallback((usd) => {\n    const code = currency && currency.code === 'USD' ? 'USD' : 'CNY'\n    const symbol = currency && currency.symbol ? currency.symbol : (CURRENCY_SYMBOLS[code] || '¥')\n    return typeof usd === 'number' ? formatCost(usd * (code === 'USD' ? 1 : 7), symbol) : '—'\n  }, [currency])\n  // 表头单位必须和单元格用的是同一个符号，否则会出现「单价（$ / 1M）」配「¥2.10」。\n  const priceUnit = (currency && currency.symbol) || '¥'\n\n  // 待选 = 阶梯没找到价的行。判据用 state 而不是 unpriced：`unpriced` 是查询那边\n  // 「某条记录没价」的字段，propose 的行从来没有它 —— 拿它当过滤条件的后果是待选\n  // 表永远是空的，未匹配的模型一行都露不出来。\n  const pending = rows.filter((r) => r.state === 'none')\n  // 历史表 = 已经写进 matchMap 的 confirmed 记录。判据只看 matchMap：目标若已从\n  // 价目表下线，这一行仍然留在这里（还能收回），主表里则按「未匹配」显示并标 stale。\n  const historyRows = rows.filter((r) => saved[r.key] !== undefined)\n  const pendingRows = pending.filter((r) => !historyRows.includes(r))\n  const matchedRows = rows.filter((r) => r.state !== 'none' && !historyRows.includes(r))\n  // 空状态判的是主表有没有行。此前判的是 `pending.length` —— 只要有模型按阶梯\n  // 命中了价，第一张表就整块消失，于是「精确 / 模糊」两种状态永远没机会露面。\n  const hasMainRows = pendingRows.length > 0 || matchedRows.length > 0\n\n  // 注意：组件里的 `setDraft` 是 useState 的 setter，不是上面那个纯函数。\n  // 写成 setDraft((prev) => setDraft(prev, ...)) 会递归调自己（初值 undefined），\n  // 所以这里用纯函数的名字 `mergeDraft` 区分开。\n  const choose = (key, target) => {\n    setDraft((prev) => mergeDraft(prev, key, { target, cleared: false, custom: null, key }))\n    setEditFor(null)\n    closePick()\n  }\n  const clearRow = (key) => {\n    setDraft((prev) => mergeDraft(prev, key, { target: null, cleared: true, custom: null, key }))\n    setEditFor((k) => (k === key ? null : k))\n  }\n\n  /** 手填单价：三格，都是「每百万 Token」的展示币种金额。 */\n  const CUSTOM_FIELDS = [['input', 'pricingCustomInput'], ['output', 'pricingCustomOutput'], ['cacheRead', 'pricingCustomCacheRead']]\n  /** 某个 key 当前的手填值（草稿优先，其次宿主已有的自定义价）。 */\n  const customOf = (r) => {\n    const d = draft[r.key]\n    if (d && d.custom) return d.custom\n    // 宿主已按自定义价计过账：用它当前的费率回填，方便改。\n    if (r.how === 'custom' && r.rates) {\n      const per = moneyPerUsd()\n      const at = r.rates.peak || r.rates.offPeak\n      return {\n        input: String(Number((at.input * per).toFixed(4))),\n        output: String(Number((at.output * per).toFixed(4))),\n        cacheRead: String(Number((at.cacheRead * per).toFixed(4))),\n      }\n    }\n    return { input: '', output: '', cacheRead: '' }\n  }\n  /** 开始手填：把这一行切成编辑态，草稿里先放一份可编辑的值。 */\n  const startCustom = (key) => {\n    const row = rows.find((x) => x.key === key)\n    const seed = row ? customOf(row) : { input: '', output: '', cacheRead: '' }\n    setDraft((prev) => mergeDraft(prev, key, { target: null, cleared: false, custom: seed, key }))\n    setEditFor(key)\n    closePick()\n  }\n  const setCustomField = (key, field, value) => {\n    setDraft((prev) => {\n      const cur = (prev[key] && prev[key].custom) || { input: '', output: '', cacheRead: '' }\n      return mergeDraft(prev, key, { target: null, cleared: false, custom: { ...cur, [field]: value }, key })\n    })\n  }\n\n  const dirtyKeys = Object.keys(draft).filter((k) => draft[k].dirty)\n  /** 三格都能读成非负数字才算一条手填价，否则不发出去（避免把空串写成 0）。 */\n  const customOfDraft = (d) => {\n    if (!d || !d.custom) return null\n    const out = {}\n    for (const [field] of CUSTOM_FIELDS) {\n      const raw = String(d.custom[field] == null ? '' : d.custom[field]).trim()\n      if (raw === '') return null\n      const v = Number(raw)\n      if (!Number.isFinite(v) || v < 0) return null\n      out[field] = v\n    }\n    return out\n  }\n  const submit = () => {\n    if (dirtyKeys.length === 0 || saving) { if (dirtyKeys.length === 0) onClose(); return }\n    const decisions = []\n    const cleared = []\n    const customs = []\n    for (const k of dirtyKeys) {\n      const d = draft[k]\n      if (d.cleared) cleared.push(k)\n      else if (d.custom) {\n        const rate = customOfDraft(d)\n        if (rate !== null) customs.push({ key: k, ...rate })\n      } else if (typeof d.target === 'string' && d.target !== '') decisions.push({ key: k, target: d.target })\n    }\n    setSaving(true)\n    hostCall('usage/pricing', { action: 'commit', decisions, cleared, customs, currency: currency && currency.code ? currency.code : 'CNY' })\n      .then((v) => {\n        setSaving(false)\n        setDraft({})\n        setEditFor(null)\n        if (onApplied) onApplied(v)\n        onClose()\n      }, (e) => {\n        setSaving(false)\n        setError(e)\n        setStatus('error')\n      })\n  }\n\n  const onKeyDown = (e) => {\n    if (e.key === 'Escape') {\n      // 一路退出：先收候选列表，再关弹窗\n      if (pickFor !== null) { closePick(); return }\n      onClose()\n    }\n  }\n\n  // 单价：宿主给的是两档费率（rates），tier 是它自己算的「现在按哪档显示」。\n  // 前端只查表、不猜档 —— 之前宿主把档折成一行再发过来，另一档就凭空消失了。\n  const rateLine = (rates) => [rates.input, rates.output, rates.cacheRead].map(moneyOf).join(' / ')\n  const priceLine = (r) => {\n    // 手填价：三格都填好就照填的印（它们本来就是展示币种），否则提示还没填完。\n    const d = r ? draft[r.key] : null\n    if (d && d.custom) {\n      const vals = CUSTOM_FIELDS.map(([field]) => String(d.custom[field] == null ? '' : d.custom[field]).trim())\n      if (vals.every((v) => v !== '' && Number.isFinite(Number(v)))) {\n        return vals.map((v) => priceUnit + Number(v).toFixed(2)).join(' / ')\n      }\n      return t('pricingCustomPending')\n    }\n    return r && r.rates ? rateLine(r.rates[r.tier] || r.rates.peak) : t('unpriced')\n  }\n  /** 悬停时把两档都列出来：同一格只印一档，但不能让另一半价格看不见。 */\n  const priceTitle = (r) => {\n    if (!r || !r.rates) return null\n    return t('pricingBothTiers', { peak: rateLine(r.rates.peak), off: rateLine(r.rates.offPeak) })\n  }\n\n  // 参考模型候选按来源分组：DeepSeek 官方、opencode Zen。「自定义」不是一个组，\n  // 而是列表顶部的一个单独选项 —— 选它不是挑一个参考模型，而是直接给这一行填\n  // 三个单价（输入 / 输出 / 缓存读），存进 `prices`。\n  const SOURCE_LABEL = { deepseek: 'pricingSourceDeepseek', zen: 'pricingSourceZen', custom: 'pricingSourceCustom' }\n  const candidateGroups = () => {\n    if (!table || !Array.isArray(table.groups)) return []\n    const q = pickText.trim().toLowerCase()\n    let budget = 80\n    const out = []\n    for (const group of table.groups) {\n      const all = Array.isArray(group.ids) ? group.ids : []\n      const ids = all.filter((id) => (q === '' ? true : id.toLowerCase().includes(q)))\n      if (ids.length === 0) continue\n      const kept = ids.slice(0, Math.max(0, budget))\n      budget -= kept.length\n      out.push({ source: group.source, ids: kept })\n      if (budget <= 0) break\n    }\n    return out\n  }\n\n  /** 某组里的 id 属于哪个来源（草稿刚选的目标也查得到）。 */\n  const sourceOf = (id) => {\n    if (!id || !table || !Array.isArray(table.groups)) return null\n    for (const group of table.groups) {\n      if (Array.isArray(group.ids) && group.ids.includes(id)) return group.source\n    }\n    return null\n  }\n\n  /**\n   * 当前行要显示的匹配目标：草稿优先于宿主的答案。\n   *\n   * 用户刚选完目标就要立刻看见，否则读起来像「点了没反应」；已收回的显示为空。\n   */\n  const shownOf = (r) => {\n    const d = draft[r.key]\n    if (!d) return r.target\n    if (d.cleared) return null\n    if (d.custom) return null // 手填价没有参考模型 id，格子显示「自定义」\n    return d.target\n  }\n\n  /** 一行的四态：收回即未匹配，选了目标或手填价即自定义，其余用宿主给的 state。 */\n  const stateOf = (r) => {\n    const d = draft[r.key]\n    if (d && d.cleared) return 'none'\n    if (d && (d.target || d.custom)) return 'custom'\n    return r.state\n  }\n\n  /**\n   * 选择器本体。\n   *\n   * 未匹配的行不再要求先点一次「选择参考模型」：展开的那一刻输入框就带焦点，\n   * 选完直接落进草稿（仍然要按「确定」才写盘）。\n   */\n  const pickerFor = (key) => {\n    const row = rows.find((x) => x.key === key)\n    const cur = row ? shownOf(row) : null\n    return [\n      h('input', {\n        key: 'q',\n        type: 'text',\n        className: 'tsd-price-pick-input',\n        value: pickText,\n        placeholder: t('askPick'),\n        autoFocus: true,\n        onChange: (e) => setPickText(e.target.value),\n      }),\n      h('div', { key: 'l', className: 'tsd-price-pick-list', role: 'listbox' },\n        // 顶部固定一条「自定义」：选它不是挑参考模型，而是给这一行手填三个单价。\n        h('button', {\n          key: 'custom',\n          type: 'button',\n          role: 'option',\n          'aria-selected': 'false',\n          className: 'tsd-price-pick-item tsd-price-pick-custom',\n          onClick: () => startCustom(key),\n        },\n          h('span', { className: 'tsd-price-pick-custom-label' }, t('pricingCustomOption')),\n          h('span', { className: 'tsd-price-pick-custom-hint' }, t('pricingCustomHint'))),\n        h('div', { key: 'sep', className: 'tsd-price-pick-sep', role: 'presentation' }),\n        // 一组一个表头 + 若干选项。role 保持 listbox/option，表头只是分组标签。\n        candidateGroups().map((group) => [\n          h('div', {\n            key: 'g:' + group.source,\n            className: 'tsd-price-pick-group',\n            role: 'presentation',\n          }, t(SOURCE_LABEL[group.source] || group.source)),\n          ...group.ids.map((id) => h('button', {\n            key: id,\n            type: 'button',\n            role: 'option',\n            'aria-selected': id === (cur || ''),\n            className: 'tsd-price-pick-item' + (id === cur ? ' tsd-price-pick-item-active' : ''),\n            onClick: () => choose(key, id),\n          }, id)),\n        ])),\n    ]\n  }\n\n  const bindPickAnchor = (el) => { if (el) pickAnchor.current = el }\n\n  const renderRow = (r) => {\n    const d = draft[r.key]\n    const state = stateOf(r)\n    const shown = shownOf(r)\n    const picking = pickFor === r.key\n    const editing = editFor === r.key\n    const openPick = () => { if (picking) { closePick(); return } setEditFor(null); setPickFor(r.key); setPickText('') }\n    // 还原只在真的改过（或历史确认过）的行上出现：精确/模糊命中的行本来就没有\n    // 可还原的东西，每行都挂一颗按钮只会把表格挤成表单。\n    const canReset = state === 'custom' || (d && d.dirty)\n    // 弹窗遮罩是 z-index 60，浮层必须压在它上面；其余定位（上翻、封高）交给 hook。\n    const pickPanel = picking\n      ? h('div', {\n          className: 'tsd-price-pick-box',\n          style: Object.assign({}, pickStyle, { zIndex: 70 }),\n          onKeyDown: (e) => { if (e.key === 'Escape') { e.stopPropagation(); closePick() } },\n        }, pickerFor(r.key))\n      : null\n    // 手填单价的浮层：三格（输入 / 输出 / 缓存读），单位就是表格的展示币种。\n    const cur = editing ? customOf(r) : null\n    const customPanel = editing\n      ? h('div', {\n          className: 'tsd-price-pick-box tsd-price-custom-box',\n          style: Object.assign({}, customStyle, { zIndex: 70 }),\n          onKeyDown: (e) => { if (e.key === 'Escape') { e.stopPropagation(); setEditFor(null) } },\n        },\n          h('div', { className: 'tsd-price-custom-title' }, t('pricingCustomOption')),\n          ...CUSTOM_FIELDS.map(([field, label]) => h('label', { key: field, className: 'tsd-price-custom-field' },\n            h('span', null, t(label)),\n            h('input', {\n              type: 'number',\n              min: '0',\n              step: '0.001',\n              className: 'tsd-price-custom-input',\n              'data-field': field,\n              value: cur[field],\n              autoFocus: field === 'input',\n              onChange: (e) => setCustomField(r.key, field, e.target.value),\n            }))),\n          h('div', { className: 'tsd-price-custom-hint' }, t('pricingCustomUnit', { unit: priceUnit })),\n          h('button', {\n            type: 'button',\n            className: 'tsd-btn tsd-btn-ghost tsd-btn-xs',\n            onClick: () => setEditFor(null),\n          }, t('done')))\n      : null\n    // 这一行匹配到的参考模型属于哪一类（DeepSeek / Zen / 自定义）。草稿里刚选的\n    // 目标也查得到：候选名单本来就按来源分好了组，不用再问宿主一次。\n    // 「自定义」不仅指草稿：从 `prices` 计价的行也没有参考模型 id（target 为空），\n    // 它的目标格要写「自定义」，不然会显示成待选。\n    const isCustom = Boolean(d && d.custom) || (r.how === 'custom' && !r.target)\n    const src = shown ? (sourceOf(shown) || r.source) : (isCustom ? 'custom' : null)\n    return h('tr', { key: r.key, className: 'tsd-price-row', 'data-state': state, 'data-model': r.key, 'data-dirty': d && d.dirty ? 'true' : undefined },\n      h('td', { className: 'tsd-price-model', title: r.key },\n        h('span', { className: 'tsd-price-model-name' }, shortModelName(r.key)),\n        r.provider ? h('span', { className: 'tsd-price-model-provider' }, r.provider) : null),\n      // 匹配目标格本身就是选择器入口：一颗紧凑按钮，未匹配时虚线 + 提示语。\n      h('td', { className: 'tsd-price-target', ref: picking || editing ? bindPickAnchor : undefined },\n        h('button', {\n          type: 'button',\n          className: 'tsd-price-target-btn',\n          'data-empty': shown || isCustom ? undefined : 'true',\n          'aria-expanded': picking || editing ? 'true' : 'false',\n          'aria-haspopup': 'listbox',\n          title: shown ? shown + (src ? ' · ' + t(SOURCE_LABEL[src] || src) : '') : null,\n          onClick: openPick,\n        },\n          h('span', { className: 'tsd-price-target-id' }, shown || (isCustom ? t('pricingCustomOption') : t('askPick'))),\n          h(SvgIcon, { name: 'chevron', size: 12, className: 'tsd-price-target-chev' })),\n        src\n          ? h('span', { className: 'tsd-price-src', 'data-source': src }, t(SOURCE_LABEL[src] || src))\n          : null,\n        state !== 'none' && !r.rates && !isCustom\n          ? h('span', { className: 'tsd-price-stale' }, t('pricingStale'))\n          : null,\n        pickPanel,\n        customPanel),\n      h('td', null, h('span', { className: 'tsd-price-badge', 'data-state': state, title: r.why || null }, t(MATCH_STATE_LABEL[state]))),\n      h('td', { className: 'tsd-price-rate', title: priceTitle(r) }, priceLine(r)),\n      h('td', { className: 'tsd-price-ops' },\n        canReset\n          ? h('button', {\n              type: 'button',\n              className: 'tsd-price-reset',\n              title: t('pricingClear'),\n              'aria-label': t('pricingClear'),\n              onClick: () => clearRow(r.key),\n            }, h(SvgIcon, { name: 'refresh', size: 12 }))\n          : null))\n  }\n\n  const body = status === 'loading'\n    ? h('div', { className: 'tsd-price-loading' }, t('loading'))\n    : status === 'error'\n      ? h('div', { className: 'tsd-alert-banner', role: 'alert' },\n          h('span', null, t('pricingFailed', { message: String((error && error.message) || error) })),\n          h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: pull }, t('retry')))\n      : h('div', { className: 'tsd-price-body' },\n          h('div', { className: 'tsd-price-meta' },\n            table && table.source\n              ? t('pricingTableMeta', { source: table.source, date: stampText(table.capturedAt) })\n              : null,\n            h('span', { className: 'tsd-price-counts' }, t('pricingCounts', {\n              exact: counts.exact, fuzzy: counts.fuzzy, none: counts.none, custom: counts.custom,\n            }))),\n          // 一张表装两段行：待选的未定价行在前，已按阶梯命中的行在后。\n          // 分成两张表会出现两行表头，看起来像两份数据。\n          !hasMainRows\n            ? h('div', { className: 'tsd-price-empty' }, t('askEmpty'))\n            : h('table', { className: 'tsd-price-table' },\n                h('thead', null, h('tr', null,\n                  h('th', null, t('pricingColModel')),\n                  h('th', null, t('pricingColMatch')),\n                  h('th', null, t('pricingColState')),\n                  h('th', null, t('pricingColPrice', { unit: priceUnit })),\n                  h('th', null, ''))),\n                h('tbody', null,\n                  pendingRows.map((r) => renderRow(r)),\n                  matchedRows.map((r) => renderRow(r)))),\n          h('div', { className: 'tsd-price-history' },\n            h('button', {\n              type: 'button',\n              className: 'tsd-price-history-toggle',\n              'aria-expanded': historyOpen,\n              onClick: () => setHistoryOpen((v) => !v),\n            },\n              h(SvgIcon, { name: 'chevron', size: 12, className: 'tsd-price-history-chev' + (historyOpen ? ' tsd-price-history-chev-open' : '') }),\n              h('span', null, t('pricingHistory', { n: historyRows.length }))),\n            historyOpen\n              ? historyRows.length === 0\n                ? h('div', { className: 'tsd-price-empty' }, t('pricingHistoryEmpty'))\n                : h('div', null,\n                    h('table', { className: 'tsd-price-table tsd-price-table-sub' },\n                      h('thead', null, h('tr', null,\n                        h('th', null, t('pricingColModel')),\n                        h('th', null, t('pricingColMatch')),\n                        h('th', null, t('pricingColState')),\n                        h('th', null, t('pricingColPrice', { unit: priceUnit })),\n                        h('th', null, ''))),\n                      h('tbody', null, historyRows.map((r) => renderRow(r)))))\n              : null))\n\n  return h('div', { className: 'tsd-price-overlay', role: 'presentation', onMouseDown: (e) => { if (e.target === e.currentTarget) onClose() } },\n    h('div', {\n      className: 'tsd-price-dialog',\n      role: 'dialog',\n      'aria-modal': 'true',\n      'aria-label': t('pricingTitle'),\n      onKeyDown,\n    },\n      h('div', { className: 'tsd-price-head' },\n        h('h3', { className: 'tsd-price-title' }, t('pricingTitle')),\n        h('button', {\n          type: 'button',\n          className: 'tsd-price-close',\n          title: t('cancel'),\n          'aria-label': t('cancel'),\n          onClick: onClose,\n        }, h(SvgIcon, { name: 'x', size: 14 }))),\n      h('p', { className: 'tsd-price-desc' }, t('pricingDesc')),\n      body,\n      h('div', { className: 'tsd-price-foot' },\n        h('button', {\n          type: 'button',\n          className: 'tsd-btn tsd-btn-ghost tsd-btn-icon-label',\n          onClick: pull,\n          disabled: status === 'loading' || saving,\n        },\n          h(SvgIcon, { name: 'contextInjection', size: 14 }),\n          h('span', null, t('pricingPull'))),\n        h('span', { className: 'tsd-price-hint' }, dirtyKeys.length > 0 ? t('pricingApplyHint') : ''),\n        h('button', { type: 'button', className: 'tsd-btn tsd-btn-ghost', onClick: onClose, disabled: saving }, t('cancel')),\n        h('button', {\n          type: 'button',\n          className: 'tsd-btn tsd-btn-primary',\n          onClick: submit,\n          disabled: saving,\n        }, saving ? t('loading') : t('pricingSave')))))\n}\n\n/* ---------------------------------------------------------------------------\n * 每日用量柱状图（手写 div 堆叠柱：下段输入蓝 / 上段输出绿）\n * ------------------------------------------------------------------------- */\n/**\n * One hover-tip content block, shared by the trend chart (bar + line) and the\n * yearly heatmap: date, input, output, total, reference cost.\n *\n * Cost comes from the host bucket (`cost`, already converted to the display\n * currency), so all three tips show the same number as the summary card and the\n * model table. A zero is printed as ¥0.00 — \"0\" is a price, \"unpriced\" is a\n * different verdict, and it is the host's to give.\n */\nfunction TipRows(props) {\n  const { row, t, currency, withSplit } = props\n  const inT = row.inputTokens || 0\n  const outT = row.outputTokens || 0\n  const totT = row.totalTokens || 0\n  return [\n    withSplit\n      ? h('div', { key: 'in', 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(inT)))\n      : h('div', { key: 'in', 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(totT))),\n    withSplit\n      ? h('div', { key: 'out', 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(outT)))\n      : null,\n    // 成本与调用次数没有对应图例，所以只留 10px 的空白占位（.tsd-tooltip-dot 本身无底色），\n    // 不画色块：色块的含义是「这一行对应图例里的哪个颜色」。\n    h('div', { key: 'cost', className: 'tsd-tooltip-row' },\n      h('span', { className: 'tsd-tooltip-dot', 'aria-hidden': 'true' }),\n      h('span', null, t('cost')),\n      h('span', { className: 'tsd-tooltip-val' }, formatCost(row.cost || 0, currency))),\n    row.calls > 0\n      ? h('div', { key: 'calls', className: 'tsd-tooltip-row' },\n          h('span', { className: 'tsd-tooltip-dot', 'aria-hidden': 'true' }),\n          h('span', null, t('calls')),\n          h('span', { className: 'tsd-tooltip-val' }, formatInt(row.calls)))\n      : null,\n    withSplit\n      ? h('div', { key: 'total', className: 'tsd-tooltip-total' },\n          h('span', null, t('tooltipTotal')),\n          h('span', null, formatInt(totT)))\n      : null,\n  ]\n}\n\nfunction DailyChart(props) {\n  const { daily, gran, stepDays, granLabel, currency } = 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(TipRows, { row: tip.row, t, currency, withSplit: true }))\n    : null\n\n  const body = view === 'line'\n    ? h(LineChart, { rows, gran, stepDays, showTip, tip, setTip, chartRef, currency })\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), cost: formatCost(row.cost || 0, currency) }),\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, currency } = 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(TipRows, { row: tip.row, t, currency, withSplit: true }))\n      : null)\n}\n\n/* ---------------------------------------------------------------------------\n * 年度用量热力图（GitHub 风格）\n * ------------------------------------------------------------------------- */\nfunction HeatmapCard(props) {\n  const { days, currency } = 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(TipRows, { row: htip.cell, t, currency, withSplit: false }))\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) }) : '', cost: formatCost(c.cost || 0, currency) }),\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    // The verdict comes from the host, which knows whether a price was found.\n    // This used to be re-derived here as `tokens > 0 && !(cost > 0)`, which\n    // labels every 0-cost row 未定价 — including a model the user explicitly\n    // priced at 0 (a real price, cost 0, so ¥0.00 is the honest answer).\n    unpriced: r.unpriced === true,\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(props) {\n  const t = useT()\n  // 统计中（computing）时头部副标题已经在播报进度，这里就不再做第二个 live 区域，\n  // 否则屏幕阅读器会把「正在加载」和「正在统计 12/258」各念一遍。\n  const announce = !props || props.announce !== false\n  return h('div', { className: 'tsd-loading', role: 'status', 'aria-live': announce ? 'polite' : 'off' },\n    // 骨架屏对眼睛是\"正在来\"，对屏幕阅读器什么都不是：给它一句可读的状态。\n    announce ? h('span', { className: 'tsd-visually-hidden' }, t('loading')) : null,\n    h('div', { className: 'tsd-cards' },\n      // 一张卡一个占位块，张数取自 SUMMARY_CARD_SLOTS —— 与真实卡片同一份顺序表，\n      // 所以补卡片时骨架自动跟上（这里曾经写死 5 个，真实是 6 个）。\n      SUMMARY_CARD_SLOTS.map((slot) =>\n        h('div', { key: slot, 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  // 定价匹配弹窗：只在这里开着，关掉即卸载（它的内部状态随之丢弃，\n  // 所以「不确定就不生效」不需要额外清理逻辑）。\n  const [pricingOpen, setPricingOpen] = React.useState(false)\n  // P1-6 backfill 轮询状态：queryKey 变化时重置，仅对同一查询串轮询\n  const queryKeyRef = React.useRef(null)\n  const backfillSeenRef = React.useRef(false)\n  const finalRefreshRef = React.useRef(false)\n  // 轮询节奏：统计窗口短则快问、长则慢问。固定 3 s 时，暖缓存 ~0.8 s 就跑完，\n  // 客户端要等 3 s 才更新 —— 进度条先躺着再跳一格，比没有更糟。\n  const pollStepRef = React.useRef(0)\n  const POLL_DELAYS = [600, 1500, 3000]\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      pollStepRef.current = 0\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          // 先快后慢：600 ms 起步能跟上 0.8 s 的暖缓存窗口，长任务再退到 3 s，\n          // 不至于把宿主问成压力测试。\n          const delay = POLL_DELAYS[Math.min(pollStepRef.current, POLL_DELAYS.length - 1)]\n          pollStepRef.current += 1\n          backfillTimer = setTimeout(() => {\n            if (current) setRetry((v) => v + 1)\n          }, delay)\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  // \"统计没算完\"：宿主还在回填历史（backfill.status === 'running'）。\n  // 它比 busy 长得多（全量 258 个会话要几秒），所以进度条与文案都以它为准；\n  // 请求在飞（busy）只是刷新，不该被当成\"在算\"。\n  const backfill = (data && data.backfill) || null\n  const computing = Boolean(backfill && backfill.status === 'running')\n  const computeTotal = (backfill && backfill.total) || 0\n  const computeDone = (backfill && backfill.done) || 0\n  const computePct = computing && computeTotal > 0\n    ? Math.min(100, Math.round((computeDone / computeTotal) * 100))\n    : null\n  const showProgress = computing || (busy && ready && !isError)\n\n  return h(T.Provider, { value: t },\n    h('div', { className: 'tsd-section', 'aria-busy': busy || computing || undefined },\n    // 首屏走后骨架屏（见 LoadingState）；这里管\"有数据但没算完\"与\"正在刷新\"：\n    // 一条 2px 的细进度条，绝对定位，不推动版面也不碰任何数字。\n    // 算得完的时候它是确定进度（宽度 = done/total），否则是不确定扫动。\n    showProgress\n      ? h('div', {\n          className: 'tsd-progress',\n          'aria-hidden': 'true',\n          'data-determinate': computePct === null ? undefined : 'true',\n          style: computePct === null ? undefined : { '--tsd-progress': computePct + '%' },\n        })\n      : null,\n    h(StatsHeader, {\n      busy,\n      computing,\n      computeDone,\n      computeTotal,\n      onRefresh: reload,\n    }),\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    // **从 DSH 启动到统计算完，整段都是加载态。**\n    // 覆盖两种\"还没东西可看\"：\n    //  ① 首屏请求还没回来（!ready）；\n    //  ② 宿主还在回填历史（computing）—— 哪怕是第二次进来、手里已经有半份数据。\n    // 半份数字比骨架更误导：它看起来像\"你只有这么多用量\"，而且会一格一格往上爬。\n    // 这也正是「数字一点点往上爬」那个抱怨的来源，所以宁可等，也不要给残缺的答案。\n    (!ready || computing) && !isError\n      ? h(LoadingState, { announce: !computing })\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    // 空态只在\"确实算完了还没有记录\"时出现。统计中不落到空态。\n    ready && !isError && isEmpty && !computing\n      ? h(EmptyState, { filtered: models.length > 0, onReset: resetFilters })\n      : null,\n    // 数据区同理：算完之前不渲染，免得残缺数字先出现再跳变。\n    ready && !isError && !isEmpty && !computing\n      ? h('div', { className: 'tsd-content' },\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            pricing: data.pricing,\n            onOpenPricing: () => setPricingOpen(true),\n          }),\n          h(DailyChart, {\n            daily: data.daily,\n            gran: effGran,\n            stepDays,\n            granLabel,\n            currency: currencySymbol,\n          }),\n          h(HeatmapCard, { days: data.heatmap || [], currency: currencySymbol }),\n          h(ModelTable, { rows: data.byModel, currency: currencySymbol }))\n      : null,\n    pricingOpen\n      ? h(PricingDialog, {\n          currency: { code: displayCurrency, symbol: currencySymbol },\n          onClose: () => setPricingOpen(false),\n          // 确定后重查一次：匹配改了，卡片上的数字必须跟着变，否则用户会以为没保存成功。\n          onApplied: reload,\n        })\n      : null))\n}\n\n/* ---------------------------------------------------------------------------\n * 设置页导航图标\n *\n * 原生确实没有这个插口 —— 取证过的，不是\"我觉得\"：\n *   · 官方设置页把 `settings.section` 的条目投影成 `{id, order, label}` 三字段，\n *     没有 icon（`@deepseek-ai/dsh-client-ui-settings-general` 的 nav rows\n *     getSnapshot：`ctx.slots.entries(\"settings.section\").map(e => ({id, order,\n *     label: resolveSlotLabel(e.options.label)}))`）；\n *   · 图标由该包自己的 `navIcon(id)` 按 id 白名单选，未列出的 id 回落到设置齿轮\n *     （同包 `function navIcon(id)`，其注释原文 \"unknown ids fall back to the\n *     settings gear\"）。\n * 所以第三方只能给自己的那一行打属性标记、用 CSS mask 换字形：不替换节点、不碰\n * React 管的 svg（替换会让 React 卸载时抛 NotFoundError），只加属性、只用 ::before\n * 画字形。官方一旦给 `settings.section` 加上 icon 字段，这个模块应整体删除 ——\n * 那时它是可引用的 L0，不该再留 L2 补缺。\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    logWarn('[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    logWarn('[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 * 输入区成本 pill（composer dock）\n *\n * DSH 0.2.1-rc.1 把输入区统计拆成 `activity` / `usage` 两个 composer dock 条目，\n * 宿主自己的 `usage` pill 显示 token 数（读官方 `tokenUsage` 投影）。官方投影只有\n * 会话内合计、**不带模型归因**，而成本必须按模型单价算（本插件自 v0.3 起坚持\n * 不混价），所以这里不走投影，改走本插件自己的 `query`：记录里带 provider/model，\n * 宿主侧按模型精确计价。\n *\n * 口径取「今日」而不是「本会话」：dock 条目拿不到会话标识（宿主渲染这个 slot 时\n * 是 `renderSlot(\"conversation.composer.dock\", {})`，不传 props），而今日成本与\n * 宿主的 token pill 正好互补。\n * ------------------------------------------------------------------------- */\nconst DOCK_REFRESH_MS = 30000\n/** 回填（backfill）进行中的快重试间隔，与设置页一致。 */\nconst DOCK_BACKFILL_RETRY_MS = 3000\n\nfunction CostPill(props) {\n  const tr = props && typeof props.t === 'function' ? props.t : fallbackT\n  const [state, setState] = React.useState({ status: 'loading' })\n  React.useEffect(() => {\n    let alive = true\n    let timer = null\n    const schedule = (ms) => {\n      if (timer !== null) clearTimeout(timer)\n      timer = setTimeout(load, ms)\n    }\n    const load = () => {\n      if (!alive) return\n      const now = new Date()\n      hostCall('usage/query', {\n        from: startOfDay(now).getTime(),\n        to: now.getTime(),\n        // 「今日」是有限区间，但不需零填充：空桶对成本没意义。\n        fill: false,\n        granularity: 'day',\n        currency: readStoredCurrency(),\n      })\n        .then((r) => {\n          if (!alive) return\n          const total = (r && r.total) || null\n          setState({\n            status: 'ready',\n            calls: total ? total.calls : 0,\n            tokens: total ? total.totalTokens : 0,\n            cost: total ? total.cost : 0,\n            symbol: (r && r.currency && r.currency.symbol)\n              || CURRENCY_SYMBOLS[readStoredCurrency()]\n              || '¥',\n          })\n          const backfilling = Boolean(r && r.backfill && r.backfill.status === 'running')\n          schedule(backfilling ? DOCK_BACKFILL_RETRY_MS : DOCK_REFRESH_MS)\n        })\n        .catch(() => {\n          // 路由不可用 / 宿主未就绪：不猜数字，也不报错弹窗（dock 常驻，不能刷屏）。\n          if (alive) {\n            setState({ status: 'error' })\n            schedule(DOCK_REFRESH_MS)\n          }\n        })\n    }\n    load()\n    const onVisible = () => {\n      if (typeof document !== 'undefined' && document.visibilityState === 'visible') load()\n    }\n    if (typeof document !== 'undefined') document.addEventListener('visibilitychange', onVisible)\n    return () => {\n      alive = false\n      if (timer !== null) clearTimeout(timer)\n      if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', onVisible)\n    }\n  }, [])\n  // 今日无调用（或还没查到）就不占位：dock 是常驻区，空 pill 比没有更吵。\n  if (state.status !== 'ready' || !state.calls) return null\n  const priced = state.cost > 0\n  const value = priced ? state.symbol + costDigits(state.cost) : tr('dockUnpriced')\n  const hint = tr('dockHint', {\n    cost: value,\n    calls: formatInt(state.calls),\n    tokens: formatInt(state.tokens),\n  })\n  return h('span', {\n    className: 'tsd-dock',\n    title: hint,\n    'aria-label': hint,\n    'data-usage-cost': true,\n  },\n    h('span', { className: 'tsd-dock-label' }, tr('today')),\n    h('span', { className: 'tsd-dock-value' }, value))\n}\n\n/* ---------------------------------------------------------------------------\n * 注册：settings.section 页面\n * ------------------------------------------------------------------------- */\nfunction apply(ctx) {\n  usageCtx = ctx\n  // Mount the native Remote face once the page is up; the Fetch routes carry\n  // every call until it lands.\n  mountRemoteChannel(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    logWarn('[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  // 输入区成本 pill。0.2.1 的 composer dock 是 list slot，宿主自己占了 activity(0)\n  // 与 usage(1)，插件排在它们之后；0.2.0 没有这个 slot，注入失败不能拖垮设置页。\n  try {\n    slots.inject('conversation.composer.dock', () => slots.register(\n      { name: 'conversation.composer.dock', id: 'usage-cost', order: 2, locale: NS },\n      (props) => h(CostPill, props),\n    ))\n  } catch (e) {\n    console.warn('[usage] composer dock slot unavailable', e)\n  }\n}\n\nreturn { inject: ['locale', 'slots'], apply }\n"],"names":[],"mappings":""}