@mzzsfy/dsh-usage-dash 0.10.3 → 0.10.5

package/README.md

@@ -9,25 +9,25 @@
 - 三粒度视图,全部支持自定义时间范围:天(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 形态不变(仍为逐规则字段),存量空货币规则经编辑器保存后归一。费用显示为全局价格定位:汇总卡/趋势悬浮/模型列表/底栏费用项/回合费用芯片的货币符号统一取规则表首个非空货币(数值仍按命中规则单价计算),切换并保存后全部显示点随之变更。
+规则形态:`{ model, currency, price: { input, output, cacheRead, cacheWrite }, conditions }`,单价单位固定「每百万 token」。货币为编辑器级全局设置:「定价规则」标题右侧切换,仅 ¥/$ 两档(无「空」档),打开编辑器即按首个非空货币归一显示(无非空回落 ¥),切换或保存后整表统一;wire 形态不变(仍为逐规则字段),存量空货币规则经编辑器保存后归一。**服务端单币约束**:pricing POST 整表替换时非空 currency 全表必须一致,混币提交 400 拒绝——费用聚合按数值直接相加,混币相加无意义。费用显示为全局价格定位:汇总卡/趋势悬浮/模型列表/底栏费用项/回合费用芯片的货币符号统一取规则表首个非空货币(数值仍按命中规则单价计算),切换并保存后全部显示点随之变更。**计价时点口径**:时间条件按「估算时点」匹配当前规则表——面板聚合以小时桶时点,回合费用芯片以回合结束事件被观测时刻(用量首达即冻结,重渲染不漂移);规则表变更后按当前规则重算历史为既定选择,不做价格版本化存储。
 
 - 模型匹配:`model` 为两段式 `vendor/model`(首个 `/` 分段,模型段允许含 `/`),两段各自可 `*` 通配;匹配链为 全名精确 > 模型名精确(`*/model`,跨供应商同模型名同价)> 供应商精确(`vendor/*`,同供应商多模型同价)> `*/*` 全通,档位相同按数组序取首个命中,高档条件不满足逐层落低档;全链无命中不计费用并计 unpriced。提交(编辑器保存与 pricing POST)强制两段式,单段旧形态(`*` 或裸名)不再合法
 - 同模型多规则(分时段定价):组内附加计费规则从上到下首个「条件全过」者生效,全不命中落组内默认价(无条件规则,恒兜底);附加规则卡带 ↑/↓ 调序。注意同一模型的多条规则请使用相同的模型键写法——不同写法(如 `*/model` 与 `vendor/model`)分属不同档位,按档位优先级而非数组序取胜
@@ -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.5",
   "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,17 +2699,15 @@ 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())
+      // 计价时点 = 回合结束事件被观测的时刻(F15 决策:统一用当时价格、按回合
+      // 事件时点匹配当前规则表)。官方 tokenUsage 无事件时间戳,以用量首次到
+      // 达的观测时刻冻结:后续规则重渲染不再漂移,同一回合计价时点恒定
+      const observedAtRef = useRef(null)
+      if (matched && observedAtRef.current === null) observedAtRef.current = Date.now()
+      const price = matched && prefs.costDisplay && pricingRules !== null && observedAtRef.current !== null
+        ? matchPrice(pricingRules, turnModelOf(matched), new Date(observedAtRef.current))
         : null
       // 0 元(全零价/全零桶)与价未命中同不渲染,无占位符
       const cost = matched && price ? turnCostAmountOf(matched, price) : null
@@ -2900,6 +2948,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 +2983,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))
@@ -3151,20 +3206,15 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
       const heatGenerationRef = useRef(0)
       const panelRef = useRef(null)
       const [heatDays, setHeatDays] = useState(null)
+      // 热力图重取信号(F23):手动刷新/回扫完成即 bump,独立请求随之重取
+      const [heatFetchTick, setHeatFetchTick] = useState(0)
+      const bumpHeatFetch = () => setHeatFetchTick((tick) => tick + 1)
       // 费用展示货币来源:价格规则异步首帧未回时空串即不带符号
-      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 +3233,8 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
             }
           }))
         })
-      }, [])
+        return () => { heatGenerationRef.current++ }
+      }, [pricingTick, heatFetchTick])
 
       const load = useCallback(async () => {
         const request = range === 'custom'
@@ -3201,10 +3252,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 +3265,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 +3277,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)
@@ -3260,6 +3313,9 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
 
       const refresh = () => {
         setError('')
+        // 手动刷新同触热力图重取(F23):重建后热力图口径随日桶更新,
+        // 独立请求此前只随挂载/价格变更重取,重建产物不进热力图
+        bumpHeatFetch()
         if (view === 'day') load()
         else refreshPoints()
       }
@@ -3290,9 +3346,18 @@ if (typeof window !== 'undefined' && window.__ModuleLoader__) {
               baseDone = value.done
               scheduleRefresh()
             }
+            wasRunning = true
             schedule(STATUS_POLL_FAST_MS)
+          } else if (wasRunning) {
+            // running→idle 转换补最终刷新(F23):reset 同步等回扫,响应时 running 已 false,
+            // done 增长分支永不触发——回扫产物的最终态靠此转换收尾(含热力图重取)
+            wasRunning = false
+            scheduleRefresh()
+            bumpHeatFetch()
+            schedule(STATUS_POLL_SLOW_MS)
           }
         }
+        let wasRunning = false
         tick()
         statusMachineRef.current = { restart: () => { baseDone = 0; schedule(STATUS_POLL_FAST_MS) } }
         return () => {

package/src/routes.js

@@ -73,20 +73,25 @@ const conditionSchema = z.union(
   CONDITION_KINDS.map((kind) => z.object({ kind: z.literal(kind), ...CONDITION_FIELD_SCHEMAS[kind] })),
 )
 
-const pricingRulesSchema = z.array(
-  z.object({
-    // 模型键强制两段式 vendor/model(段可通配),单段旧形态提交即拒
-    model: z.string().refine(isTwoSegmentModel),
-    unit: z.literal(UNIT_PER_MILLION).optional(),
-    currency: z.enum(CURRENCIES).nullable(),
-    price: z.object({
-      input: z.number().min(0),
-      output: z.number().min(0),
-      cacheRead: z.number().min(0),
-      cacheWrite: z.number().min(0),
-    }),
-    conditions: z.array(conditionSchema),
+const pricingRuleShape = z.object({
+  // 模型键强制两段式 vendor/model(段可通配),单段旧形态提交即拒
+  model: z.string().refine(isTwoSegmentModel),
+  unit: z.literal(UNIT_PER_MILLION).optional(),
+  currency: z.enum(CURRENCIES).nullable(),
+  price: z.object({
+    input: z.number().min(0),
+    output: z.number().min(0),
+    cacheRead: z.number().min(0),
+    cacheWrite: z.number().min(0),
   }),
+  conditions: z.array(conditionSchema),
+})
+
+const pricingRulesSchema = z.array(pricingRuleShape).refine(
+  // 表级单币约束(F15):定价聚合按数值直接相加,混币相加无意义;
+  // 非空币种全表必须同一种(null 视为未指定,不参与币种一致对账)
+  (rules) => new Set(rules.map((rule) => rule.currency).filter((c) => c !== null)).size <= 1,
+  { message: '定价表必须单币种:非空 currency 全表一致' },
 )
 
 // 桶串形态锚定 + 本地时区分量回读,回滚形(13 月/25 时/60 分)当场拒绝,

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'
@@ -36,6 +37,7 @@ const TABLE_BUCKETS = 'buckets'
 const MISSING_RECORD_PATTERN = /no record .* to update/
 const MINUTE_KEY_PREFIX = `${GRANULARITY_MINUTE}|`
 const HOUR_KEY_PREFIX = `${GRANULARITY_HOURLY}|`
+const DAILY_KEY_PREFIX = `${GRANULARITY_DAILY}|`
 
 // 保留值归一:非法回落默认,超出上限截到上限;0(禁用)合法保留
 export function clampMinuteRetentionDays(days) {
@@ -69,6 +71,16 @@ export const GRANULARITIES = [
   [GRANULARITY_MINUTE, minuteKey],
 ]
 
+// 档保留资格(F14):样本桶 ≥ 该档 cutoff 即可写入。日档无上限恒写;
+// 小时档固定留存;分钟档走可配置天数(0 = 分钟档关闭,一律不写)
+function withinRetention(g, bucket, nowMs, minuteRetentionDays) {
+  if (g === GRANULARITY_DAILY) return true
+  if (g === GRANULARITY_HOURLY) return bucket >= hourKey(nowMs - HOUR_RETENTION_DAYS * DAY_MS)
+  const retention = clampMinuteRetentionDays(minuteRetentionDays)
+  if (retention === 0) return false
+  return bucket >= minuteKey(nowMs - retention * DAY_MS)
+}
+
 // vendor 段推导与定价匹配同源:首个 / 前段,无 / 或首位斜杠归 default
 export function providerOf(modelRef) {
   return splitRequestSegments(modelRef)[0]
@@ -217,6 +229,7 @@ export class UsageStore {
   }
 
   async initialize(facility) {
+    // 占用不等于无主:开域失败只降级,不关闭其他实例仍在写入的句柄。
     const domain = await facility.open(usageStatsDomain)
     this.domain = domain
     this.table = domain.table(TABLE_BUCKETS)
@@ -257,7 +270,9 @@ export class UsageStore {
     return this.readCursor() ?? {}
   }
 
-  // 同步合并进 pending,不等待持久化;崩溃丢失窗口 = flush 周期
+  // 同步合并进 pending,不等待持久化;崩溃丢失窗口 = flush 周期。
+  // 入队按档保留资格过滤(F14):超出该档留存期的样本不写入——
+  // 写后即被 prune 删除是纯 IO 浪费;回扫历史导入经同一通道自动受控
   async record(sample) {
     await this.ready
     this.requireTable()
@@ -266,6 +281,7 @@ export class UsageStore {
     const provider = sample.turn ? PROVIDER_UNSET : providerOf(model)
     const delta = deltaOf(sample, nowMs)
     for (const [g, bucketOf] of GRANULARITIES) {
+      if (!withinRetention(g, bucketOf(sample.time), nowMs, this.retentionDays())) continue
       const bucket = bucketOf(sample.time)
       const entry = { ...delta, bucket, provider, model }
       const existing = this.pending.get(rowKey(g, bucket, provider, model))
@@ -308,6 +324,9 @@ export class UsageStore {
       if (outcome.status !== 'rejected') return []
       const key = [...batch.keys()][index]
       const [entryKey, entry] = [key, batch.get(key)]
+      // 重排前复核保留资格(F14):失败重试期间样本可能已滑出留存期,不再重排
+      const g = key.startsWith(DAILY_KEY_PREFIX) ? GRANULARITY_DAILY : key.startsWith(HOUR_KEY_PREFIX) ? GRANULARITY_HOURLY : GRANULARITY_MINUTE
+      if (!withinRetention(g, entry.bucket, this.now(), this.retentionDays())) return []
       const existing = this.pending.get(entryKey)
       this.pending.set(entryKey, existing ? addDelta(existing, entry) : entry)
       return [outcome.reason]
@@ -480,13 +499,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
 }