@mzzsfy/dsh-usage-dash 0.1.0 → 0.3.0

package/test/pricing-parity.test.mjs

@@ -1,34 +1,28 @@
 // 双实现同源 parity 测试:client.js 顶层定价镜像函数与宿主 src/pricing.js 同输入同输出
 // 向量表驱动:同一批向量喂双侧,deepEqual 双侧结果并对期望值断言
-// client.js 为非模块 script(bundle 求值形态,禁 import/export),整源求值后按顶层声明名收集
+// client.js 为经典 script bundle(禁 import/export),整文件 IIFE 书挡;经 client-eval 剥壳后整源求值,按顶层声明名收集
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
+import { CLIENT_BODY, DECLARATION_NAMES } from './client-eval.mjs'
 
 import {
   matchPrice as hostMatchPrice,
   costOf as hostCostOf,
   conditionMatches as hostConditionMatches,
+  isTwoSegmentModel as hostIsTwoSegmentModel,
   UNIT_PER_MILLION as hostUnitPerMillion,
   CURRENCIES as hostCurrencies,
   CONDITION_KINDS as hostConditionKinds,
   TOKENS_PER_MILLION as hostTokensPerMillion,
 } from '../src/pricing.js'
 
-const CLIENT_SOURCE = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'client.js'), 'utf8')
-const DECLARATION_NAMES = [
-  ...new Set(
-    [...CLIENT_SOURCE.matchAll(/^(?:const|function|let) ([A-Za-z_$][\w$]*)/gm)].map((match) => match[1])
-  ),
-]
-const core = new Function(`${CLIENT_SOURCE}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
+const core = new Function(`${CLIENT_BODY}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
 
 const {
   matchPrice: clientMatchPrice,
   costOf: clientCostOf,
   conditionMatches: clientConditionMatches,
+  isTwoSegmentModel: clientIsTwoSegmentModel,
   UNIT_PER_MILLION: clientUnitPerMillion,
   CURRENCIES: clientCurrencies,
   CONDITION_KINDS: clientConditionKinds,
@@ -83,67 +77,112 @@ const MATCH_SUNDAY_1000 = [2026, 2, 15, 10, 0]
 
 const MATCH_VECTORS = [
   {
-    name: '精确命中按数组序取首个',
-    rules: [ruleOf('a', 1), ruleOf('b', 2)], model: 'b', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+    name: '全名精确命中按数组序取首个',
+    rules: [ruleOf('x/a', 1), ruleOf('x/b', 2)], model: 'x/b', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '同全名多条取数组序第一条',
+    rules: [ruleOf('x/a', 1), ruleOf('x/a', 3)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '模型名通配跨供应商命中',
+    rules: [ruleOf('*/a', 5)], model: 'zzz/a', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+  },
+  {
+    name: '供应商通配命中同供应商模型',
+    rules: [ruleOf('x/*', 5)], model: 'x/zzz', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+  },
+  {
+    name: '无精确回落全通配',
+    rules: [ruleOf('*/*', 5)], model: 'zzz/yyy', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+  },
+  {
+    name: '全名精确优先于全通配',
+    rules: [ruleOf('*/*', 5), ruleOf('x/a', 1)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '匹配链:模型名通配优先于供应商通配',
+    rules: [ruleOf('x/*', 3), ruleOf('*/a', 2)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '匹配链:供应商通配优先于全通配',
+    rules: [ruleOf('*/*', 4), ruleOf('x/*', 3)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(3),
   },
   {
-    name: '同 model 多条取数组序第一条',
-    rules: [ruleOf('a', 1), ruleOf('a', 3)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    name: '模型名段允许含斜杠',
+    rules: [ruleOf('x/*', 1)], model: 'x/deepseek/deepseek-chat', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
-    name: '无精确回落通配',
-    rules: [ruleOf('*', 5)], model: 'zzz', date: MATCH_SUNDAY_1000, expected: priceOf(5),
+    name: '请求裸名归 default 供应商',
+    rules: [ruleOf('default/a', 1), ruleOf('*/a', 2)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
-    name: '精确优先于通配',
-    rules: [ruleOf('*', 5), ruleOf('a', 1)], model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    name: '请求首位斜杠不拆段归 default 供应商',
+    rules: [ruleOf('default//x', 1), ruleOf('*/x', 2)], model: '/x', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+  },
+  {
+    name: '单段旧形态规则失效',
+    rules: [ruleOf('*', 5), ruleOf('a', 1)], model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: '供应商段不同不命中',
+    rules: [ruleOf('x/*', 1)], model: 'y/a', date: MATCH_SUNDAY_1000, expected: null,
+  },
+  {
+    name: '模型段不同不命中',
+    rules: [ruleOf('*/a', 1)], model: 'x/b', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: '多条件 AND 全过命中',
-    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [0] }, { kind: 'dailyWindow', from: '00:00', to: '23:59' }])],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [0] }, { kind: 'dailyWindow', from: '00:00', to: '23:59' }])],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
     name: '一条件不过跳至下一条规则',
-    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [1] }]), ruleOf('a', 2, [])],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [1] }]), ruleOf('x/a', 2, [])],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(2),
+  },
+  {
+    name: '高档条件不过逐层落低档',
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [1] }]), ruleOf('*/a', 5)],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(5),
   },
   {
     name: '缺 conditions 形状残缺跳过',
-    rules: [{ model: 'a', currency: '¥', price: priceOf(1) }],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [{ model: 'x/a', currency: '¥', price: priceOf(1) }],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: '缺 price 形状残缺跳过',
-    rules: [{ model: 'a', currency: '¥', conditions: [] }],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [{ model: 'x/a', currency: '¥', conditions: [] }],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: 'unit 非 perMillion 跳过',
-    rules: [{ ...ruleOf('a', 1), unit: 'perThousand' }],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [{ ...ruleOf('x/a', 1), unit: 'perThousand' }],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: 'unit 缺省视为 perMillion 命中',
-    rules: [ruleOf('a', 1)],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
+    rules: [ruleOf('x/a', 1)],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: priceOf(1),
   },
   {
     name: 'rules 非数组为 null',
-    rules: 'nope', model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: 'nope', model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: 'model 非字符串为 null',
-    rules: [ruleOf('a', 1)], model: 7, date: MATCH_SUNDAY_1000, expected: null,
+    rules: [ruleOf('x/a', 1)], model: 7, date: MATCH_SUNDAY_1000, expected: null,
   },
   {
     name: '非法时间戳为 null',
-    rules: [ruleOf('a', 1)], model: 'a', date: null, expected: null,
+    rules: [ruleOf('x/a', 1)], model: 'x/a', date: null, expected: null,
   },
   {
     name: '条件不满足且无通配为 null',
-    rules: [ruleOf('a', 1, [{ kind: 'weekdays', days: [1] }])],
-    model: 'a', date: MATCH_SUNDAY_1000, expected: null,
+    rules: [ruleOf('x/a', 1, [{ kind: 'weekdays', days: [1] }])],
+    model: 'x/a', date: MATCH_SUNDAY_1000, expected: null,
   },
 ]
 
@@ -221,6 +260,30 @@ test(`matchPrice 双侧一致(${MATCH_VECTORS.length} 向量)`, () => {
   }
 })
 
+const SEGMENT_VECTORS = [
+  { name: '两段合法', model: 'a/b', expected: true },
+  { name: '通配段合法', model: '*/*', expected: true },
+  { name: '多级模型名合法', model: 'a/b/c', expected: true },
+  { name: '单段非法', model: 'a', expected: false },
+  { name: '通配单段非法', model: '*', expected: false },
+  { name: '首位斜杠非法', model: '/b', expected: false },
+  { name: '空串非法', model: '', expected: false },
+  { name: '模型段空非法', model: 'a/', expected: false },
+  { name: '段含前导空白非法', model: ' /b', expected: false },
+  { name: '段含尾随空白非法', model: 'a/ ', expected: false },
+  { name: '段内含空白非法', model: 'a /b', expected: false },
+  { name: '通配段含空白非法', model: '* /b', expected: false },
+]
+
+test(`isTwoSegmentModel 双侧一致(${SEGMENT_VECTORS.length} 向量)`, () => {
+  for (const vector of SEGMENT_VECTORS) {
+    const host = hostIsTwoSegmentModel(vector.model)
+    const client = clientIsTwoSegmentModel(vector.model)
+    assert.deepEqual(client, host, vector.name)
+    assert.equal(host, vector.expected, vector.name)
+  }
+})
+
 test(`costOf 双侧一致(${COST_VECTORS.length} 向量)`, () => {
   for (const vector of COST_VECTORS) {
     const host = hostCostOf(vector.price, vector.buckets)

package/test/pricing.test.mjs

@@ -8,6 +8,7 @@ import {
   UNIT_PER_MILLION,
   conditionMatches,
   costOf,
+  isTwoSegmentModel,
   matchPrice,
 } from '../src/pricing.js'
 
@@ -19,7 +20,7 @@ const SATURDAY = new Date(2026, 8, 12)
 const localTime = (day, hour, minute = 0) => new Date(2026, 8, day, hour, minute)
 
 const makeRule = (overrides = {}) => ({
-  model: '*',
+  model: '*/*',
   unit: UNIT_PER_MILLION,
   currency: '¥',
   price: { input: 1, output: 2, cacheRead: 0.5, cacheWrite: 1 },
@@ -53,9 +54,9 @@ test('无条件规则恒命中', () => {
 })
 
 test('精确模型优先于通配规则', () => {
-  // Given 精确规则与 '*' 规则并存 When 匹配 Then 取精确规则 price
+  // Given 精确规则与 '*/*' 规则并存 When 匹配 Then 取精确规则 price
   const exact = makeRule({ model: 'a/b', price: { input: 5 } })
-  const wildcard = makeRule({ model: '*', price: { input: 1 } })
+  const wildcard = makeRule({ model: '*/*', price: { input: 1 } })
   assert.deepEqual(matchPrice([wildcard, exact], 'a/b', SUNDAY), exact.price)
 })
 
@@ -67,25 +68,126 @@ test('精确子集按数组序取首个命中', () => {
 })
 
 test('精确子集全不命中回落通配子集', () => {
-  // Given 精确规则条件不满足、'*' 规则无条件 When 匹配 Then 回落 '*' 而非 null
+  // Given 精确规则条件不满足、'*/*' 规则无条件 When 匹配 Then 回落 '*/*' 而非 null
   const exact = makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [1] }] })
-  const wildcard = makeRule({ model: '*', price: { input: 3 } })
+  const wildcard = makeRule({ model: '*/*', price: { input: 3 } })
   assert.deepEqual(matchPrice([exact, wildcard], 'a/b', SUNDAY), wildcard.price)
 })
 
 test('通配子集按数组序取首个命中', () => {
-  // Given 首条 '*' 条件满足、次条无条件 When 匹配 Then 取首条
-  const first = makeRule({ model: '*', conditions: [{ kind: 'weekdays', days: [0] }], price: { input: 1 } })
-  const second = makeRule({ model: '*', price: { input: 2 } })
+  // Given 首条 '*/*' 条件满足、次条无条件 When 匹配 Then 取首条
+  const first = makeRule({ model: '*/*', conditions: [{ kind: 'weekdays', days: [0] }], price: { input: 1 } })
+  const second = makeRule({ model: '*/*', price: { input: 2 } })
   assert.deepEqual(matchPrice([first, second], 'a/b', SUNDAY), first.price)
 })
 
 test('无精确子集直接查通配子集', () => {
-  // Given 仅 '*' 规则 When 匹配未列出模型 Then 命中通配
-  const wildcard = makeRule({ model: '*', price: { input: 4 } })
+  // Given 仅 '*/*' 规则 When 匹配未列出模型 Then 命中通配
+  const wildcard = makeRule({ model: '*/*', price: { input: 4 } })
   assert.deepEqual(matchPrice([wildcard], 'other/c', SUNDAY), wildcard.price)
 })
 
+test('匹配链:全名优先于模型名、供应商、全通配', () => {
+  // Given 四档规则并存 When 匹配 Then 依次全名 > 模型名 > 供应商 > 全通配
+  const rules = [
+    makeRule({ model: 'x/*', price: { input: 3 } }),
+    makeRule({ model: '*/*', price: { input: 4 } }),
+    makeRule({ model: '*/a', price: { input: 2 } }),
+    makeRule({ model: 'x/a', price: { input: 1 } }),
+  ]
+  assert.deepEqual(matchPrice(rules, 'x/a', SUNDAY), { input: 1 })
+})
+
+test('匹配链:模型名通配优先于供应商通配', () => {
+  // Given '*/a' 与 'x/*' 并存 When 匹配 x/a Then 模型名精确档胜
+  const rules = [
+    makeRule({ model: 'x/*', price: { input: 3 } }),
+    makeRule({ model: '*/a', price: { input: 2 } }),
+  ]
+  assert.deepEqual(matchPrice(rules, 'x/a', SUNDAY), { input: 2 })
+})
+
+test('匹配链:供应商通配优先于全通配', () => {
+  // Given 'x/*' 与 '*/*' 并存 When 匹配 x/a Then 供应商精确档胜
+  const rules = [
+    makeRule({ model: '*/*', price: { input: 4 } }),
+    makeRule({ model: 'x/*', price: { input: 3 } }),
+  ]
+  assert.deepEqual(matchPrice(rules, 'x/a', SUNDAY), { input: 3 })
+})
+
+test('模型名通配跨供应商命中同模型名', () => {
+  // Given '*/gpt-4o' When 匹配不同供应商同模型名 Then 命中;模型名不同不命中
+  const rule = makeRule({ model: '*/gpt-4o', price: { input: 7 } })
+  assert.deepEqual(matchPrice([rule], 'openai/gpt-4o', SUNDAY), { input: 7 })
+  assert.deepEqual(matchPrice([rule], 'azure/gpt-4o', SUNDAY), { input: 7 })
+  assert.equal(matchPrice([rule], 'openai/gpt-4o-mini', SUNDAY), null)
+})
+
+test('供应商通配命中同供应商全部模型', () => {
+  // Given 'openai/*' When 匹配同供应商多模型 Then 命中;异供应商不命中
+  const rule = makeRule({ model: 'openai/*', price: { input: 6 } })
+  assert.deepEqual(matchPrice([rule], 'openai/gpt-4o', SUNDAY), { input: 6 })
+  assert.deepEqual(matchPrice([rule], 'openai/o3', SUNDAY), { input: 6 })
+  assert.equal(matchPrice([rule], 'azure/gpt-4o', SUNDAY), null)
+})
+
+test('模型名段允许含斜杠按首个斜杠分段', () => {
+  // Given vendor 段通配或精确 When 匹配模型名含斜杠的多级模型 Then 按 vendor/余段比对
+  const vendorWide = makeRule({ model: 'openrouter/*', price: { input: 8 } })
+  assert.deepEqual(matchPrice([vendorWide], 'openrouter/deepseek/deepseek-chat', SUNDAY), { input: 8 })
+  const named = makeRule({ model: '*/deepseek/deepseek-chat', price: { input: 9 } })
+  assert.deepEqual(matchPrice([named], 'openrouter/deepseek/deepseek-chat', SUNDAY), { input: 9 })
+  assert.equal(matchPrice([named], 'openrouter/deepseek/chat', SUNDAY), null)
+})
+
+test('单段规则属旧形态失效不命中', () => {
+  // Given 旧写法 '*' 与裸名规则 When 匹配 Then 一律 null
+  const legacy = makeRule({ model: '*', price: { input: 1 } })
+  const bare = makeRule({ model: 'a', price: { input: 2 } })
+  assert.equal(matchPrice([legacy, bare], 'a/b', SUNDAY), null)
+  assert.equal(matchPrice([legacy, bare], 'a', SUNDAY), null)
+})
+
+test('请求裸名模型归 default 供应商', () => {
+  // Given 无斜杠请求 When 匹配 'default/名' 与 '*/名' Then 全名档优先
+  const exact = makeRule({ model: 'default/abc', price: { input: 1 } })
+  const named = makeRule({ model: '*/abc', price: { input: 2 } })
+  assert.deepEqual(matchPrice([named, exact], 'abc', SUNDAY), { input: 1 })
+  assert.deepEqual(matchPrice([named], 'abc', SUNDAY), { input: 2 })
+})
+
+test('档位回落:高档条件不满足逐层落低档', () => {
+  // Given 全名与模型名档条件仅周一 When 周日匹配 Then 落到无条件的供应商档
+  const exact = makeRule({ model: 'x/a', conditions: [{ kind: 'weekdays', days: [1] }], price: { input: 1 } })
+  const modelName = makeRule({ model: '*/a', conditions: [{ kind: 'weekdays', days: [1] }], price: { input: 2 } })
+  const vendor = makeRule({ model: 'x/*', price: { input: 3 } })
+  assert.deepEqual(matchPrice([exact, modelName, vendor], 'x/a', SUNDAY), { input: 3 })
+})
+
+test('同档规则按数组序取首个条件满足者', () => {
+  // Given 同为 '*/a' 两条,首条条件周日 When 周日匹配 Then 取首条
+  const first = makeRule({ model: '*/a', price: { input: 1 }, conditions: [{ kind: 'weekdays', days: [0] }] })
+  const second = makeRule({ model: '*/a', price: { input: 2 } })
+  assert.deepEqual(matchPrice([first, second], 'x/a', SUNDAY), { input: 1 })
+})
+
+test('isTwoSegmentModel 判定提交形态两段式', () => {
+  // Given 两段式与单段/空白段串 When 判定 Then 首斜杠在首位之后且两段无空白才成立
+  assert.equal(isTwoSegmentModel('a/b'), true)
+  assert.equal(isTwoSegmentModel('*/*'), true)
+  assert.equal(isTwoSegmentModel('a/b/c'), true)
+  assert.equal(isTwoSegmentModel('a'), false)
+  assert.equal(isTwoSegmentModel('*'), false)
+  assert.equal(isTwoSegmentModel('/b'), false)
+  assert.equal(isTwoSegmentModel(''), false)
+  assert.equal(isTwoSegmentModel('a/'), false)
+  assert.equal(isTwoSegmentModel(' /b'), false)
+  assert.equal(isTwoSegmentModel('a/ '), false)
+  assert.equal(isTwoSegmentModel('a /b'), false)
+  assert.equal(isTwoSegmentModel('* /b'), false)
+})
+
 test('两子集全不命中返回 null 计 unpriced', () => {
   // Given 仅一条精确规则且条件不满足 When 匹配本模型与陌生模型 Then 均为 null
   const rules = [makeRule({ model: 'a/b', conditions: [{ kind: 'weekdays', days: [1] }] })]

package/test/query.test.mjs

@@ -257,7 +257,7 @@ test('H 粒度槽数恰为 MAX_SLOTS 时不出现 truncated', () => {
 // ---- attachCosts 聚合计价:计价唯一以 H 桶起点匹配,费用精度=小时级 ----
 
 const ruleOf = (overrides = {}) => ({
-  model: '*',
+  model: '*/*',
   currency: '¥',
   price: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
   conditions: [],
@@ -266,12 +266,62 @@ const ruleOf = (overrides = {}) => ({
 
 const inputPrice = (input) => ({ input, output: 0, cacheRead: 0, cacheWrite: 0 })
 
+test('speed 配对聚合:仅 durationMs>0 行计入分子分母,老行只进 tokens', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', inputTokens: 5, outputTokens: 20, durationMs: 6500 }),
+    makeRow({ bucket: '2020-01-02', model: 'm1', provider: 'p1', outputTokens: 30, durationMs: 2500 }),
+    // 存量旧格式行:无 durationMs,token 计入总量但速度分母不含
+    makeRow({ bucket: '2020-01-03', model: 'm1', provider: 'p1', outputTokens: 100 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-03')
+  const entry = out.models.find((item) => item.model === 'm1')
+  assert.equal(entry.tokens, 25 + 30 + 100)
+  assert.equal(entry.speed, (20 + 30) / ((6500 + 2500) / 1000))
+})
+
+test('无 durationMs 数据时 models 条目无 speed 字段', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', outputTokens: 30 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-01')
+  assert.equal(out.models.length, 1)
+  assert.equal('speed' in out.models[0], false)
+})
+
+test('纯缓存行带时长:输出 0 计入分母,speed 为 0', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', cacheReadTokens: 10, outputTokens: 0, durationMs: 4000 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-01')
+  assert.equal(out.models[0].speed, 0)
+})
+
+test('槽级 speed 配对聚合:同槽带时长行合计,无时长槽无 speed 字段', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01', model: 'm1', provider: 'p1', outputTokens: 20, durationMs: 6500 }),
+    makeRow({ bucket: '2020-01-01', model: 'm2', provider: 'p2', outputTokens: 30, durationMs: 2500 }),
+    makeRow({ bucket: '2020-01-02', model: 'm1', provider: 'p1', outputTokens: 100 }),
+  ]
+  const out = aggregateRange(rows, 'D', '2020-01-01', '2020-01-02')
+  assert.equal(out.daily[0].speed, (20 + 30) / ((6500 + 2500) / 1000))
+  assert.equal('speed' in out.daily[1], false)
+})
+
+test('attachCosts 保留槽级 speed 字段供曲线消费', () => {
+  const rows = [
+    makeRow({ bucket: '2020-01-01T01', model: 'm1', provider: 'p1', outputTokens: 20, durationMs: 4000 }),
+  ]
+  const result = aggregateRange(rows, 'H', '2020-01-01T00', '2020-01-01T02')
+  const out = attachCosts(result, rows, 'H', [ruleOf()])
+  assert.equal(out.daily[1].speed, 5)
+})
+
 test('attachCosts H 槽按桶起点计价并归集 totals 与 models', () => {
   const rows = [
     makeRow({ bucket: '2020-01-01T01', model: 'm1', provider: 'p1', inputTokens: 1000000, outputTokens: 500000 }),
   ]
   const result = aggregateRange(rows, 'H', '2020-01-01T00', '2020-01-01T02')
-  const out = attachCosts(result, rows, 'H', [ruleOf({ model: 'm1', price: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 } })])
+  const out = attachCosts(result, rows, 'H', [ruleOf({ model: 'default/m1', price: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 } })])
   assert.equal(out.daily[1].cost, 2)
   assert.equal(out.cost, 2)
   assert.equal(out.unpriced, 0)
@@ -289,7 +339,7 @@ test('attachCosts 多行同桶多规则累加且残缺规则跳过后回落通
     makeRow({ bucket: '2020-01-01T01', model: 'm2', inputTokens: 1000000 }),
   ]
   const rules = [
-    ruleOf({ model: 'm1', price: inputPrice(1) }),
+    ruleOf({ model: 'default/m1', price: inputPrice(1) }),
     { model: 'm2' },
     ruleOf({ price: inputPrice(3) }),
   ]

package/test/routes.test.mjs

@@ -6,7 +6,7 @@ import assert from 'node:assert/strict'
 import { Readable } from 'node:stream'
 
 import { MAX_RANGE_SPAN_DAYS, registerUsageRoutes } from '../src/routes.js'
-import { DEFAULT_MINUTE_RETENTION_DAYS, minuteKey } from '../src/store.js'
+import { DEFAULT_MINUTE_RETENTION_DAYS, hourKey, minuteKey } from '../src/store.js'
 
 const DAY_MS = 24 * 60 * 60 * 1000
 const MINUTE_MS = 60 * 1000
@@ -338,8 +338,9 @@ test('minutes 禁用保留时标注空 covered', async () => {
 
 test('minutes from 未对齐 10 分钟桶边界拒绝 400', async () => {
   const { routes } = mount()
-  const d = new Date(FIXED_NOW)
-  const unaligned = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}T12:07`
+  // from 由 hourKey 本地渲染保证与 to 同一时区基准,前一小时的 :07 早于 to 且未对齐;
+  // 前提是 FIXED_NOW 不落入 DST 回拨小时(当前 2 月常量全球无转变日)
+  const unaligned = `${hourKey(FIXED_NOW - 60 * MINUTE_MS)}:07`
   const res = await invokeJson(routes, PATH_MINUTES, { payload: { from: unaligned, to: minuteKey(FIXED_NOW) } })
   const parsed = JSON.parse(res.body)
   assert.equal(res.statusCode, 400)
@@ -349,12 +350,12 @@ test('minutes from 未对齐 10 分钟桶边界拒绝 400', async () => {
 
 test('minutes 保留值超上限时 covered 窗口按 clamp 计算', async () => {
   const { routes } = mount({ retentionDays: () => 30 })
-  const from = minuteKey(FIXED_NOW - 3 * DAY_MS)
+  const from = minuteKey(FIXED_NOW - 8 * DAY_MS)
   const to = minuteKey(FIXED_NOW)
   const res = await invokeJson(routes, PATH_MINUTES, { payload: { from, to } })
   const parsed = JSON.parse(res.body)
   assert.equal(res.statusCode, 200)
-  assert.equal(parsed.value.coveredFrom, minuteKey(FIXED_NOW - 2 * DAY_MS))
+  assert.equal(parsed.value.coveredFrom, minuteKey(FIXED_NOW - 7 * DAY_MS))
   assert.equal(parsed.value.coveredTo, to)
 })
 
@@ -382,14 +383,14 @@ test('内部错误 500 不回显内部文本', async () => {
 // ---- S13 pricing 端点与 cost 集成 ----
 
 const PRICING_RULE = {
-  model: 'deepseek-chat',
+  model: 'deepseek/deepseek-chat',
   currency: '¥',
   price: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
   conditions: [{ kind: 'dailyWindow', from: '09:00', to: '18:00' }],
 }
 
 const ruleWithInputPrice = (input) => ({
-  model: 'deepseek-chat',
+  model: 'default/deepseek-chat',
   currency: '¥',
   price: { input, output: 0, cacheRead: 0, cacheWrite: 0 },
   conditions: [],
@@ -438,6 +439,9 @@ test('pricing POST 非法规则拒绝 400 且不写入', async () => {
     { rules: 'x' },
     {},
     { rules: [{ model: 1, currency: '¥', price: PRICING_RULE.price, conditions: [] }] },
+    { rules: [{ ...PRICING_RULE, model: 'deepseek-chat' }] },
+    { rules: [{ ...PRICING_RULE, model: '*' }] },
+    { rules: [{ ...PRICING_RULE, model: '/deepseek-chat' }] },
     { rules: [{ ...PRICING_RULE, price: { input: -1, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
     { rules: [{ ...PRICING_RULE, conditions: [{ kind: 'unknown' }] }] },
     { rules: [{ ...PRICING_RULE, conditions: [{ kind: 'weekdays', days: [7] }] }] },

package/test/stats-line.test.mjs

@@ -1,19 +1,11 @@
 // 底部信息栏增强纯函数层测试:官方 StatsLine 口径(dsh-client-ui-chat 同构)+ usp 双开关状态
 // Given/When/Then 场景内嵌于用例描述
-// client.js 为非模块 script(bundle 求值形态,禁 import/export),整源求值后按顶层声明名收集
+// client.js 为经典 script bundle(禁 import/export),整文件 IIFE 书挡;经 client-eval 剥壳后整源求值,按顶层声明名收集
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-const CLIENT_SOURCE = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'client.js'), 'utf8')
-const DECLARATION_NAMES = [
-  ...new Set(
-    [...CLIENT_SOURCE.matchAll(/^(?:const|function|let) ([A-Za-z_$][\w$]*)/gm)].map((match) => match[1])
-  ),
-]
-const core = new Function(`${CLIENT_SOURCE}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
+import { CLIENT_BODY, DECLARATION_NAMES } from './client-eval.mjs'
+
+const core = new Function(`${CLIENT_BODY}\nreturn { ${DECLARATION_NAMES.join(', ')} }`)()
 
 const {
   STATS_LINE_STORAGE_KEY,
@@ -43,11 +35,11 @@ const PREFS_COST_ON = { cachePrecision: false, tokenDetail: false, costDisplay:
 const zhT = createTranslator(MESSAGES_ZH)
 const enT = createTranslator(MESSAGES_EN)
 
-// 费用组装配输入:精确规则在前、通配规则兜底,通配仅全天时段生效
+// 费用组装配输入:精确规则在前、全通配规则兜底,通配仅全天时段生效
 const COST_RULES = [
   { model: 'p/m', currency: '¥', price: { input: 2, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [] },
   {
-    model: '*', currency: '', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 },
+    model: '*/*', currency: '', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 },
     conditions: [{ kind: 'dailyWindow', from: '00:00', to: '00:00' }],
   },
 ]
@@ -353,8 +345,8 @@ test('buildCostItem 开关关恒为 null,组数组不受 rules 影响', () => {
   ])
 })
 
-test('buildCostItem routes 缺席按通配规则匹配,符号取全局口径(首个非空货币)', () => {
-  // 无 routes → model '*',500000 × 1 / 每百万 = 0.5;命中通配(货币空),符号取表内首个非空 ¥
+test('buildCostItem routes 缺席按全通配规则匹配,符号取全局口径(首个非空货币)', () => {
+  // 无 routes → model '*/*',500000 × 1 / 每百万 = 0.5;命中全通配(货币空),符号取表内首个非空 ¥
   assert.equal(buildCostItem(COST_USAGE, COST_RULES, PREFS_COST_ON, zhT, COST_NOW), '费用 ≈ ¥0.50')
   assert.equal(buildCostItem(COST_USAGE, COST_RULES, PREFS_COST_ON, enT, COST_NOW), 'Cost ≈ ¥0.50')
 })