@mzzsfy/dsh-usage-dash 0.5.0 → 0.7.0

package/test/client.test.mjs

@@ -67,6 +67,9 @@ const {
   matchPrice,
   maxSlotsFor,
   minuteTickLabel,
+  modelIoPercentText,
+  hasTipContent,
+  tipModelEntries,
   modelSegmentLabel,
   modelSpeedText,
   modelNameOf,
@@ -75,6 +78,7 @@ const {
   otherDetailItems,
   parseEnvelope,
   partitionGroupOf,
+  pointerAt,
   providerOf,
   rateAxisTicks,
   removeRulesAt,
@@ -82,6 +86,11 @@ const {
   resolveDayRange,
   resolveHourRange,
   resolveMinuteRange,
+  resolveHourCustomRange,
+  resolveMinuteCustomRange,
+  resolvePointQuery,
+  formatDateTimeInput,
+  parseLocalDateTime,
   shortDay,
   smoothPath,
   tipPlace,
@@ -177,6 +186,112 @@ test('pointStats 缓存命中须视图与挡位双匹配', () => {
   assert.equal(pointStatsMatches(null, 'hour', '24h'), false)
 })
 
+// —— 时/分自定义时间范围:归一语义与预设挡一致(小时 floor 整点桶,分钟 from 对齐 10 分钟桶、to 保原分钟) ——
+
+const CUSTOM_FROM = '2026-03-14T09:45'
+const CUSTOM_TO = '2026-03-15T14:10'
+
+test('hour 自定义范围两端 floor 到所在小时桶', () => {
+  // Given datetime 输入含分钟偏移 When 解析 Then 两端均取所在小时桶起点(闭区间)
+  assert.deepEqual(resolveHourCustomRange(CUSTOM_FROM, CUSTOM_TO), { from: '2026-03-14T09', to: '2026-03-15T14' })
+  assert.deepEqual(resolveHourCustomRange('2026-03-14T09:00', '2026-03-15T14:59'), { from: '2026-03-14T09', to: '2026-03-15T14' })
+})
+
+test('hour 自定义跨度超保留期钳起点,临界窗经 floor 与原窗输出等价', () => {
+  // Given 跨度 16 天 When 解析 Then 起点钳到终点前 15 天整点;15 天余零头的窗钳后 floor 输出不变
+  assert.deepEqual(
+    resolveHourCustomRange('2026-02-27T00:00', '2026-03-15T14:10'),
+    { from: '2026-02-28T14', to: '2026-03-15T14' },
+  )
+  assert.deepEqual(
+    resolveHourCustomRange('2026-02-28T14:00', '2026-03-15T14:10'),
+    { from: '2026-02-28T14', to: '2026-03-15T14' },
+  )
+})
+
+test('hour 自定义非法输入返回 null', () => {
+  // Given 空值/垃圾串/from 晚于 to When 解析 Then 恒 null,不发请求
+  assert.equal(resolveHourCustomRange('', CUSTOM_TO), null)
+  assert.equal(resolveHourCustomRange(CUSTOM_FROM, ''), null)
+  assert.equal(resolveHourCustomRange('junk', CUSTOM_TO), null)
+  assert.equal(resolveHourCustomRange('2026-13-40T09:00', CUSTOM_TO), null)
+  assert.equal(resolveHourCustomRange(CUSTOM_TO, CUSTOM_FROM), null)
+})
+
+test('parseLocalDateTime 拒绝数字分量回卷的日历非法值', () => {
+  // Given 超界分量(13 月/2 月 30 日/25 时)在 Date 构造下静默回卷 When 解析 Then 逐分量回读拦截为 null
+  assert.equal(parseLocalDateTime('2026-13-01T00:00'), null)
+  assert.equal(parseLocalDateTime('2026-02-30T10:00'), null)
+  assert.equal(parseLocalDateTime('2026-03-14T25:00'), null)
+  assert.deepEqual(parseLocalDateTime('2026-03-14T09:45'), new Date(2026, 2, 14, 9, 45))
+})
+
+test('hour 自定义拒绝回卷后仍保序的非法日历输入', () => {
+  // Given 13 月回卷为次年 1 月且整体仍早于 to When 解析 Then 恒 null,不静默改写查询时段
+  assert.equal(resolveHourCustomRange('2026-13-01T00:00', '2027-06-01T00:00'), null)
+})
+
+test('minute 自定义 from 对齐 10 分钟桶,to 保持原始分钟', () => {
+  // Given from 含非对齐分钟 When 解析 Then from floor 到桶边界,to 原值保留(闭区间上界)
+  assert.deepEqual(resolveMinuteCustomRange(CUSTOM_FROM, CUSTOM_TO), { from: '2026-03-14T09:40', to: '2026-03-15T14:10' })
+  assert.deepEqual(resolveMinuteCustomRange('2026-03-14T09:40', '2026-03-15T14:17'), { from: '2026-03-14T09:40', to: '2026-03-15T14:17' })
+})
+
+test('minute 自定义跨度超保留期钳起点', () => {
+  // Given 跨度 8 天 When 解析 Then 起点钳到终点前 7 天的 10 分钟桶边界
+  assert.deepEqual(
+    resolveMinuteCustomRange('2026-03-06T00:00', '2026-03-15T14:10'),
+    { from: '2026-03-08T14:10', to: '2026-03-15T14:10' },
+  )
+})
+
+test('minute 自定义非法输入返回 null', () => {
+  assert.equal(resolveMinuteCustomRange('', CUSTOM_TO), null)
+  assert.equal(resolveMinuteCustomRange('junk', CUSTOM_TO), null)
+  assert.equal(resolveMinuteCustomRange(CUSTOM_TO, CUSTOM_FROM), null)
+})
+
+test('resolvePointQuery 预设挡返回挡位键与滚动窗口请求', () => {
+  // Given 时/分预设挡 When 解析查询 Then 键为挡位 id,请求与既有 resolve 同构
+  const hour = resolvePointQuery('hour', '24h', '', '', NOW)
+  assert.equal(hour.key, '24h')
+  assert.deepEqual(hour.request, resolveHourRange('24h', NOW))
+  const minute = resolvePointQuery('minute', '3h', '', '', NOW)
+  assert.equal(minute.key, '3h')
+  assert.deepEqual(minute.request, resolveMinuteRange('3h', NOW))
+})
+
+test('resolvePointQuery 自定义挡键含归一范围且随范围变化', () => {
+  // Given 同视图同挡不同范围 When 解析查询 Then 键互异;同范围键稳定(缓存可命中)
+  const first = resolvePointQuery('hour', 'custom', CUSTOM_FROM, CUSTOM_TO, NOW)
+  assert.deepEqual(first.request, { from: '2026-03-14T09', to: '2026-03-15T14' })
+  assert.equal(first.key, 'custom:2026-03-14T09:2026-03-15T14')
+  const again = resolvePointQuery('hour', 'custom', CUSTOM_FROM, CUSTOM_TO, NOW)
+  assert.equal(again.key, first.key)
+  const shifted = resolvePointQuery('hour', 'custom', '2026-03-14T10:45', CUSTOM_TO, NOW)
+  assert.notEqual(shifted.key, first.key)
+  const minute = resolvePointQuery('minute', 'custom', CUSTOM_FROM, CUSTOM_TO, NOW)
+  assert.deepEqual(minute.request, { from: '2026-03-14T09:40', to: '2026-03-15T14:10' })
+  assert.notEqual(minute.key, first.key)
+})
+
+test('resolvePointQuery 自定义输入不完整返回 null', () => {
+  // Given 任一端为空 When 解析查询 Then null,面板不发请求不误清缓存
+  assert.equal(resolvePointQuery('hour', 'custom', '', CUSTOM_TO, NOW), null)
+  assert.equal(resolvePointQuery('minute', 'custom', CUSTOM_FROM, '', NOW), null)
+})
+
+test('maxSlotsFor custom 挡取保留期桶数上限', () => {
+  // Given 自定义挡受保留期钳制 When 取渲染上限 Then 小时为 15 天小时桶数,分钟为 7 天 10 分钟桶数
+  assert.equal(maxSlotsFor('hour', 'custom'), 15 * 24 + 1)
+  assert.equal(maxSlotsFor('minute', 'custom'), (7 * 24 * 60) / 10 + 1)
+})
+
+test('formatDateTimeInput 产出 datetime-local 分钟粒度值', () => {
+  assert.equal(formatDateTimeInput(new Date(2026, 2, 15, 9, 5)), '2026-03-15T09:05')
+  assert.equal(formatDateTimeInput(NOW), '2026-03-15T14:30')
+})
+
 test('每视图渲染上限等于闭区间桶数', () => {
   assert.equal(maxSlotsFor('day', '90'), DAY_MAX_SLOTS)
   assert.equal(maxSlotsFor('hour', '24h'), 25)
@@ -476,50 +591,57 @@ test('heatLevel 零值为空档其余按峰值四分位', () => {
   assert.equal(heatLevel(1, 1), 5)
 })
 
-const TIP_ANCHOR = { left: 100, top: 100, right: 140, bottom: 114 }
+const TIP_ANCHOR = { x: 100, y: 100 }
 const TIP_SIZE = { width: 80, height: 40 }
 const TIP_BOUNDS = { left: 0, top: 0, right: 800, bottom: 600 }
 
-test('tipPlace 小锚点默认翻上方水平居中', () => {
-  assert.deepEqual(tipPlace(TIP_ANCHOR, TIP_SIZE, TIP_BOUNDS), { left: 80, top: 52 })
+test('tipPlace 指针右下空位放右下', () => {
+  assert.deepEqual(tipPlace(TIP_ANCHOR, TIP_SIZE, TIP_BOUNDS), { left: 108, top: 108 })
+})
+
+test('tipPlace 右侧越界翻左侧', () => {
+  assert.deepEqual(tipPlace({ x: 730, y: 100 }, TIP_SIZE, TIP_BOUNDS), { left: 642, top: 108 })
+})
+
+test('tipPlace 下方越界翻上方', () => {
+  assert.deepEqual(tipPlace({ x: 100, y: 570 }, TIP_SIZE, TIP_BOUNDS), { left: 108, top: 522 })
 })
 
-test('tipPlace 锚定区装得下提示框贴内顶', () => {
-  const anchor = { left: 100, top: 100, right: 240, bottom: 460 }
-  assert.deepEqual(tipPlace(anchor, TIP_SIZE, TIP_BOUNDS), { left: 130, top: 108 })
+test('tipPlace 右下均越界双翻', () => {
+  assert.deepEqual(tipPlace({ x: 730, y: 570 }, TIP_SIZE, TIP_BOUNDS), { left: 642, top: 522 })
 })
 
-test('tipPlace 上方不足翻下方', () => {
-  const anchor = { left: 100, top: 20, right: 140, bottom: 60 }
-  assert.equal(tipPlace(anchor, TIP_SIZE, TIP_BOUNDS).top, 68)
+test('tipPlace 双翻后仍越界钳进边界', () => {
+  assert.deepEqual(tipPlace({ x: 798, y: 598 }, TIP_SIZE, TIP_BOUNDS), { left: 710, top: 550 })
 })
 
-test('tipPlace 候选边界等号归属', () => {
-  assert.deepEqual(tipPlace({ left: 100, top: 100, right: 240, bottom: 148 }, TIP_SIZE, TIP_BOUNDS), { left: 130, top: 108 })
-  assert.equal(tipPlace({ left: 100, top: 56, right: 140, bottom: 96 }, TIP_SIZE, TIP_BOUNDS).top, 8)
-  assert.equal(tipPlace({ left: 100, top: 8, right: 140, bottom: 48 }, TIP_SIZE, { left: 0, top: 0, right: 800, bottom: 104 }).top, 56)
+test('tipPlace 恰贴右缘等号归属放右侧', () => {
+  assert.deepEqual(tipPlace({ x: 704, y: 100 }, TIP_SIZE, TIP_BOUNDS), { left: 712, top: 108 })
 })
 
-test('tipPlace 下方放不下翻转上方', () => {
-  const anchor = { ...TIP_ANCHOR, top: 540, bottom: 580 }
-  assert.equal(tipPlace(anchor, TIP_SIZE, TIP_BOUNDS).top, 492)
+test('tipPlace 左上角指针放右下不翻转', () => {
+  assert.deepEqual(tipPlace({ x: 2, y: 2 }, TIP_SIZE, TIP_BOUNDS), { left: 10, top: 10 })
 })
 
-test('tipPlace 两侧均放不下钳到边界顶', () => {
-  const bounds = { left: 0, top: 0, right: 800, bottom: 50 }
-  const anchor = { left: 100, top: 20, right: 140, bottom: 50 }
-  assert.equal(tipPlace(anchor, TIP_SIZE, bounds).top, 8)
+test('tipPlace 提示框宽于边界钳贴左缘', () => {
+  assert.equal(tipPlace({ x: 400, y: 100 }, { width: 900, height: 40 }, TIP_BOUNDS).left, 8)
 })
 
-test('tipPlace 水平越界钳到边界左缘', () => {
-  const anchor = { left: 2, top: 100, right: 10, bottom: 114 }
-  assert.equal(tipPlace(anchor, TIP_SIZE, TIP_BOUNDS).left, 8)
+test('pointerAt 指针事件取指针坐标', () => {
+  assert.deepEqual(pointerAt({ clientX: 12, clientY: 34 }), { x: 12, y: 34 })
 })
 
-test('tipPlace 零尺寸或全零锚定矩形返回隐藏', () => {
+test('pointerAt 焦点事件回退目标矩形中心', () => {
+  const event = {
+    currentTarget: { getBoundingClientRect: () => ({ left: 10, top: 20, right: 30, bottom: 60 }) },
+  }
+  assert.deepEqual(pointerAt(event), { x: 20, y: 40 })
+})
+
+test('tipPlace 零尺寸或非法锚点返回隐藏', () => {
   assert.equal(tipPlace(TIP_ANCHOR, { width: 0, height: 0 }, TIP_BOUNDS), null)
-  assert.equal(tipPlace({ left: 0, top: 0, right: 0, bottom: 0 }, TIP_SIZE, TIP_BOUNDS), null)
   assert.equal(tipPlace(null, TIP_SIZE, TIP_BOUNDS), null)
+  assert.equal(tipPlace({ x: Number.NaN, y: 100 }, TIP_SIZE, TIP_BOUNDS), null)
 })
 
 // —— S8 命中率曲线 ——
@@ -691,6 +813,56 @@ test('donutSegments 全零 total 回落下限防除零', () => {
   assert.equal(segments[0].percent, 0)
 })
 
+test('groupStats 哨兵折叠四桶求和,top 模型四桶透传', () => {
+  // Given 超 top 上限模型条目带四桶 When 分组 Then 哨兵四桶为 rest 求和,top 条目原字段保留
+  const stats = {
+    models: [
+      { model: 'p/m1', tokens: 500, inputTokens: 300, outputTokens: 200, cacheReadTokens: 0, cacheWriteTokens: 0 },
+      { model: 'p/m2', tokens: 400, inputTokens: 100, outputTokens: 300, cacheReadTokens: 0, cacheWriteTokens: 0 },
+      { model: 'p/m3', tokens: 300, inputTokens: 0, outputTokens: 100, cacheReadTokens: 150, cacheWriteTokens: 50 },
+      { model: 'p/m4', tokens: 200, inputTokens: 80, outputTokens: 120, cacheReadTokens: 0, cacheWriteTokens: 0 },
+      { model: 'p/m5', tokens: 100, inputTokens: 60, outputTokens: 40, cacheReadTokens: 0, cacheWriteTokens: 0 },
+      { model: 'p/m6', tokens: 50, inputTokens: 10, outputTokens: 30, cacheReadTokens: 5, cacheWriteTokens: 5 },
+    ],
+    daily: [],
+  }
+  const grouped = groupStats(stats)
+  assert.equal(grouped.models[0].inputTokens, 300)
+  assert.equal(grouped.models[0].outputTokens, 200)
+  assert.deepEqual(grouped.models[5], {
+    model: OTHER_MODEL,
+    tokens: 50,
+    inputTokens: 10,
+    outputTokens: 30,
+    cacheReadTokens: 5,
+    cacheWriteTokens: 5,
+    items: [stats.models[5]],
+  })
+})
+
+test('groupStats 哨兵费用同源:无 cost 输入不挂 cost,有 cost 求和', () => {
+  // Given rest 条目无 cost When 折叠 Then 哨兵无 cost 字段;Given rest 带 cost When 折叠 Then 哨兵求和
+  const bare = groupStats({ models: [
+    { model: 'p/m1', tokens: 500 },
+    { model: 'p/m2', tokens: 400 },
+    { model: 'p/m3', tokens: 300 },
+    { model: 'p/m4', tokens: 200 },
+    { model: 'p/m5', tokens: 100 },
+    { model: 'p/m6', tokens: 50 },
+  ], daily: [] })
+  assert.equal('cost' in bare.models[5], false)
+  const priced = groupStats({ models: [
+    { model: 'p/m1', tokens: 500, cost: 1 },
+    { model: 'p/m2', tokens: 400, cost: 2 },
+    { model: 'p/m3', tokens: 300, cost: undefined },
+    { model: 'p/m4', tokens: 200, cost: 4 },
+    { model: 'p/m5', tokens: 100, cost: 8 },
+    { model: 'p/m6', tokens: 50, cost: 16 },
+    { model: 'p/m7', tokens: 25, cost: 32 },
+  ], daily: [] })
+  assert.equal(priced.models[5].cost, 16 + 32)
+})
+
 test('groupStats 哨兵保留其他模型明细供展开与提示', () => {
   const stats = {
     models: [
@@ -705,6 +877,8 @@ test('groupStats 哨兵保留其他模型明细供展开与提示', () => {
   }
   const grouped = groupStats(stats)
   assert.deepEqual(grouped.models[5].items, [{ model: 'p/m6', tokens: 50 }])
+  // Given 旧形条目无四桶 When 折叠 Then 哨兵不合成零值四桶,与 top 条目降级形态一致
+  assert.equal('inputTokens' in grouped.models[5], false)
 })
 
 test('groupStats 逐日保留其他明细映射供 tooltip', () => {
@@ -737,6 +911,45 @@ test('模型速度文本:官方吞吐口径格式化,无速度为空串', () =>
   assert.equal(modelSpeedText(undefined), '')
 })
 
+test('模型输入输出占比构成:缓存/输入/输出 三段各占该模型 token 总量', () => {
+  // Given 四桶齐备的模型条目 When 格式化 Then 三段占比相对 tokens 总量,缓存=读+写,合计 100%,顺序缓存/输入/输出
+  const zhT = createTranslator(MESSAGES_ZH)
+  const enT = createTranslator(MESSAGES_EN)
+  const item = { tokens: 1000, inputTokens: 31, cacheReadTokens: 954, cacheWriteTokens: 10, outputTokens: 5 }
+  assert.equal(modelIoPercentText(item, zhT), '缓存 96.4% · 输入 3.1% · 输出 0.5%')
+  assert.equal(modelIoPercentText(item, enT), 'Cache 96.4% · Input 3.1% · Output 0.5%')
+})
+
+test('趋势 tooltip 模型行:仅含可见且当前时段有用量的模型', () => {
+  // Given 槽内 byModel 含零值与非零值,OTHER 明细含零值与无序多元素 When 取行数据 Then 主行与子行均过滤零用量,子行按 tokens 降序,OTHER 不可见时子行为空
+  const hoverSlot = {
+    total: 300,
+    byModel: { 'p/a': 200, 'p/b': 0, [OTHER_MODEL]: 100 },
+    otherByModel: { 'p/y': 0, 'p/x': 20, 'p/z': 50 },
+  }
+  const visible = new Set(['p/a', 'p/b', OTHER_MODEL])
+  const rows = tipModelEntries(hoverSlot, visible)
+  assert.deepEqual(rows.main, [{ model: 'p/a', tokens: 200 }, { model: OTHER_MODEL, tokens: 100 }])
+  assert.deepEqual(rows.other, [['p/z', 50], ['p/x', 20]])
+  const hiddenOther = tipModelEntries(hoverSlot, new Set(['p/a']))
+  assert.deepEqual(hiddenOther.main, [{ model: 'p/a', tokens: 200 }])
+  assert.deepEqual(hiddenOther.other, [])
+})
+
+test('趋势 tooltip 内容门:仅 total>0 的槽渲染', () => {
+  // Given 全零槽/常规槽 When 判定 Then 全零槽无内容,常规槽有内容,null 槽无内容
+  assert.equal(hasTipContent(null), false)
+  assert.equal(hasTipContent({ total: 0 }), false)
+  assert.equal(hasTipContent({ total: 5 }), true)
+})
+
+test('模型输入输出占比构成:缺四桶或零总量为空串', () => {
+  const zhT = createTranslator(MESSAGES_ZH)
+  assert.equal(modelIoPercentText({ tokens: 100 }, zhT), '')
+  assert.equal(modelIoPercentText(undefined, zhT), '')
+  assert.equal(modelIoPercentText({ tokens: 0, inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0 }, zhT), '')
+})
+
 test('模型首字文本:语言中立短时长,无 ttft 为空串', () => {
   assert.equal(modelTtftText(200), 'TTFT 0.2s')
   assert.equal(modelTtftText(162000), 'TTFT 2m42s')

package/test/query.test.mjs

@@ -117,8 +117,26 @@ test('D 粒度聚合总量排序与占比正确', () => {
   assert.equal(out.topModel, 'deepseek/deepseek-chat')
   assert.equal(out.topProvider, 'deepseek')
   assert.deepEqual(out.models, [
-    { model: 'deepseek/deepseek-chat', provider: 'deepseek', tokens: 350, percent: (350 / 410) * 100 },
-    { model: 'deepseek-chat', provider: 'default', tokens: 60, percent: (60 / 410) * 100 },
+    {
+      model: 'deepseek/deepseek-chat',
+      provider: 'deepseek',
+      tokens: 350,
+      percent: (350 / 410) * 100,
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheReadTokens: 200,
+      cacheWriteTokens: 0,
+    },
+    {
+      model: 'deepseek-chat',
+      provider: 'default',
+      tokens: 60,
+      percent: (60 / 410) * 100,
+      inputTokens: 10,
+      outputTokens: 20,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 30,
+    },
   ])
   assert.deepEqual(out.providers, [
     { provider: 'deepseek', tokens: 350, percent: (350 / 410) * 100 },
@@ -351,6 +369,38 @@ test('ttft 模型级聚合:加权平均,无 ttft 行不参与,无数据不挂字
   assert.equal('ttft' in m2, false)
 })
 
+test('模型级四桶聚合:models 条目带输入输出与缓存拆分,按该模型行累加', () => {
+  // Given 两模型多行四桶用量 When D 粒度聚合 Then models 每项四桶为该模型行累加,排序与占比不变
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', inputTokens: 100, outputTokens: 50, cacheReadTokens: 200, cacheWriteTokens: 10 }),
+    makeRow({ bucket: '2020-01-02', model: 'm1', provider: 'p1', inputTokens: 30, outputTokens: 70 }),
+    makeRow({ bucket: '2020-01-01', model: 'm2', provider: 'p2', inputTokens: 5, outputTokens: 25, cacheWriteTokens: 8 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-02')
+  assert.deepEqual(out.models, [
+    {
+      model: 'm1',
+      provider: 'p1',
+      tokens: 460,
+      percent: (460 / 498) * 100,
+      inputTokens: 130,
+      outputTokens: 120,
+      cacheReadTokens: 200,
+      cacheWriteTokens: 10,
+    },
+    {
+      model: 'm2',
+      provider: 'p2',
+      tokens: 38,
+      percent: (38 / 498) * 100,
+      inputTokens: 5,
+      outputTokens: 25,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 8,
+    },
+  ])
+})
+
 test('槽级 ttft 聚合:同槽配对,无 ttft 槽不挂字段,attachCosts 保留', () => {
   const rows = [
     makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', outputTokens: 20, ttftMs: 2000, ttftSteps: 1 }),
@@ -373,7 +423,7 @@ test('attachCosts H 槽按桶起点计价并归集 totals 与 models', () => {
   assert.equal(out.daily[1].cost, 2)
   assert.equal(out.cost, 2)
   assert.equal(out.unpriced, 0)
-  assert.deepEqual(out.models, [{ model: 'm1', provider: 'p1', tokens: 1500000, percent: 100, cost: 2 }])
+  assert.deepEqual(out.models, [{ model: 'm1', provider: 'p1', tokens: 1500000, inputTokens: 1000000, outputTokens: 500000, cacheReadTokens: 0, cacheWriteTokens: 0, percent: 100, cost: 2 }])
   assert.equal(out.from, '2020-01-01T00')
   assert.equal(out.tokens, 1500000)
   // 纯函数:入参 result 不被修改

package/test/turn-tail.test.mjs

@@ -151,6 +151,22 @@ test('反查:容器换引用(快照更替)后新节点可见', () => {
   assert.equal(turnTokenUsageOfMessage(oldNodes, 'm-1'), oldUsage)
 })
 
+test('反查:仓库身份恒定而节点集更替时新增回合可见', () => {
+  // Given 官方 chat 仓库语义:store 实例身份跨回合恒定,values() 返回的节点集数组随 upsert 换新引用
+  const usage1 = { uncachedInputTokens: 1, outputTokens: 1, totalTokens: 2 }
+  const usage2 = { uncachedInputTokens: 7, outputTokens: 7, totalTokens: 14 }
+  let snapshot = [tailNode('m-1', usage1)]
+  const store = { values: () => snapshot }
+  assert.equal(turnUsageSourceOfMessage(store, 'm-1'), usage1)
+  // When 第二回合 turn-tail 节点入库(同一 store,节点集数组换引用)
+  snapshot = [...snapshot, tailNode('m-2', usage2)]
+  // Then 新回合反查命中,不依赖页面刷新重建索引
+  assert.equal(turnUsageSourceOfMessage(store, 'm-2'), usage2)
+  assert.equal(turnTokenUsageOfMessage(store, 'm-2'), usage2)
+  // 旧回合反查不受重建影响
+  assert.equal(turnUsageSourceOfMessage(store, 'm-1'), usage1)
+})
+
 test('计价模型键:双全拼两段,仅 model 用裸名,双缺回退全通配键', () => {
   assert.equal(turnModelOf({ routes: [{ provider: 'p', model: 'm' }] }), 'p/m')
   assert.equal(turnModelOf({ routes: [{ model: 'm' }] }), 'm')