@mzzsfy/dsh-usage-dash 0.10.3 → 0.10.4

package/README.md

@@ -9,23 +9,23 @@
 - 三粒度视图,全部支持自定义时间范围:天(7/30/90 天/自定义日期段)、小时(24 小时/3 天/7 天/15 天/自定义时刻段)、分钟(3 小时/24 小时/3 天/7 天/自定义时刻段,10 分钟桶粒度),预设挡为滚动窗口;自定义时刻段为起止 datetime 双输入,两端归一到桶边界(小时取所在整点、分钟起点对齐 10 分钟且终点保留原分钟,均闭区间),跨度上限与数据保留期一致(小时 15 天、分钟 7 天,超限自动钳起点),首次切到自定义挡预填最近 24 小时,时/分两视图共享同一对自定义输入;已知限制:自定义输入残缺(任一端为空)时面板不发请求且图表静默空白,与天视图行为一致,交互反馈留待后续增强
 - 汇总卡六张:Tokens 用量(服务商总口径)、会话数量、请求数量、最常用模型、平均缓存命中率、活跃天数(恒按天口径,不随视图切换);配置定价规则后 Tokens 卡头部行右侧显示估算费用
 - 活动热力图:GitHub 风格周列×星期行,26 周窗口,五档色阶,悬停明细(配置定价规则后附「费用 ≈」估算行,受「费用显示」开关;费用数据依赖小时桶保留期,仅最近 15 天的天显示,更早的天无该行);仅按天视图展示
-- 缓存命中率曲线:日粒度命中率 + 右侧副轴,并叠加平均生成速度曲线与首 token 延迟曲线(各自单独颜色,读数走悬停;仅含配对数据的槽参与,整图无数据不绘制),悬停显示当前时段命中率、平均生成速度、首 token 延迟与 token 明细(配置定价规则后附当前时段估算费用行,受「费用显示」开关;三粒度趋势图通用)
+- 缓存命中率曲线:日粒度命中率 + 右侧副轴,并叠加平均生成速度曲线与首 token 延迟曲线(各自单独颜色,读数走悬停;仅含配对数据的槽参与,整图无数据不绘制),悬停按已启用曲线显示当前时段命中率、平均生成速度、首 token 延迟,模型明细随 Token/金额视图与图例筛选联动(配置定价规则后 Token 视图可附所选模型估算费用行,受「费用显示」开关;三粒度趋势图通用)
 - 模型 donut 与列表:按 token 排序的模型占比环形图(中心为总量,模型不超过 5 个时全展示,超过时折叠为前 4 +「其他」,「其他」可展开),每行名称两行展示(厂商/模型名),右侧三排:第一排 token 数·占比,第二排输入输出占比构成(缓存/输入/输出 三段各占该模型 token 总量,缓存=读+写,三段合计 100%,无四桶数据不显示),第三排估算费用·TTFT·生成速度(费用需配置定价规则,TTFT/速度无配对数据不显示),悬停明细含输入/缓存读/缓存写/输出四桶 token 拆分并联动
-- 三粒度堆叠柱状趋势图(数据量大时裁最旧并提示);节头「金额」开关把柱状图从 token 消耗切到金额消耗——柱按模型堆叠估算费用,标题与左轴同步切金额读数(悬停明细保持 token 口径与估算费用行不变,命中率/速度/首 token 延迟曲线不受影响),三粒度通用;开关仅在存在正计价数据时显示(未配置规则或全量未计价时不渲染,避免全零金额柱误导);图例可点击切换显隐:点击单选(仅显示该项,左轴刻度按可见项归一)/再点恢复全部,Ctrl+点击多选,隐藏最后一项无效;悬停明细按当前时段数据展示,零用量模型不显示,全零时段不显示悬浮框
+- 三粒度堆叠柱状趋势图(数据量大时裁最旧并提示);节头「金额」开关把柱状图从 token 消耗切到金额消耗——柱按模型堆叠估算费用,标题、左轴和悬停的总计/逐模型/「其他」明细同步切金额读数(带货币符号和「≈」),三粒度通用;开关仅在存在正计价数据时显示(未配置规则或全量未计价时不渲染,避免全零金额柱误导)。图例点击单选、再点恢复默认显示(全部模型及有数据的速度线),Ctrl+点击多选,隐藏最后一项无效;换窗口时只保留仍可用的所选项,全部失效则恢复默认显示;柱高、提示合计、辅助费用和均价均按可见模型计算,「其他」子项不重复计入合计,金额模式「其他」明细按费用降序。命中率/速度/首 token 延迟曲线保持整个时段的统计口径,提示中标注「时段整体指标」,仅显示已启用且当前桶有数据的曲线读数(速度或延迟为零仍属有效值,独立 timing 桶没有 Token 也可展示);仅选曲线时不再显示模型合计与费用。零用量模型不显示,有用量的零费用模型保留零费用读数,无可见模型用量且没有启用曲线的有效读数时不显示提示;切换时间窗口时提示绑定时间桶,不复用旧位置。金额模式主费用读数不受「费用显示」开关控制;有可见模型用量且所选费用为正时显示均价,该均价亦不受此开关控制。Token 模式辅助费用与均价仍受「费用显示」开关控制
 - 回扫状态行默认隐藏:首次启用自动回扫历史会话,运行中显示进度(常显);右上角为折叠箭头与刷新图标,折叠层内展开扫描异常日志块(逐条:时间/类型/明细,计数即明细条数,上限 200 条超限丢最旧,重建时清空)与「重建」入口(二次确认 3 秒后清库重扫),采集错误常显;折叠且有待读信息(异常日志或写入失败)时箭头带红点提醒,展开后消失;工具栏分主区与右侧操作区,窄宽度时挡位组在主区内换行
-- 会话底栏追加(append 模式):本插件在官方 activity/usage 胶囊之后仅显示估算费用,不另建明细按钮或浮层。精确缓存命中率开关(`cachePrecision`)原位修改官方 usage 胶囊的命中率文字、按钮 `aria-label` 与官方弹窗原命中率 `dd`,统一显示两位小数;关闭开关或卸载增强时还原,保留官方节点与交互。「会话 Token 明细」开关(`tokenDetail`)只在已打开的官方 `[data-session-stats-usage]` 用量弹窗 `dl` 末尾追加「输入合计（含缓存）」(未缓存输入+缓存读+缓存写),仅当 `cacheWriteTokens > 0` 再追加「未命中合计（含缓存写入）」(未缓存输入+缓存写入)。合计使用完整千分位计数,官方已有的总量、缓存读写、输出与命中率不重复追加;无输入用量时不追加零值合计。偏好卡三个开关仍默认全开,已有偏好继续生效;「费用显示」控制底栏费用、趋势 tooltip 费用行与回合费用芯片。官方弹窗关闭时不挂载补充行;空用量无插件可见条目,精度或明细单独开启均不产生底栏入口。官方未公开用量弹窗扩展 slot,上述增强依赖宿主 DOM 语义标记,标记改变或无法唯一确认弹窗归属时停用相应增强,底栏费用仍独立显示。
+- 会话底栏追加(append 模式):本插件在官方 activity/usage 胶囊之后仅显示估算费用,不另建明细按钮或浮层。精确缓存命中率开关(`cachePrecision`)原位修改官方 usage 胶囊的命中率文字、按钮 `aria-label` 与官方弹窗原命中率 `dd`,统一显示两位小数;关闭开关或卸载增强时还原,保留官方节点与交互。「会话 Token 明细」开关(`tokenDetail`)只在已打开的官方 `[data-session-stats-usage]` 用量弹窗 `dl` 末尾追加「输入合计（含缓存）」(未缓存输入+缓存读+缓存写),仅当 `cacheWriteTokens > 0` 再追加「未命中合计（含缓存写入）」(未缓存输入+缓存写入)。合计使用完整千分位计数,官方已有的总量、缓存读写、输出与命中率不重复追加;无输入用量时不追加零值合计。偏好卡三个开关仍默认全开,已有偏好继续生效;「费用显示」控制底栏费用、Token 趋势 tooltip 的辅助费用行与回合费用芯片;金额趋势主读数不受此开关控制。官方弹窗关闭时不挂载补充行;空用量无插件可见条目,精度或明细单独开启均不产生底栏入口。官方未公开用量弹窗扩展 slot,上述增强依赖宿主 DOM 语义标记,标记改变或无法唯一确认弹窗归属时停用相应增强,底栏费用仍独立显示。
 - 回合费用芯片:经官方 `conversation.chat.assistant-actions` 槽注入动作行(复制与分支图标之间,官方赞/踩与上下文跳转同排),每轮对话结束后显示该轮估算费用(悬停 title 带 token 摘要与估算口径;显隐节奏随官方动作行——最新一轮常显,历史轮悬停显现;受「费用显示」开关;官方用量芯片弹窗已有 token 明细,芯片只承载费用)。旧宿主无该插槽时告警禁用
 - 定价规则编辑器:设置面板内按**模型分组**编辑,组头 = 模型键(整组一次改名,改后即时重新聚合)+ 删除整组;组内 = **默认价**槽(价格四桶,不设条件——附加规则全不命中时兜底,禁排序/删除)+ **附加计费规则**列表(四桶单价 + 条件组合,「+添加条件」追加条件行,行内下拉切换类型,规则带 ↑/↓ 调序与删除),「添加额外计费规则」追加一条(默认带全天时段条件);货币为全局切换(「定价规则」标题右侧,仅 ¥/$ 两档,整表统一),显式「保存」整表写入
 - 双语:跟随宿主语言设置(设置 → 通用 → 语言)即时切换 en/zh
-- 数据 API 守卫:POST 同源校验 + JSON content-type(与 dsh-usage-panel 同构),局域网远程访问可用
+- 数据 API 守卫:POST 同源校验 + JSON content-type,与 dsh-usage-panel 同构(pricing 端点例外:GET/POST 放行且不要求 content-type),局域网远程访问可用
 
 口径:token 总量 = 未缓存输入 + 输出 + 缓存读 + 缓存写;命中率 = 缓存读 / (缓存读 + 未缓存输入 + 缓存写);桶按 host 本地时区。聚合响应 `models` 数组每模型带 `inputTokens`/`outputTokens`/`cacheReadTokens`/`cacheWriteTokens` 四桶拆分(与定价四桶同口径),模型列表据此展示输入输出对比。平均生成速度 = decode 配对分子 ÷ 解码时长,两者均取官方吞吐口径(与官方 session-stats 投影同构):解码时长为该步首 token 时刻(首个产出 token 的 attempt 流,回落 message 自带流)到 usage 汇报时刻,不含首 token 前的排队与提示处理等待;首 token 延迟(TTFT)= 首 token 时刻 − `step/start`(起点不随 `llm/retry-started` 重置,即含失败尝试时间)。首 token 时刻在 chunk token 样本上不可得,由后续 usage 报告(message 为主)补发零桶 timing 增量行承载(decodeTokens 与时长同源配对,不重复计 token);存量旧行(时长为旧全时长口径)速度分子回落输出 token,聚合随新数据自然收敛,重建(重扫)可全量按新口径重建。保留策略:天桶永久,小时桶固定 15 天,分钟桶默认 7 天且上限 7 天(设置项 `minuteRetentionDays`,0 = 禁用分钟桶)。
 
-写入模型:样本先同步合并进内存 pending,按 2 秒周期批量落盘(单布局存储域每次持久化写都全量重发布 unit 文档,合并把每样本 3 次写降为每脏行 1 次,回扫万级样本写放大降约 99%);查询前自动 flush 保证读己之写;flush 失败的行留 pending 下轮重试并经异常日志可观测,崩溃丢失窗口 = flush 周期,统计可由会话重扫重建。
+写入模型:样本先同步合并进内存 pending,按 2 秒周期批量落盘(单布局存储域每次持久化写都全量重发布 unit 文档,合并把每样本 3 次写降为每脏行 1 次,回扫万级样本写放大降约 99%);查询前自动 flush 保证读己之写;flush 失败的行留 pending 下轮重试并经异常日志可观测,崩溃丢失窗口 = flush 周期,统计可由会话重扫重建。同一存储服务复用现有健康实例;主域已占用时新实例报告降级,不会关闭占用者或中断其待写数据。备份域占用仅停用备份,主采集继续。更换全局缓存结构后须冷重启宿主,不热迁移仍在使用的存储域。
 
 ## 定价与费用估算
 
-规则存于设置存储域,经 `GET/POST /api/usage-dash/pricing` 读写(响应含单调 revision);设置面板编辑器为常规入口。
+规则存于设置存储域,经 `GET/POST /api/usage-dash/pricing` 读写(响应含单调 revision);设置面板编辑器为常规入口。单页内价格请求合并为一个在途请求,缓存有效期内复用;保存成功会同步更新已挂载底栏/费用芯片,并重取面板日范围、热力图及当前时/分数据。迟到的低 revision 不覆盖新价格,其他编辑器未保存草稿保持独立;价格不存本机持久缓存。
 
 规则形态:`{ model, currency, price: { input, output, cacheRead, cacheWrite }, conditions }`,单价单位固定「每百万 token」。货币为编辑器级全局设置:「定价规则」标题右侧切换,仅 ¥/$ 两档(无「空」档),打开编辑器即按首个非空货币归一显示(无非空回落 ¥),切换或保存后整表统一;wire 形态不变(仍为逐规则字段),存量空货币规则经编辑器保存后归一。费用显示为全局价格定位:汇总卡/趋势悬浮/模型列表/底栏费用项/回合费用芯片的货币符号统一取规则表首个非空货币(数值仍按命中规则单价计算),切换并保存后全部显示点随之变更。
 
@@ -93,4 +93,4 @@ dsh --profile <profile> --no-open --port 9191
 
 ## dsh 版本兼容
 
-按仓库动态窗口验证(scripts/compat/window.mjs),不预置任何固定版本槽:主测 = 渠道 dist-tag 最新 rc,完全适配口径;基线 = npm latest,不崩溃底线口径;主测与基线同版时收敛单槽。兼容面以窗口实测为准,不逐版本承诺。逐轮实测结论见 `docs/兼容性测试/逐包测试进度.md` 与本包 `兼容性测试.md`。
+按仓库动态窗口验证(scripts/compat/window.mjs),不预置任何固定版本槽:主测 = 渠道 dist-tag 最新 rc,完全适配口径;基线 = npm latest,不崩溃底线口径;主测与基线同版时收敛单槽。兼容面以窗口实测为准,不逐版本承诺。逐轮实测结论见 `docs/兼容性测试/逐包测试进度.md`(本地维护,不入库)与本包 `兼容性测试.md`。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-usage-dash",
   "description": "用量统计面板:天/小时/分钟三粒度 token 与请求统计,26 周活跃热力图、缓存命中率/生成速度/首 token 延迟曲线、模型占比与四桶明细,会话底栏官方数据后追加增强项与官方动作行回合费用芯片,多条件分时段定价规则与费用估算,en/zh 双语;复刻自 github.com/HaoyueQin/dsh-usage-statistics-panel,感谢原作者 HaoyueQin",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/client.js

@@ -214,6 +214,10 @@ const MESSAGES_ZH = {
   modelOutput: '输出',
   other: '其他',
   total: '总用量',
+  selectedTotal: '所选用量',
+  totalCost: '估算费用',
+  selectedCost: '所选估算费用',
+  slotMetrics: '时段整体指标',
   percent: '占比',
   asOf: '统计截至',
   empty: '当前时间范围内暂无用量数据。Token 用量从本面板启用后开始累计,并会一次性回扫已有的历史会话。',
@@ -357,6 +361,10 @@ const MESSAGES_EN = {
   modelOutput: 'Output',
   other: 'Other',
   total: 'Total',
+  selectedTotal: 'Selected usage',
+  totalCost: 'Estimated cost',
+  selectedCost: 'Selected estimated cost',
+  slotMetrics: 'Overall interval metrics',
   percent: 'Share',
   asOf: 'Stats as of',
   empty: 'No usage data in this range yet. Token usage accumulates from when this panel is enabled, and existing sessions are scanned once.',
@@ -927,6 +935,13 @@ const tipModelEntries = (hoverSlot, visibleSet) => {
   return { main, other }
 }
 
+// 悬浮合计与柱形共用可见模型集合,其他子项仅展开、不重复求和。
+const visibleTipSlot = (slot, visibleModels) => slot ? {
+  ...slot,
+  total: visibleModels.reduce((sum, model) => sum + (slot.byModel[model] ?? 0), 0),
+  cost: slot.cost === undefined ? undefined : visibleModels.reduce((sum, model) => sum + (slot.byCostModel[model] ?? 0), 0),
+} : null
+
 // 趋势 tooltip 槽级均价:槽费用折每百万 token 单价;无槽或无有效费用(含零值)为 null
 const tipAvgPriceText = (hoverSlot, currency) => (
   hoverSlot ? avgPriceText(hoverSlot.cost, hoverSlot.total, currency) || null : null
@@ -1785,8 +1800,14 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
     const PRICING_CACHE_TTL_MS = 5 * 60 * 1000
     const PRICING_SAVED_NOTICE_MS = 3 * 1000
     let cached = null
-    const applyPricingValue = (value) => {
+    let pricingFlight = null
+    const pricingListeners = new Set()
+    const validPricing = value => value && Number.isFinite(value.revision) && Array.isArray(value.rules)
+    const applyPricingValue = (value, mutation = false) => {
+      if (!validPricing(value) || (cached && value.revision < cached.revision)) return cached
+      const refresh = mutation || (cached !== null && value.revision !== cached.revision)
       cached = { revision: value.revision, rules: value.rules, fetchedAt: Date.now() }
+      for (const listener of pricingListeners) listener(cached, refresh)
       return cached
     }
 
@@ -1809,10 +1830,29 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
     // value 缺形状按失败处理:回退旧值,无旧值为 null(费用显示占位)
     const fetchPricing = async (force = false) => {
       if (!force && cached && Date.now() - cached.fetchedAt < PRICING_CACHE_TTL_MS) return cached
-      const result = await requestGet(ENDPOINTS.pricing)
-      const value = result.ok ? result.value : null
-      if (value && Number.isFinite(value.revision) && Array.isArray(value.rules)) return applyPricingValue(value)
-      return cached
+      if (!pricingFlight) {
+        pricingFlight = (async () => {
+          const result = await requestGet(ENDPOINTS.pricing)
+          return validPricing(result.ok ? result.value : null) ? applyPricingValue(result.value) : cached
+        })().finally(() => { pricingFlight = null })
+      }
+      return pricingFlight
+    }
+
+    function usePricing() {
+      const [value, setValue] = useState(cached)
+      const [tick, setTick] = useState(0)
+      useEffect(() => {
+        const listener = (next, refresh) => {
+          setValue(next)
+          if (refresh) setTick(previous => previous + 1)
+        }
+        pricingListeners.add(listener)
+        if (cached) listener(cached, false)
+        void fetchPricing()
+        return () => pricingListeners.delete(listener)
+      }, [])
+      return { rules: value?.rules ?? null, tick }
     }
 
     // 交互与尺寸常量
@@ -1921,11 +1961,11 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
     }
 
     const STYLE_CSS = `
-/* 图表区分色:brand 派生为主,其余为规范允许的区分色 token(集中声明,S≥70%);
-   亮暗差异由 color-mix 百分比随宿主主题的 bg-base 派生自动适配,不再手动切主题 */
+/* 图表区分色:主色与热力图梯度挂业务蓝派生(brand-primary 在宿主新版主题为单色黑白,不可作数据色);
+   speed/ttft 用 success/warn 语义槽,亮暗随宿主别名自动适配 */
 .ud-panel{display:flex;flex-direction:column;gap:12px;font-size:13px;color:var(--dsw-alias-label-primary);
---ud-chart-1:var(--dsw-alias-brand-primary);--ud-chart-2:var(--dsw-alias-state-success-primary);--ud-chart-3:var(--dsw-alias-state-warn-primary);--ud-chart-4:#975bf1;--ud-chart-5:#d34591;--ud-chart-other:var(--dsw-alias-label-tertiary);
---ud-heat-0:color-mix(in srgb, var(--dsw-alias-label-tertiary) 12%, transparent);--ud-heat-1:color-mix(in srgb, var(--dsw-alias-brand-primary) 18%, transparent);--ud-heat-2:color-mix(in srgb, var(--dsw-alias-brand-primary) 36%, transparent);--ud-heat-3:color-mix(in srgb, var(--dsw-alias-brand-primary) 54%, transparent);--ud-heat-4:color-mix(in srgb, var(--dsw-alias-brand-primary) 74%, transparent);--ud-heat-5:var(--dsw-alias-brand-primary);--ud-trend-line:var(--dsw-alias-brand-primary);--ud-trend-speed:var(--dsw-alias-state-success-primary);--ud-trend-ttft:var(--dsw-alias-state-warn-primary)}
+--ud-chart-1:var(--dsw-alias-state-business-primary);--ud-chart-2:var(--dsw-alias-state-success-primary);--ud-chart-3:var(--dsw-alias-state-warn-primary);--ud-chart-4:#975bf1;--ud-chart-5:#d34591;--ud-chart-other:var(--dsw-alias-label-tertiary);
+--ud-heat-0:color-mix(in srgb, var(--dsw-alias-label-tertiary) 12%, transparent);--ud-heat-1:color-mix(in srgb, var(--dsw-alias-state-business-primary) 18%, transparent);--ud-heat-2:color-mix(in srgb, var(--dsw-alias-state-business-primary) 36%, transparent);--ud-heat-3:color-mix(in srgb, var(--dsw-alias-state-business-primary) 54%, transparent);--ud-heat-4:color-mix(in srgb, var(--dsw-alias-state-business-primary) 74%, transparent);--ud-heat-5:var(--dsw-alias-state-business-primary);--ud-trend-line:var(--dsw-alias-state-business-primary);--ud-trend-speed:var(--dsw-alias-state-success-primary);--ud-trend-ttft:var(--dsw-alias-state-warn-primary)}
 .ud-toolbar{display:flex;align-items:flex-start;gap:8px}
 .ud-toolbar-main{display:flex;align-items:center;gap:8px;flex-wrap:wrap;flex:1 1 auto;min-width:0}
 .ud-group{display:flex;align-items:center;gap:2px;padding:3px;border:1px solid var(--dsw-alias-border-l2);border-radius:9px;background:var(--dsw-alias-bg-layer-1)}
@@ -2222,7 +2262,16 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
       }, [])
       const hasSpeed = slots.some((slot) => slot.speed !== undefined)
       const hasTtft = slots.some((slot) => slot.ttft !== undefined)
-      const visibleSet = visibleKeys ?? trendDefaultVisibleKeys(modelOrder, hasSpeed)
+      const availableKeys = new Set([
+        ...modelOrder, LEGEND_KEY_RATE,
+        ...(hasSpeed ? [LEGEND_KEY_SPEED] : []),
+        ...(hasTtft ? [LEGEND_KEY_TTFT] : []),
+      ])
+      const selectedKeys = visibleKeys && new Set([...visibleKeys].filter((key) => availableKeys.has(key)))
+      if (selectedKeys && selectedKeys.size !== visibleKeys.size) {
+        setVisibleKeys(selectedKeys.size ? selectedKeys : null)
+      }
+      const visibleSet = selectedKeys?.size ? selectedKeys : trendDefaultVisibleKeys(modelOrder, hasSpeed)
       const visibleModels = modelOrder.filter((model) => visibleSet.has(model))
       const showRate = visibleSet.has(LEGEND_KEY_RATE)
       const showSpeed = hasSpeed && visibleSet.has(LEGEND_KEY_SPEED)
@@ -2242,15 +2291,26 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
       // 金额视图左轴走紧凑金额读数,速度接管时仍为 tok/s 紧凑读数
       const yTicks = leftAxisTicks(layout.ticks, layout.scaleMax, speedAxisTicks, speedAxisMax,
         money ? (value) => formatCostCompact(value, costCurrency) : formatCompact)
-      // 悬浮明细恒用 token 槽渲染:金额模式只切柱几何与左轴,悬浮文本不随口径变化
-      const hoverSlot = hover ? (tipSlots ?? slots)[hover.index] : null
+      const hoverSlot = hover ? tipSlots.find((slot) => slot.day === hover.day) : null
+      const selectedSlot = visibleTipSlot(hoverSlot, visibleModels)
+      const tipEntries = tipModelEntries(selectedSlot, visibleSet)
+      const hasModels = tipEntries.main.length > 0
+      const tipRate = showRate && hoverSlot && cacheRate(hoverSlot.cacheHit, hoverSlot.cacheMiss) !== null
+      const tipSpeed = showSpeed && hoverSlot?.speed !== undefined
+      const tipTtft = showTtft && hoverSlot?.ttft !== undefined
+      const hasMetrics = tipRate || tipSpeed || tipTtft
+      const hasTip = hasModels || hasMetrics
+      const filtered = visibleModels.length < modelOrder.length
+      const formatTipValue = money ? (value) => `≈ ${formatCost(value, costCurrency)}` : (value) => `${formatTokens(value)} tok`
+      const tipTotalLabel = t(money ? (filtered ? 'selectedCost' : 'totalCost') : (filtered ? 'selectedTotal' : 'total'))
       const hoverRatePoint = showRate && hoverSlot ? ratePoints.find((point) => point.day === hoverSlot.day) : null
       const hoverSpeedPoint = hoverSlot ? speedPoints.find((point) => point.day === hoverSlot.day) : null
       const hoverTtftPoint = hoverSlot ? ttftPoints.find((point) => point.day === hoverSlot.day) : null
-      const pick = (index) => (event) => setHover({ index, anchor: pointerAt(event) })
+      const pick = (index) => (event) => setHover({ day: slots[index].day, anchor: pointerAt(event) })
       const clear = () => setHover(null)
-      const tipEntries = hasTipContent(hoverSlot) ? tipModelEntries(hoverSlot, visibleSet) : null
-      const avgPrice = tipAvgPriceText(hoverSlot, costCurrency)
+      const showCost = hasModels && (money || prefsRef.current.costDisplay) && selectedSlot.cost !== undefined
+      const avgPrice = showCost ? tipAvgPriceText(selectedSlot, costCurrency) : null
+      const otherEntries = money ? [...tipEntries.other].sort(([a], [b]) => (hoverSlot.otherCostByModel[b] ?? 0) - (hoverSlot.otherCostByModel[a] ?? 0)) : tipEntries.other
       return h('div', { className: 'ud-section' },
         h('div', { className: 'ud-section-head' },
           h('span', { className: 'ud-section-title' }, title),
@@ -2279,11 +2339,11 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
                 x: plotRight + AXIS_RATE_GAP, y: y + AXIS_LABEL_BASELINE,
               }, String(tick))
             }),
-            layout.bars.flatMap((bar, barIndex) => bar.segments.map((segment) => h('rect', {
+            layout.bars.flatMap((bar) => bar.segments.map((segment) => h('rect', {
               key: `${bar.key}/${segment.model}`, className: 'ud-bar',
               x: bar.x - layout.barWidth / 2, y: segment.y, width: layout.barWidth, height: segment.height,
               fill: colorFor(segment.model),
-              style: hover?.index === barIndex
+              style: hover?.day === bar.key
                 ? { transform: `scaleX(${(layout.barWidth + BAR_HOVER_GROW) / layout.barWidth})` }
                 : undefined,
             }))),
@@ -2321,25 +2381,22 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
           isVisible: (key) => visibleSet.has(key),
           onItem: (key, ctrl) => setVisibleKeys(legendToggle(visibleSet, key, ctrl)),
         }),
-        h(ChartTip, { anchor: hover ? hover.anchor : null, panelRef },
-          tipEntries
+        h(ChartTip, { anchor: hasTip ? hover.anchor : null, panelRef },
+          hasTip
             ? [
                 h('div', { key: 'title', className: 'ud-tip-title' }, slotLabelFor ? slotLabelFor(hoverSlot.day) : hoverSlot.day),
-                h('div', { key: 'total', className: 'ud-tip-row' }, `${t('total')}: ${formatTokens(hoverSlot.total)}`),
+                hasModels ? h('div', { key: 'total', className: 'ud-tip-row' }, `${tipTotalLabel}: ${formatTipValue(money ? selectedSlot.cost : selectedSlot.total)}`) : null,
                 ...tipEntries.main.map((row) => h('div', { key: `m-${row.model}`, className: 'ud-tip-row' },
                   h('i', { className: 'ud-legend-swatch', style: { background: colorFor(row.model) } }),
-                  `${row.model === OTHER_MODEL ? t('other') : row.model}: ${formatTokens(row.tokens)}`)),
-                ...tipEntries.other.map(([model, tokens]) => h('div', { key: `om-${model}`, className: 'ud-tip-row ud-tip-row--sub' },
-                  `${model}: ${formatTokens(tokens)}`)),
-                showRate ? h('div', { key: 'rate', className: 'ud-tip-row' }, `${t('cacheHitRate')}: ${cacheRateText(hoverSlot.cacheHit, hoverSlot.cacheMiss)}`) : null,
-                showSpeed ? h('div', { key: 'speed', className: 'ud-tip-row' }, `${t('avgSpeed')}: ${speedTipText(hoverSlot.speed)}`) : null,
-                showTtft ? h('div', { key: 'ttft', className: 'ud-tip-row' }, `${t('ttftLegend')}: ${ttftTipText(hoverSlot.ttft, t)}`) : null,
-                prefsRef.current.costDisplay && hoverSlot.cost !== undefined
-                  ? [
-                      h('div', { key: 'cost', className: 'ud-tip-row' }, `≈ ${formatCost(hoverSlot.cost, costCurrency)}`),
-                      avgPrice ? h('div', { key: 'avg-price', className: 'ud-tip-row' }, `${t('avgPrice')}: ${avgPrice}`) : null,
-                    ]
-                  : null,
+                  `${row.model === OTHER_MODEL ? t('other') : row.model}: ${formatTipValue(money ? hoverSlot.byCostModel[row.model] ?? 0 : row.tokens)}`)),
+                ...otherEntries.map(([model, tokens]) => h('div', { key: `om-${model}`, className: 'ud-tip-row ud-tip-row--sub' },
+                  `${model}: ${formatTipValue(money ? hoverSlot.otherCostByModel[model] ?? 0 : tokens)}`)),
+                showCost && !money ? h('div', { key: 'cost', className: 'ud-tip-row' }, `≈ ${formatCost(selectedSlot.cost, costCurrency)}`) : null,
+                avgPrice ? h('div', { key: 'avg-price', className: 'ud-tip-row' }, `${t('avgPrice')}: ${avgPrice}`) : null,
+                hasMetrics ? h('div', { key: 'metrics', className: 'ud-tip-title' }, t('slotMetrics')) : null,
+                tipRate ? h('div', { key: 'rate', className: 'ud-tip-row' }, `${t('cacheHitRate')}: ${cacheRateText(hoverSlot.cacheHit, hoverSlot.cacheMiss)}`) : null,
+                tipSpeed ? h('div', { key: 'speed', className: 'ud-tip-row' }, `${t('avgSpeed')}: ${speedTipText(hoverSlot.speed)}`) : null,
+                tipTtft ? h('div', { key: 'ttft', className: 'ud-tip-row' }, `${t('ttftLegend')}: ${ttftTipText(hoverSlot.ttft, t)}`) : null,
               ]
             : null))
     }
@@ -2605,14 +2662,7 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
       const usage = useProjection('tokenUsage')
       const [prefs, setPrefs] = useState(() => statsLineState.get())
       useEffect(() => statsLineState.subscribe(() => setPrefs(statsLineState.get())), [])
-      const [pricingRules, setPricingRules] = useState(null)
-      useEffect(() => {
-        let alive = true
-        fetchPricing().then((value) => {
-          if (alive && value) setPricingRules(value.rules)
-        })
-        return () => { alive = false }
-      }, [])
+      const { rules: pricingRules } = usePricing()
       const anchorRef = useRef(null)
       const costRef = useRef(null)
       useLayoutEffect(() => {
@@ -2649,14 +2699,7 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
         : null
       const [prefs, setPrefs] = useState(() => statsLineState.get())
       useEffect(() => statsLineState.subscribe(() => setPrefs(statsLineState.get())), [])
-      const [pricingRules, setPricingRules] = useState(null)
-      useEffect(() => {
-        let alive = true
-        fetchPricing().then((value) => {
-          if (alive && value) setPricingRules(value.rules)
-        })
-        return () => { alive = false }
-      }, [])
+      const { rules: pricingRules } = usePricing()
       const matched = usageSourceBuckets(usageSource)
       const price = matched && prefs.costDisplay && pricingRules !== null
         ? matchPrice(pricingRules, turnModelOf(matched), new Date())
@@ -2900,6 +2943,11 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
       const [saving, setSaving] = useState(false)
       const [saved, setSaved] = useState(false)
       const savedTimerRef = useRef(null)
+      const aliveRef = useRef(false)
+      useEffect(() => {
+        aliveRef.current = true
+        return () => { aliveRef.current = false }
+      }, [])
 
       useEffect(() => {
         let alive = true
@@ -2930,13 +2978,15 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
         if (found.size > 0) return
         setSaving(true)
         const result = await requestPost(ENDPOINTS.pricing, { rules: coercePricingRules(rules) })
+        // 保存属于共享数据提交,编辑器退出后仍广播;局部状态只由存活实例更新。
+        if (result.ok && validPricing(result.value)) applyPricingValue(result.value, true)
+        if (!aliveRef.current) return
         setSaving(false)
-        if (!result.ok) {
-          setSaveError(result.message)
+        if (!result.ok || !validPricing(result.value)) {
+          setSaveError(result.message || '价格响应无效')
           return
         }
-        // 保存即生效:响应 value 直接覆盖缓存,编辑副本同步为服务端规整后的规则
-        applyPricingValue(result.value)
+        // 编辑副本同步为本次保存返回的规则,其他编辑器草稿保持独立。
         setSaveError('')
         setErrors(new Map())
         setRules(copyRules(result.value.rules))
@@ -3152,19 +3202,11 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
       const panelRef = useRef(null)
       const [heatDays, setHeatDays] = useState(null)
       // 费用展示货币来源:价格规则异步首帧未回时空串即不带符号
-      const [pricingRules, setPricingRules] = useState(null)
-
-      useEffect(() => {
-        let alive = true
-        fetchPricing().then((value) => {
-          if (alive && value) setPricingRules(value.rules)
-        })
-        return () => { alive = false }
-      }, [])
+      const { rules: pricingRules, tick: pricingTick } = usePricing()
 
       const costCurrency = aggregateCurrencyOf(pricingRules)
 
-      // 热力图独立请求:与所选范围无关,失败静默留空,过期响应丢弃
+      // 热力图独立请求:范围切换不重取,价格变更重算费用,过期响应丢弃
       useEffect(() => {
         const generation = ++heatGenerationRef.current
         const request = { from: localDay(-(HEAT_WINDOW_DAYS - 1)), to: localDay(0) }
@@ -3183,7 +3225,8 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
             }
           }))
         })
-      }, [])
+        return () => { heatGenerationRef.current++ }
+      }, [pricingTick])
 
       const load = useCallback(async () => {
         const request = range === 'custom'
@@ -3201,10 +3244,11 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
         }
         setError('')
         setStats(result.value)
-      }, [range, customFrom, customTo])
+      }, [range, customFrom, customTo, pricingTick])
 
       useEffect(() => {
         load()
+        return () => { generationRef.current++ }
       }, [load])
 
       const rawPreset = view === 'hour' ? hourPreset : view === 'minute' ? minutePreset : null
@@ -3213,7 +3257,7 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
 
       useEffect(() => {
         if (!activeQuery) return
-        if (pointStatsMatches(pointStats, view, activeQuery.key)) return
+        if (pointStatsMatches(pointStats, view, activeQuery.key) && pointStats.pricingTick === pricingTick) return
         const generation = ++pointGenerationRef.current
         setPointStatus('loading')
         requestPost(view === 'hour' ? ENDPOINTS.hours : ENDPOINTS.minutes, activeQuery.request).then((result) => {
@@ -3225,9 +3269,10 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
           }
           setError('')
           setPointStatus('ok')
-          setPointStats({ view, preset: activeQuery.key, value: result.value })
+          setPointStats({ view, preset: activeQuery.key, pricingTick, value: result.value })
         })
-      }, [view, rawPreset, pointCustomFrom, pointCustomTo, fetchTick])
+        return () => { pointGenerationRef.current++ }
+      }, [view, rawPreset, pointCustomFrom, pointCustomTo, fetchTick, pricingTick])
 
       const refreshPoints = useCallback(() => {
         setPointStats(null)

package/src/store.js

@@ -2,8 +2,9 @@
 // single 布局每次持久化写都全量重发布 unit 文档,故写入侧做合并(write-behind):
 // record 同步累加进内存 pending,按周期 flush 批量落盘,同桶多样本折叠为一次
 // update;flush 失败的行留在 pending 下轮重试,错误经 onFlushError 上抛。
-// 游标读写与 flush 全部串行在同一条 promise 链上,防 lost update。进程级单例
-// 挂 globalThis,防 HMR 热重载后重复开域。
+// 游标读写与 flush 全部串行在同一条 promise 链上,防 lost update。store 实例
+// 按 facility 弱关联缓存,防 HMR 热重载换 facility 后旧实例泄漏或撞单开守卫;
+// 同名域被上一代遗留占用时收养(close 孤儿后重开),不留永久降级。
 
 import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain'
 import { z } from 'zod'
@@ -217,6 +218,7 @@ export class UsageStore {
   }
 
   async initialize(facility) {
+    // 占用不等于无主:开域失败只降级,不关闭其他实例仍在写入的句柄。
     const domain = await facility.open(usageStatsDomain)
     this.domain = domain
     this.table = domain.table(TABLE_BUCKETS)
@@ -480,13 +482,18 @@ export class UsageStore {
   }
 }
 
-const SHARED_STORE_KEY = '__dshUsageDashStore'
+const SHARED_STORE_KEY = '__dshUsageDashStores'
 
+// 单例按 facility 关联:插件热重载会换 facility 再 apply,全局单 key 缓存会把
+// 绑定旧域的实例泄漏给新一代,或将新一代 open 撞 reserved 固化为永久降级;
+// 未降级实例同 facility 复用,降级/异 facility 一律重建
+// 可作弱键的 facility 才可缓存:服务缺席桩(非对象)退化为不缓存,每次新建
 export function sharedStore(facility, options = {}) {
-  const existing = globalThis[SHARED_STORE_KEY]
-  if (existing) return existing
+  const cacheable = (typeof facility === 'object' && facility !== null) || typeof facility === 'function'
+  const existing = cacheable ? globalThis[SHARED_STORE_KEY]?.get?.(facility) : undefined
+  if (existing && existing.degradation === undefined) return existing
   const store = new UsageStore(facility, options)
-  globalThis[SHARED_STORE_KEY] = store
+  if (cacheable) (globalThis[SHARED_STORE_KEY] ??= new WeakMap()).set(facility, store)
   return store
 }
 

package/test/pricing-current.test.mjs

@@ -0,0 +1,179 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { CLIENT_SOURCE } from './client-eval.mjs'
+
+const flush = () => new Promise(resolve => setImmediate(resolve))
+const nodes = node => !node || typeof node !== 'object' ? [] : Array.isArray(node) ? node.flatMap(nodes) : [node, ...(node.children ?? []).flatMap(nodes)]
+const text = node => typeof node === 'string' ? node : Array.isArray(node) ? node.map(text).join('') : (node?.children ?? []).map(text).join('')
+const rule = (amount = 1, currency = '¥') => ({ model: '*/*', unit: 'perMillion', currency, price: { input: amount, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] })
+const price = (revision, amount = revision) => ({ revision, rules: [rule(amount)] })
+const usage = { uncachedInputTokens: 1000 * 1000, inputTokens: 1000 * 1000, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, routes: [{ model: 'p/m' }] }
+
+// 执行真实loader和槽组件,Hook仅模拟状态/依赖/清理,网络为可控边界。
+function fixture() {
+  let current, factory, now = Date.now()
+  const slots = new Map(), mounted = [], requests = [], gets = [], saves = [], timers = new Map()
+  let lateState = 0
+  const depsEqual = (a, b) => a && b && a.length === b.length && a.every((value, i) => Object.is(value, b[i]))
+  const hooks = {
+    createElement: (type, props, ...children) => ({ type, props: props ?? {}, children }),
+    memo: fn => fn, Fragment: 'fragment', useId: () => 'fixture',
+    useState(seed) {
+      const owner = current, i = owner.cursor++
+      if (!(i in owner.states)) owner.states[i] = typeof seed === 'function' ? seed() : seed
+      return [owner.states[i], value => {
+        if (!owner.alive) { lateState++; return }
+        owner.states[i] = typeof value === 'function' ? value(owner.states[i]) : value
+        owner.dirty = true
+      }]
+    },
+    useRef(seed) { const i = current.cursor++; return current.refs[i] ??= { current: seed } },
+    useMemo(fn, deps) {
+      const i = current.cursor++, old = current.memos[i]
+      if (!old || !depsEqual(old.deps, deps)) current.memos[i] = { value: fn(), deps }
+      return current.memos[i].value
+    },
+    useEffect(fn, deps) {
+      const owner = current, i = owner.cursor++, old = owner.effects[i]
+      if (!old || !depsEqual(old.deps, deps)) owner.pending.push(() => {
+        old?.cleanup?.(); owner.effects[i] = { deps, cleanup: fn() }
+      })
+    },
+  }
+  hooks.useCallback = (fn, deps) => hooks.useMemo(() => fn, deps)
+  hooks.useLayoutEffect = hooks.useEffect
+  const window = { __ModuleLoader__: { load: entry => { factory = entry.factory } }, addEventListener() {}, removeEventListener() {} }
+  const document = { querySelector: () => ({}), querySelectorAll: () => [], documentElement: {}, body: {} }
+  const schedule = (fn, ms) => { const id = {}; timers.set(id, { fn, ms }); return id }
+  const fetch = async (path, options = {}) => {
+    requests.push({ path, ...options })
+    const deferred = Promise.withResolvers()
+    if (path.endsWith('/pricing')) {
+      const list = options.method === 'POST' ? saves : gets
+      list.push({ ...deferred, body: options.body && JSON.parse(options.body) })
+      return deferred.promise
+    }
+    const value = path.endsWith('/status') ? { running: false } : { models: [], daily: [], total: 0, requests: 0, from: '2026-10-01', to: '2026-10-28' }
+    return { json: async () => ({ ok: true, value }) }
+  }
+  const Clock = class extends Date { static now() { return now } }
+  new Function('window', 'document', 'fetch', 'localStorage', 'MutationObserver', 'setTimeout', 'clearTimeout', 'Date', CLIENT_SOURCE)(window, document, fetch, null, class { observe() {} disconnect() {} takeRecords() { return [] } }, schedule, id => timers.delete(id), Clock)
+  const mod = factory(name => name === 'react' ? hooks : { createPortal: null })
+  mod.apply({ effect: fn => fn(), locale: { register() {} }, slots: { inject: (_name, fn) => fn(), register: (entry, component) => slots.set(entry.name, component) } })
+  const render = owner => {
+    current = owner; owner.cursor = 0; owner.dirty = false
+    owner.tree = owner.component(owner.props); current = null
+    owner.pending.splice(0).forEach(fn => fn())
+    return owner.tree
+  }
+  const mount = (component, props = {}) => {
+    const owner = { component, props, states: [], refs: [], memos: [], effects: [], pending: [], cursor: 0, alive: true, dirty: true }
+    mounted.push(owner); render(owner); return owner
+  }
+  const unmount = owner => { owner.alive = false; owner.effects.forEach(effect => effect?.cleanup?.()) }
+  const settle = async () => {
+    for (let i = 0; i < 12; i++) { await flush(); mounted.filter(owner => owner.alive && owner.dirty).forEach(render) }
+  }
+  const panel = () => mount(slots.get('settings.section'))
+  const editor = () => { const p = panel(); return mount(nodes(p.tree).find(n => n.type?.name === 'PricingEditor').type) }
+  const stats = () => mount(slots.get('conversation.composer.dock'), { useProjection: () => usage })
+  const chip = () => mount(slots.get('conversation.chat.assistant-actions'), { messageId: 'm1', useChat: select => select({ nodes: [{ kind: 'turn-tail', data: { closing: { finalNode: { messageId: 'm1' } }, tokenUsage: usage } }] }) })
+  const resolve = (item, value) => item.resolve({ json: async () => ({ ok: true, value }) })
+  const save = owner => {
+    const button = nodes(owner.tree).find(n => n.type === 'button' && text(n) === '保存')
+    assert.ok(button, '已载入编辑器保存按钮'); return button.props.onClick()
+  }
+  return { panel, editor, stats, chip, settle, unmount, requests, gets, saves, resolve, save, mount, nodes, text, timers,
+    get lateState() { return lateState }, advance: ms => { now += ms }, cleanup: () => mounted.filter(o => o.alive).forEach(unmount) }
+}
+
+const withFixture = async (t, fn) => { const f = fixture(); t.after(f.cleanup); await fn(f) }
+
+test('P1 Given concurrent consumers, When cold mounted, Then only one pricing GET is sent', t => withFixture(t, async f => {
+  f.stats(); f.stats(); f.panel(); f.editor()
+  assert.equal(f.gets.length, 1)
+}))
+
+test('P2/P4 Given mounted consumers, When editor saves, Then cost changes and panel ranges refresh', t => withFixture(t, async f => {
+  const stats = f.stats(), chip = f.chip(), editor = f.editor()
+  f.gets.forEach(item => f.resolve(item, price(1))); await f.settle()
+  assert.match(text(stats.tree), /¥1\.00/)
+  assert.match(text(chip.tree), /¥1\.00/)
+  const before = f.requests.filter(r => r.path.endsWith('/range')).length
+  const pending = f.save(editor); f.resolve(f.saves[0], price(2)); await pending; await f.settle()
+  assert.match(text(stats.tree), /¥2\.00/)
+  assert.match(text(chip.tree), /¥2\.00/)
+  assert.equal(f.requests.filter(r => r.path.endsWith('/range')).length, before + 2)
+}))
+
+test('P3/P8 Given initial load or same revision TTL refresh, When panel mounts, Then range is not duplicated', t => withFixture(t, async f => {
+  f.panel(); f.resolve(f.gets[0], price(1)); await f.settle()
+  assert.equal(f.requests.filter(r => r.path.endsWith('/range')).length, 2)
+  f.advance(5 * 60 * 1000 + 1); f.panel()
+  f.resolve(f.gets.at(-1), price(1)); await f.settle()
+  assert.equal(f.requests.filter(r => r.path.endsWith('/range')).length, 4)
+}))
+
+test('P6/P9 Given new save while old GET is pending, When old reply arrives, Then price never goes backward', t => withFixture(t, async f => {
+  const editor = f.editor()
+  f.gets.forEach(item => f.resolve(item, price(1))); await f.settle()
+  f.advance(5 * 60 * 1000 + 1)
+  const stats = f.stats(), old = f.gets.at(-1)
+  const pending = f.save(editor); f.resolve(f.saves[0], price(3)); await pending; await f.settle()
+  f.resolve(old, price(2)); await f.settle()
+  assert.match(text(stats.tree), /¥3\.00/)
+  const remount = f.stats(); await f.settle(); assert.match(text(remount.tree), /¥3\.00/)
+}))
+
+test('P7 Given TTL refresh GET pending, When another editor saves first, Then panel refreshes for mutation', t => withFixture(t, async f => {
+  const editor = f.editor(); f.gets.forEach(item => f.resolve(item, price(1))); await f.settle()
+  f.advance(5 * 60 * 1000 + 1); f.panel()
+  const before = f.requests.filter(r => r.path.endsWith('/range')).length
+  const pending = f.save(editor); f.resolve(f.saves[0], price(2)); await pending; await f.settle()
+  assert.equal(f.requests.filter(r => r.path.endsWith('/range')).length, before + 4)
+}))
+
+test('P10 Given editor unmount during save, When reply arrives, Then publish without stale state or timer', t => withFixture(t, async f => {
+  const stats = f.stats(), editor = f.editor()
+  f.gets.forEach(item => f.resolve(item, price(1))); await f.settle()
+  const before = f.timers.size, pending = f.save(editor); f.unmount(editor)
+  f.resolve(f.saves[0], price(2)); await pending; await f.settle()
+  assert.equal(f.lateState, 0)
+  assert.equal(f.timers.size, before)
+  assert.match(text(stats.tree), /¥2\.00/)
+}))
+
+test('P11 Given another editor has a draft, When save publishes, Then draft stays unchanged', t => withFixture(t, async f => {
+  const a = f.editor(), b = f.editor()
+  f.gets.forEach(item => f.resolve(item, price(1))); await f.settle()
+  const group = () => nodes(b.tree).find(n => n.type?.name === 'PricingModelGroup')
+  group().props.onModelChange('draft/model'); await f.settle()
+  const pending = f.save(a); f.resolve(f.saves[0], price(2)); await pending; await f.settle()
+  assert.equal(group().props.group.model, 'draft/model')
+}))
+
+for (const [tab, endpoint] of [['小时', 'hours'], ['分钟', 'minutes']]) {
+  test(`P5 Given ${endpoint} view, When save publishes, Then active points refetch once`, t => withFixture(t, async f => {
+    const panel = f.panel(), editor = f.editor()
+    f.resolve(f.gets[0], price(1)); await f.settle()
+    const button = nodes(panel.tree).find(n => n.type === 'button' && text(n) === tab)
+    assert.ok(button, tab + '视图按钮'); button.props.onClick(); await f.settle()
+    const count = () => f.requests.filter(r => r.path.endsWith('/' + endpoint)).length
+    assert.equal(count(), 1)
+    const pending = f.save(editor); f.resolve(f.saves[0], price(2)); await pending; await f.settle()
+    assert.equal(count(), 2)
+  }))
+}
+
+test('P10-GET Given consumers unmount with GET pending, When response arrives, Then no stale state is written', t => withFixture(t, async f => {
+  const stats = f.stats(), editor = f.editor()
+  f.unmount(stats); f.unmount(editor)
+  f.resolve(f.gets[0], price(2)); await f.settle()
+  assert.equal(f.lateState, 0)
+}))
+
+test('P12 Given failed pricing request, When next consumer mounts, Then failed flight is released and retry works', t => withFixture(t, async f => {
+  f.stats(); f.gets[0].reject(new Error('injected network')); await f.settle()
+  const stats = f.stats(); assert.equal(f.gets.length, 2)
+  f.resolve(f.gets[1], price(2)); await f.settle(); assert.match(text(stats.tree), /¥2\.00/)
+}))

package/test/stats-line-render.test.mjs

@@ -17,7 +17,7 @@ function render(options = {}) {
   const useState = (init) => [stateIndex++ === 1 ? pricing : typeof init === 'function' ? init() : init, () => {}]
   const noop = () => {}
   const names = Object.keys(core)
-  const component = new Function(...names, 'React', 'h', 'useState', 'useEffect', 'useLayoutEffect', 'useRef', 'statsLineState', 'defaultT', 'fetchPricing', 'useUsageDialogTarget', 'createPortal', `return (${source})`)(...Object.values(core), React, h, useState, noop, noop, () => ({ current: null }), { get: () => prefs }, core.createTranslator(core.MESSAGES_ZH), noop, () => target, (content, container) => ({ type: 'portal', props: { container }, children: [content].flat(Infinity) }))
+  const component = new Function(...names, 'React', 'h', 'useState', 'useEffect', 'useLayoutEffect', 'useRef', 'statsLineState', 'defaultT', 'usePricing', 'useUsageDialogTarget', 'createPortal', `return (${source})`)(...Object.values(core), React, h, useState, noop, noop, () => ({ current: null }), { get: () => prefs }, core.createTranslator(core.MESSAGES_ZH), () => ({ rules: pricing }), () => target, (content, container) => ({ type: 'portal', props: { container }, children: [content].flat(Infinity) }))
   return component({ useProjection: () => value, t: core.createTranslator(lang === 'en' ? core.MESSAGES_EN : core.MESSAGES_ZH) })
 }
 const nodes = (tree) => tree && typeof tree === 'object' ? [tree, ...tree.children.flatMap(nodes)] : []

package/test/store-owner.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { DomainFacility } from '@deepseek-ai/dsh-storage-domain'
+import { UsageStore, sharedStore, __resetSharedStoreForTests } from '../src/store.js'
+
+// 真实宿主域,只替换磁盘后端,不读取生产档案或调用回扫。
+test('UO1 Given real DomainFacility with live pending owner, When a newcomer collides, Then old tokens remain writable exactly once', async () => {
+  const media = new Map(), closes = [], errors = []
+  const backend = { kv: { async open(spec) {
+    const data = media.get(spec.name) ?? { tables: { buckets: {} }, global: null }
+    media.set(spec.name, data)
+    return {
+      async loadAll() { return structuredClone(data) },
+      async setGlobal(value) { data.global = structuredClone(value) },
+      async putRecord(table, key, value) { data.tables[table][key] = structuredClone(value) },
+      async deleteRecord(table, key) { delete data.tables[table][key] },
+      async close() { closes.push(spec.name) },
+    }
+  } } }
+  const facility = new DomainFacility({ storage: { backend: { get: () => backend } }, emit() {}, logger: { warn() {} } }, { backend: 'memory' })
+  let old, next
+  try {
+    __resetSharedStoreForTests()
+    old = new UsageStore(facility, { onFlushError: error => errors.push(error.message) })
+    await old.readyPromise()
+    await old.markSeenSessions(['s1'])
+    await old.record({ time: Date.now(), model: 'probe/model', inputTokens: 17, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 })
+    next = sharedStore(facility)
+    await next.readyPromise()
+    assert.ok(next.degradation)
+    assert.deepEqual(closes, [])
+    assert.deepEqual(await old.seenSessions(), new Set(['s1']))
+    await old.flushNow()
+    await old.flushNow()
+    assert.deepEqual(errors, [])
+    const sums = Object.entries(media.get('usage_stats').tables.buckets).filter(([key]) => key.startsWith('D|')).reduce((sum, [, row]) => sum + row.inputTokens, 0)
+    assert.equal(sums, 17)
+    assert.equal(old.pending.size, 0)
+    await assert.rejects(next.record({ time: Date.now(), model: 'probe/model', inputTokens: 17 }), /usage store degraded/)
+  } finally {
+    clearTimeout(old?.flushTimer); clearTimeout(next?.flushTimer)
+    await facility.closeAll()
+    __resetSharedStoreForTests()
+  }
+})

package/test/store.test.mjs

@@ -563,13 +563,118 @@ test('域打开失败进入降级:ready 可等待,操作按调用失败', async
   assert.deepEqual(await store.liveSequences(), new Map())
 })
 
-test('globalThis 单例复用同实例,重置缝生效', () => {
+test('globalThis 单例按 facility 关联:同 facility 同实例,异 facility 新实例', async () => {
   __resetSharedStoreForTests()
-  const first = sharedStore(facilityOf(fakeDomain()))
-  assert.equal(sharedStore(facilityOf(fakeDomain())), first)
+  const facilityA = facilityOf(fakeDomain())
+  const a = await sharedStore(facilityA)
+  assert.equal(await sharedStore(facilityA), a)
+  assert.notEqual(await sharedStore(facilityOf(fakeDomain())), a)
   __resetSharedStoreForTests()
-  assert.notEqual(sharedStore(facilityOf(fakeDomain())), first)
+})
+
+test('降级实例不复用:同 facility 再取重建新实例', async () => {
+  __resetSharedStoreForTests()
+  const facility = { open: () => Promise.reject(new Error("domain 'usage_stats' is already open")) }
+  const degraded = await sharedStore(facility)
+  await degraded.readyPromise()
+  assert.ok(degraded.degradation)
+  const fresh = sharedStore(facility)
+  assert.notEqual(fresh, degraded)
+  __resetSharedStoreForTests()
+})
+
+test('非对象 facility(服务缺席桩)不缓存:每次新建', () => {
+  __resetSharedStoreForTests()
+  assert.notEqual(sharedStore(undefined), sharedStore(undefined))
+  __resetSharedStoreForTests()
+})
+
+// 同名域占用不证明无主;get 诊断面不可授权关闭活跃 owner。
+function facilityWithReserved({ withCode = true } = {}) {
+  const reserved = new Map()
+  const closes = []
+  const open = async (spec) => {
+    if (reserved.has(spec.name)) {
+      const err = new Error(`domain '${spec.name}' is already open`)
+      if (withCode) err.code = 'already-open'
+      throw err
+    }
+    const domain = fakeDomain()
+    domain.close = async () => {
+      closes.push(spec.name)
+      reserved.delete(spec.name)
+    }
+    reserved.set(spec.name, domain)
+    return domain
+  }
+  return { open, get: (name) => reserved.get(name), closes }
+}
+
+for (const withCode of [true, false]) {
+  test(`Given occupied domain with code=${withCode}, When another store opens, Then owner stays live and newcomer degrades`, async () => {
+    __resetSharedStoreForTests()
+    const facility = facilityWithReserved({ withCode })
+    const owner = await facility.open({ name: 'usage_stats' })
+    await facility.open({ name: 'usage_stats_backup' })
+    const store = sharedStore(facility)
+    await store.readyPromise()
+    assert.ok(store.degradation)
+    assert.equal(facility.get('usage_stats'), owner)
+    assert.deepEqual(facility.closes, [])
+    await owner.global.set({ stillLive: true })
+    assert.deepEqual(owner.global.get(), { stillLive: true })
+    await assert.rejects(store.record(tokenSample(local(2026, 8, 2, 14, 37))), /usage store degraded/)
+    __resetSharedStoreForTests()
+  })
+}
+
+test('UO1 Given old owner with seen cursor and pending tokens, When new generation opens, Then old owner flushes every bucket once', async () => {
   __resetSharedStoreForTests()
+  const facility = facilityWithReserved()
+  const old = new UsageStore(facility)
+  await old.readyPromise()
+  await old.markSeenSessions(['s1'])
+  await old.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  clearTimeout(old.flushTimer)
+  const newcomer = sharedStore(facility)
+  await newcomer.readyPromise()
+  assert.deepEqual(facility.closes, [])
+  assert.ok(newcomer.degradation)
+  await old.flushNow()
+  const rows = await old.rangeRows('D', '2026-08-02', '2026-08-02')
+  assert.equal(rows.length, 1)
+  assert.equal(rows[0].inputTokens, 10)
+  assert.equal(rows[0].outputTokens, 20)
+  assert.deepEqual(await old.seenSessions(), new Set(['s1']))
+  await old.flushNow()
+  assert.equal((await old.rangeRows('D', '2026-08-02', '2026-08-02'))[0].inputTokens, 10)
+  __resetSharedStoreForTests()
+})
+
+test('UO3 Given occupied backup only, When main opens, Then collection works and backup owner is untouched', async () => {
+  __resetSharedStoreForTests()
+  const facility = facilityWithReserved()
+  const backup = await facility.open({ name: 'usage_stats_backup' })
+  const store = sharedStore(facility)
+  await store.readyPromise()
+  assert.equal(store.degradation, undefined)
+  assert.equal(facility.get('usage_stats_backup'), backup)
+  assert.deepEqual(facility.closes, [])
+  await store.record(tokenSample(local(2026, 8, 2, 14, 37)))
+  clearTimeout(store.flushTimer)
+  await store.flushNow()
+  assert.equal((await store.rangeRows('D', '2026-08-02', '2026-08-02'))[0].inputTokens, 10)
+  __resetSharedStoreForTests()
+})
+
+test('get 缝在场但孤儿已不存在:维持降级,不逃逸', async () => {
+  const store = new UsageStore({
+    open: () => Promise.reject(new Error("domain 'usage_stats' is already open")),
+    get: () => undefined,
+  })
+  await store.readyPromise()
+  assert.ok(store.degradation)
+  await assert.rejects(store.record(tokenSample(local(2026, 8, 2, 14, 37))), /usage store degraded/)
 })
 
 // —— 写合并(write-behind):record 同步入 pending,flush 周期落盘 ——

package/test/trend-tooltip.test.mjs

@@ -0,0 +1,182 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { CLIENT_SOURCE, CLIENT_BODY, DECLARATION_NAMES } from './client-eval.mjs'
+
+const core = new Function(`${CLIENT_BODY}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
+const nodes = node => !node || typeof node !== 'object' ? [] : [node, ...(node.children ?? []).flatMap(nodes)]
+const text = node => typeof node === 'string' ? node : (node?.children ?? []).map(text).join('')
+const OTHER = core.OTHER_MODEL
+const slot = {
+  day: '2026-10-28', total: 16000, byModel: { 'p/a': 1000, 'p/b': 9000, [OTHER]: 6000 },
+  otherByModel: { 'p/c': 2000, 'p/d': 4000 }, cost: 12,
+  byCostModel: { 'p/a': 2, 'p/b': 9, [OTHER]: 1 }, otherCostByModel: { 'p/c': 0.75, 'p/d': 0.25 },
+  cacheHit: 3000, cacheMiss: 1000, speed: 12, ttft: 300,
+}
+
+function fixture({ money = false, costDisplay = true, currency = '¥', lang = 'zh', data = [slot] } = {}) {
+  let factory, cursor = 0
+  const states = [], refs = []
+  const React = {
+    createElement: (type, props, ...children) => ({ type, props: props ?? {}, children: children.flat(Infinity).filter(x => x != null && x !== false) }),
+    memo: fn => fn, useId: () => 'trend-test',
+    useState(seed) {
+      const i = cursor++
+      if (!(i in states)) states[i] = typeof seed === 'function' ? seed() : seed
+      return [states[i], value => { states[i] = typeof value === 'function' ? value(states[i]) : value }]
+    },
+    useRef(seed) { const i = cursor++; return refs[i] ??= { current: seed } },
+    useEffect() {}, useLayoutEffect() {}, useMemo: fn => fn(), useCallback: fn => fn,
+  }
+  const window = { __ModuleLoader__: { load: entry => { factory = entry.factory } } }
+  const source = CLIENT_SOURCE.replace("inject: ['slots', 'locale'],", "__test: { TrendChart }, inject: ['slots', 'locale'],")
+  new Function('window', 'localStorage', source)(window, { getItem: () => JSON.stringify({ costDisplay }), setItem() {} })
+  const { TrendChart } = factory(name => name === 'react' ? React : {}).__test
+  let tree
+  const props = {
+    title: 'trend', notes: [], slots: data, tipSlots: data, modelOrder: ['p/a', 'p/b', OTHER],
+    colorFor: () => 'currentColor', labelFor: key => key, labelMinPitch: 60,
+    legendModels: [], money, costCurrency: currency, t: core.createTranslator(lang === 'en' ? core.MESSAGES_EN : core.MESSAGES_ZH),
+  }
+  const render = () => {
+    cursor = 0
+    props.slots = props.money ? core.costSlotsOf(props.tipSlots) : props.tipSlots
+    tree = TrendChart(props)
+    return tree
+  }
+  const tip = () => nodes(tree).find(n => n.type?.name === 'ChartTip')
+  const rows = () => nodes(tip()).filter(n => n.props.className?.includes('ud-tip-row')).map(text)
+  const hover = (index = 0) => {
+    nodes(tree).filter(n => n.props.className === 'ud-bar-hit')[index].props.onMouseEnter({ clientX: 20, clientY: 20 })
+    render()
+  }
+  const select = (key, ctrl = false) => {
+    nodes(tree).find(n => n.type?.name === 'Legend').props.onItem(key, ctrl)
+    render()
+  }
+  render()
+  return { hover, select, rows, tip: () => text(tip()), update: changes => { Object.assign(props, changes); render() } }
+}
+
+test('Given 金额视图 When 悬浮 Then 总计和各模型展示估算费用，其他明细按费用排序', () => {
+  const f = fixture({ money: true }); f.hover()
+  assert.deepEqual(f.rows().slice(0, 5), ['估算费用: ≈ ¥12.00', 'p/a: ≈ ¥2.00', 'p/b: ≈ ¥9.00', '其他: ≈ ¥1.00', 'p/c: ≈ ¥0.75'])
+  assert.ok(f.rows().includes('p/d: ≈ ¥0.25'))
+  assert.doesNotMatch(f.tip(), /16,000|9,000|6,000/)
+})
+
+test('Given Token 视图 When 单选模型 Then 总计、费用、均价仅包含可见模型', () => {
+  const f = fixture(); f.hover(); f.select('p/a')
+  assert.deepEqual(f.rows(), ['所选用量: 1,000 tok', 'p/a: 1,000 tok', '≈ ¥2.00', '均价: ¥2,000.000/M'])
+})
+
+test('Given 金额视图 When Ctrl 多选包含其他 Then 合计不重复计其他子项', () => {
+  const f = fixture({ money: true }); f.hover(); f.select('p/a'); f.select(OTHER, true)
+  assert.equal(f.rows()[0], '所选估算费用: ≈ ¥3.00')
+  assert.doesNotMatch(f.tip(), /p\/b:/)
+  assert.ok(f.rows().includes('均价: ¥428.571/M'))
+})
+
+for (const [key, label, value] of [['speed', '平均生成速度', '12 tok/s'], ['rate', '缓存命中率', '75.0%'], ['ttft', '首 token 延迟', '0.3秒']]) {
+  test(`Given 仅选 ${key} 曲线 When 悬浮 Then 只有时段整体指标且不显示模型合计或费用`, () => {
+    const f = fixture({ money: true }); f.hover(); f.select(key)
+    assert.match(f.tip(), /时段整体指标/)
+    assert.deepEqual(f.rows(), [`${label}: ${value}`])
+  })
+}
+
+test('Given 有其他付费槽和零费用模型 When 在金额视图选择零费用模型 Then 保留零费用读数', () => {
+  const data = [{ ...slot, byCostModel: { ...slot.byCostModel, 'p/a': 0 }, cost: 10 }]
+  const f = fixture({ money: true, data }); f.hover(); f.select('p/a')
+  assert.deepEqual(f.rows(), ['所选估算费用: ≈ ¥0.00', 'p/a: ≈ ¥0.00'])
+})
+
+test('Given 当前槽中选中模型没有用量 When 悬浮 Then 不展示隐藏模型总计或空提示', () => {
+  const f = fixture({ data: [{ ...slot, byModel: { ...slot.byModel, 'p/a': 0 } }] }); f.hover(); f.select('p/a')
+  assert.equal(f.tip(), '')
+})
+
+test('Given 辅助费用偏好关闭 When 切换金额视图 Then 主金额读数仍展示并响应货币变化', () => {
+  const f = fixture({ costDisplay: false }); f.hover(); f.select('p/a')
+  assert.deepEqual(f.rows(), ['所选用量: 1,000 tok', 'p/a: 1,000 tok'])
+  f.update({ money: true, costCurrency: '$' })
+  assert.deepEqual(f.rows(), ['所选估算费用: ≈ $2.00', 'p/a: ≈ $2.00', '均价: $2,000.000/M'])
+})
+
+test('Given 悬浮时间桶 When 切换到不含该桶的窗口 Then 清除提示而不复用数组下标', () => {
+  const f = fixture(); f.hover()
+  f.update({ tipSlots: [{ ...slot, day: '2026-10-27' }] })
+  assert.equal(f.tip(), '')
+})
+
+test('Given 悬浮时间桶 When 窗口前插时间桶 Then 提示仍绑定原时间桶', () => {
+  const f = fixture(); f.hover()
+  f.update({ tipSlots: [{ ...slot, day: '2026-10-27' }, slot] })
+  assert.match(f.tip(), /^2026-10-28/)
+})
+
+test('Given 英文金额视图 When 单选模型 Then 使用英文费用标签及当前货币', () => {
+  const f = fixture({ money: true, lang: 'en', currency: '$' }); f.hover(); f.select('p/a')
+  assert.equal(f.rows()[0], 'Selected estimated cost: ≈ $2.00')
+})
+
+for (const [key, label, value] of [['speed', '平均生成速度', '0 tok/s'], ['ttft', '首 token 延迟', '0秒']]) {
+  test(`Given 只有 timing 的时间桶 When 仅选 ${key} Then 零值指标仍显示提示`, () => {
+    const timing = { ...slot, total: 0, byModel: {}, cost: 0, byCostModel: {}, cacheHit: 0, cacheMiss: 0, speed: 0, ttft: 0 }
+    const f = fixture({ data: [timing] }); f.select(key); f.hover()
+    assert.deepEqual(f.rows(), [`${label}: ${value}`])
+  })
+}
+
+for (const key of ['speed', 'ttft', 'rate']) {
+  test(`Given 所选 ${key} 在当前桶没有数据 When 悬浮 Then 不显示空指标提示`, () => {
+    const emptyMetrics = { ...slot, day: '2026-10-27', speed: undefined, ttft: undefined, cacheHit: 0, cacheMiss: 0 }
+    const f = fixture({ data: [emptyMetrics, slot] }); f.select(key); f.hover()
+    assert.equal(f.tip(), '')
+  })
+}
+
+test('Given 单选旧模型 When 新窗口不含该模型 Then 恢复默认可见模型且能继续单选', () => {
+  const f = fixture(); f.select('p/a'); f.hover()
+  f.update({ tipSlots: [{ ...slot, total: 100, byModel: { 'p/z': 100 }, cost: 1, byCostModel: { 'p/z': 1 } }], modelOrder: ['p/z'] })
+  assert.ok(f.rows().includes('p/z: 100 tok'))
+  assert.equal(f.rows()[0], '总用量: 100 tok')
+  f.select('p/z')
+  assert.ok(f.rows().includes('p/z: 100 tok'))
+})
+
+test('Given 单选速度 When 新窗口没有速度 Then 恢复可用模型', () => {
+  const f = fixture(); f.select('speed'); f.hover()
+  f.update({ tipSlots: [{ ...slot, speed: undefined }] })
+  assert.ok(f.rows().includes('p/a: 1,000 tok'))
+  assert.doesNotMatch(f.tip(), /平均生成速度:/)
+})
+
+test('Given 小时桶悬浮 When 切到分钟桶 Then 旧提示清除且新提示显示分钟桶数据', () => {
+  const f = fixture({ data: [{ ...slot, day: '2026-10-28T12' }] }); f.hover()
+  f.update({ tipSlots: [{ ...slot, day: '2026-10-28T12:10' }] })
+  assert.equal(f.tip(), '')
+  f.hover()
+  assert.match(f.tip(), /^2026-10-28T12:10/)
+})
+
+test('Given 单选模型在新窗口全部失效 When 返回原窗口 Then 保持默认显示而不复活旧单选', () => {
+  const f = fixture(); f.select('p/a'); f.hover()
+  f.update({ tipSlots: [{ ...slot, total: 100, byModel: { 'p/z': 100 }, cost: 1, byCostModel: { 'p/z': 1 } }], modelOrder: ['p/z'] })
+  f.update({ tipSlots: [slot], modelOrder: ['p/a', 'p/b', OTHER] })
+  assert.equal(f.rows()[0], '总用量: 16,000 tok')
+  assert.ok(f.rows().includes('p/b: 9,000 tok'))
+})
+
+test('Given 多选中部分模型在新窗口失效 When 返回原窗口 Then 只保留未失效的选择', () => {
+  const f = fixture(); f.select('p/a'); f.select('p/b', true); f.hover()
+  f.update({ tipSlots: [{ ...slot, total: 1000, byModel: { 'p/a': 1000 }, cost: 2, byCostModel: { 'p/a': 2 } }], modelOrder: ['p/a'] })
+  f.update({ tipSlots: [slot], modelOrder: ['p/a', 'p/b', OTHER] })
+  assert.equal(f.rows()[0], '所选用量: 1,000 tok')
+  assert.doesNotMatch(f.tip(), /p\/b:/)
+})
+
+test('Given 未配置费用 When 悬浮 Token 视图 Then 只展示用量及有效曲线', () => {
+  const { cost, byCostModel, otherCostByModel, ...unpriced } = slot
+  const f = fixture({ data: [unpriced] }); f.select('p/a'); f.hover()
+  assert.deepEqual(f.rows(), ['所选用量: 1,000 tok', 'p/a: 1,000 tok'])
+})