@mzzsfy/dsh-usage-dash 0.2.0 → 0.4.0

package/test/client.test.mjs

@@ -15,6 +15,9 @@ const {
   CHART_PAD,
   DAY_MAX_SLOTS,
   DAY_PRESETS,
+  DEFAULT_HOUR_PRESET,
+  DEFAULT_MINUTE_PRESET,
+  DEFAULT_RANGE,
   DONUT_CENTER_XY,
   DONUT_CIRCUMFERENCE,
   DONUT_OUTER_RADIUS,
@@ -58,6 +61,8 @@ const {
   hourTickLabel,
   indexOfDay,
   isEmptyRange,
+  groupRulesOf,
+  insertRuleAt,
   logTimeOf,
   matchPrice,
   maxSlotsFor,
@@ -65,11 +70,15 @@ const {
   modelSegmentLabel,
   modelSpeedText,
   modelNameOf,
+  moveRuleTo,
   niceTicks,
   otherDetailItems,
   parseEnvelope,
+  partitionGroupOf,
   providerOf,
   rateAxisTicks,
+  removeRulesAt,
+  renameRulesAt,
   resolveDayRange,
   resolveHourRange,
   resolveMinuteRange,
@@ -80,6 +89,13 @@ const {
   trimSlots,
   trendLayout,
   trendRatePoints,
+  trendSpeedPoints,
+  speedTipText,
+  speedScaleMax,
+  legendToggle,
+  leftAxisTicks,
+  hourSlotLabel,
+  minuteSlotLabel,
   validatePricingRules,
 } = core
 
@@ -129,6 +145,13 @@ test('预设定义表覆盖三视图', () => {
   assert.deepEqual(MINUTE_PRESETS, ['3h', '24h', '3d', '7d'])
 })
 
+test('默认挡位均在其挡位列表内,分钟窗口可解析', () => {
+  assert.ok(DAY_PRESETS.includes(DEFAULT_RANGE))
+  assert.ok(HOUR_PRESETS.includes(DEFAULT_HOUR_PRESET))
+  assert.ok(MINUTE_PRESETS.includes(DEFAULT_MINUTE_PRESET))
+  assert.notEqual(resolveMinuteRange(DEFAULT_MINUTE_PRESET, NOW), null)
+})
+
 test('时/分挡位文案键逐挡齐备,含跨表同 id 挡位', () => {
   // Given 时/分挡位表存在同 id('24h') When 逐挡查词典 Then 两语言均有对应键,漏配即回退键名
   for (const id of HOUR_PRESETS) {
@@ -320,23 +343,53 @@ test('trendLayout 单槽列距铺满且柱宽取上限', () => {
   assert.equal(layout.maxTotal, 50)
 })
 
-test('trendLayout 零值槽无分段但保留刻度', () => {
+test('trendLayout 零值槽无分段,无可见数据时刻度为空表', () => {
   const layout = trendLayout([{ day: '2026-03-15', total: 0, byModel: {} }], [], 720, 46)
   assert.deepEqual(layout.bars[0].segments, [])
-  assert.deepEqual(layout.ticks, [0.5, 1])
+  assert.deepEqual(layout.ticks, [])
 })
 
-test('trendLayout 堆叠分段自底向上且高度求和等于绘图高', () => {
+test('trendLayout 堆叠分段自底向上,轴上限为数据峰乘留白系数', () => {
   const layout = trendLayout([{ day: 'd', total: 50, byModel: { a: 30, b: 20 } }], ['a', 'b'], 720, 46)
   const [segA, segB] = layout.bars[0].segments
   assert.deepEqual(segA.model, 'a')
   assert.deepEqual(segB.model, 'b')
-  approx(segA.height, (30 / 50) * 184)
-  approx(segB.height, (20 / 50) * 184)
-  approx(segA.height + segB.height, 184)
+  approx(segA.height, (30 / (50 * 1.1)) * 184)
+  approx(segB.height, (20 / (50 * 1.1)) * 184)
+  approx(segA.height + segB.height, (50 / (50 * 1.1)) * 184)
   approx(segB.y + segB.height, segA.y)
 })
 
+test('trendLayout 数据峰不顶满绘图区,留白系数 1.1', () => {
+  const layout = trendLayout([{ day: 'd', total: 30, byModel: { a: 30 } }], ['a'], 720, 46)
+  const [segA] = layout.bars[0].segments
+  approx(segA.height + CHART_PAD.top, CHART_PAD.top + (1 / 1.1) * 184)
+})
+
+test('trendLayout 可见模型无数据时左轴刻度为空表', () => {
+  const slots = [{ day: 'd', total: 50, byModel: { a: 50 } }]
+  assert.deepEqual(trendLayout(slots, [], 720, 46).ticks, [])
+  assert.deepEqual(trendLayout(slots, ['b'], 720, 46).ticks, [])
+  assert.ok(trendLayout(slots, ['a'], 720, 46).ticks.length > 0)
+})
+
+test('leftAxisTicks 速度模式标定速度刻度,否则标定 token 刻度', () => {
+  const tokenTicks = leftAxisTicks([100, 200], 200, [], 1)
+  assert.deepEqual(tokenTicks.map((tick) => tick.label), ['100', '200'])
+  approx(tokenTicks[0].ratio, 0.5)
+  const speedTicks = leftAxisTicks([], 1, [0.5, 1], 1)
+  assert.deepEqual(speedTicks.map((tick) => tick.label), ['0.5', '1'])
+  approx(speedTicks[0].ratio, 0.5)
+  approx(speedTicks[1].ratio, 1)
+})
+
+test('hour/minute 悬浮窗槽标签:T 换空格,小时带 h 后缀,分钟保 HH:MM', () => {
+  assert.equal(hourSlotLabel('2026-03-15T14'), '2026-03-15 14h')
+  assert.equal(hourSlotLabel('2026-03-15T00'), '2026-03-15 00h')
+  assert.equal(minuteSlotLabel('2026-03-15T14:30'), '2026-03-15 14:30')
+  assert.equal(minuteSlotLabel('2026-03-15T00:00'), '2026-03-15 00:00')
+})
+
 test('trendLayout 标签密度随列距收敛', () => {
   const slots = Array.from({ length: 100 }, (_, i) => ({ day: `d${i}`, total: 0, byModel: {} }))
   const layout = trendLayout(slots, [], 720, 46)
@@ -423,8 +476,24 @@ const TIP_ANCHOR = { left: 100, top: 100, right: 140, bottom: 114 }
 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: 122 })
+test('tipPlace 小锚点默认翻上方水平居中', () => {
+  assert.deepEqual(tipPlace(TIP_ANCHOR, TIP_SIZE, TIP_BOUNDS), { left: 80, top: 52 })
+})
+
+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 上方不足翻下方', () => {
+  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({ 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 下方放不下翻转上方', () => {
@@ -473,6 +542,61 @@ test('trendRatePoints 点映射列中心与百分比高度且零数据日跳过'
   approx(points[1].y, CHART_PAD.top + plotHeight - 0.5 * plotHeight)
 })
 
+test('trendSpeedPoints 点映射列中心与刻度上限比例高度且无速度槽跳过', () => {
+  const slots = [
+    { day: 'd0', speed: 50 },
+    { day: 'd1', total: 10 },
+    { day: 'd2', speed: 25 },
+  ]
+  const bars = [{ x: 10 }, { x: 20 }, { x: 30 }]
+  const plotHeight = CHART_HEIGHT - CHART_PAD.top - CHART_PAD.bottom
+  const points = trendSpeedPoints(slots, bars, plotHeight, 100)
+  assert.equal(points.length, 2)
+  assert.equal(points[0].day, 'd0')
+  assert.equal(points[0].x, 10)
+  approx(points[0].y, CHART_PAD.top + plotHeight - 0.5 * plotHeight)
+  assert.equal(points[1].day, 'd2')
+  assert.equal(points[1].x, 30)
+  approx(points[1].y, CHART_PAD.top + plotHeight - 0.25 * plotHeight)
+})
+
+test('speedTipText 无速度为占位符有速度为官方吞吐口径', () => {
+  assert.equal(speedTipText(undefined), '—')
+  assert.equal(speedTipText(5.5556), '5.6 tok/s')
+  assert.equal(speedTipText(12.34), '12 tok/s')
+})
+
+test('legendToggle 普通点击单选,再点恢复全部,ctrl 多选且禁全藏', () => {
+  // null 表示全部可见
+  assert.deepEqual(legendToggle(null, 'a', false), new Set(['a']))
+  // 单选态再点同项恢复全部(null)
+  assert.equal(legendToggle(new Set(['a']), 'a', false), null)
+  // 单选态点他项 → 切换单选目标
+  assert.deepEqual(legendToggle(new Set(['a']), 'b', false), new Set(['b']))
+  // ctrl 切换单项:加入与移除
+  assert.deepEqual(legendToggle(new Set(['a']), 'b', true), new Set(['a', 'b']))
+  assert.deepEqual(legendToggle(new Set(['a', 'b']), 'b', true), new Set(['a']))
+  // ctrl 隐藏最后一项:无操作,保持原态
+  const solo = new Set(['a'])
+  assert.equal(legendToggle(solo, 'a', true), solo)
+})
+
+test('trendLayout 刻度跟随可见模型:单模型刻度按该槽内合计归一', () => {
+  const slots = [
+    { day: 'd0', total: 50, byModel: { a: 30, b: 20 } },
+    { day: 'd1', total: 90, byModel: { a: 40, b: 50 } },
+  ]
+  assert.equal(trendLayout(slots, ['a', 'b'], 720, 46).maxTotal, 90)
+  assert.equal(trendLayout(slots, ['a'], 720, 46).maxTotal, 40)
+  assert.equal(trendLayout(slots, [], 720, 46).maxTotal, 1)
+})
+
+test('speedScaleMax 全零或空槽钳底防除零,混合取最大速度', () => {
+  assert.equal(speedScaleMax([]), 1)
+  assert.equal(speedScaleMax([{ day: 'd0' }, { day: 'd1', speed: 0 }]), 1)
+  assert.equal(speedScaleMax([{ day: 'd0', speed: 30 }, { day: 'd1', speed: 12.5 }]), 30)
+})
+
 test('smoothPath 空点集为空串单点为移动命令', () => {
   assert.equal(smoothPath([]), '')
   assert.equal(smoothPath([{ x: 1, y: 2 }]), 'M 1 2')
@@ -647,51 +771,70 @@ test('costTitleText 未计价计数后缀', () => {
 })
 
 test('defaultCondition 各类型默认值即填即用', () => {
-  // Given 四种条件类型 When 取默认 Then 时段全天/周几空/号段全月/日期段当天
-  assert.deepEqual(defaultCondition('dailyWindow'), { kind: 'dailyWindow', from: '00:00', to: '00:00' })
+  // Given 四种条件类型 When 取默认 Then 时段全天(00:00~23:59)/周几空/号段全月(1~31)/日期段当天单日
+  assert.deepEqual(defaultCondition('dailyWindow'), { kind: 'dailyWindow', from: '00:00', to: '23:59' })
   assert.deepEqual(defaultCondition('weekdays'), { kind: 'weekdays', days: [] })
   assert.deepEqual(defaultCondition('monthDays'), { kind: 'monthDays', from: 1, to: 31 })
   assert.deepEqual(defaultCondition('dateRange', new Date(2026, 2, 15)), { kind: 'dateRange', from: '2026-03-15', to: '2026-03-15' })
 })
 
 test('validatePricingRules 拒绝非法时刻与时刻字段缺失', () => {
-  // Given dailyWindow 时刻超界或缺失 When 校验 Then 标 condTime/required
+  // Given dailyWindow 时刻超界或缺失 When 校验 Then 标 condTime/required;双闭域 00:00~23:59,24:00 超界
   const rules = [
     { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '99:99', to: '08:00' }] },
     { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '', to: '08:00' }] },
-    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '23:59', to: '24:00' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '24:00', to: '24:00' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '08:00', to: '24:30' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '00:00', to: '23:59' }] },
   ]
   const errors = validatePricingRules(rules)
   assert.equal(errors.get('0.conditions.0.from'), 'condTime')
   assert.equal(errors.get('1.conditions.0.from'), 'required')
-  assert.equal(errors.get('2.conditions.0.to'), 'condTime')
+  assert.equal(errors.get('2.conditions.0.from'), 'condTime')
+  assert.equal(errors.get('3.conditions.0.to'), 'condTime')
+  assert.equal(errors.has('4.conditions.0'), false)
+})
+
+test('validatePricingRules 接受 from===to 单点与单日', () => {
+  // Given 双闭下时段/号段/日期段 from===to When 校验 Then 全部合法
+  const rules = [
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dailyWindow', from: '10:00', to: '10:00' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'monthDays', from: 5, to: 5 }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-03-05', to: '2026-03-05' }] },
+  ]
+  const errors = validatePricingRules(rules)
+  assert.equal(errors.size, 0)
 })
 
 test('validatePricingRules 校验周几与月号段边界', () => {
-  // Given weekdays 含 7、monthDays 含 0 或 32 When 校验 Then 标 condWeekday/condMonthDay
+  // Given weekdays 含 7、monthDays 含 0/32/33 When 校验 Then 标 condWeekday/condMonthDay;31 为合法上界
   const rules = [
     { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'weekdays', days: [0, 7] }] },
     { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'monthDays', from: 0, to: 31 }] },
-    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'monthDays', from: 1, to: 32 }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'monthDays', from: 32, to: 32 }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'monthDays', from: 1, to: 33 }] },
   ]
   const errors = validatePricingRules(rules)
   assert.equal(errors.get('0.conditions.0.days'), 'condWeekday')
   assert.equal(errors.get('1.conditions.0.from'), 'condMonthDay')
-  assert.equal(errors.get('2.conditions.0.to'), 'condMonthDay')
+  assert.equal(errors.get('2.conditions.0.from'), 'condMonthDay')
+  assert.equal(errors.get('3.conditions.0.to'), 'condMonthDay')
 })
 
 test('validatePricingRules 校验日期段格式与倒序', () => {
-  // Given dateRange 非规范日期或倒序 When 校验 Then 标 condDate/condRange
+  // Given dateRange 非规范日期或倒序(双闭下同日合法)When 校验 Then 标 condDate/condRange
   const rules = [
     { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-3-5', to: '2026-03-08' }] },
     { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-03-08', to: '2026-03-05' }] },
+    { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-03-05', to: '2026-03-05' }] },
     { model: 'a/b', currency: '¥', price: { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }, conditions: [{ kind: 'dateRange', from: '2026-03-05', to: '2026-03-08' }] },
   ]
   const errors = validatePricingRules(rules)
   assert.equal(errors.get('0.conditions.0.from'), 'condDate')
   assert.equal(errors.get('1.conditions.0'), 'condRange')
   assert.equal(errors.has('2.conditions.0'), false)
-  assert.equal(errors.has('2.conditions.0.from'), false)
+  assert.equal(errors.has('3.conditions.0'), false)
+  assert.equal(errors.has('3.conditions.0.from'), false)
 })
 
 test('coerceConditions 规整数字字段且不改其余字段', () => {
@@ -720,3 +863,103 @@ test('coercePricingRules 连带规整条件', () => {
   assert.deepEqual(coerced[0].conditions, [{ kind: 'weekdays', days: [1] }, { kind: 'monthDays', from: 1, to: 31 }])
   assert.deepEqual(coerced[0].price, { input: 1, output: 0, cacheRead: 0, cacheWrite: 0 })
 })
+
+// —— 定价编辑器分组视图:模型组 = 默认价(组末无条件规则投影,禁条件) + 附加计费规则(带条件) ——
+
+test('groupRulesOf 按模型聚合,组序为首次出现序,槽位保序带平面索引', () => {
+  // Given 平面规则 [a1, b1, a2] When 分组 Then a 组槽位 [0,2]、b 组槽位 [1],组顺序按首次出现
+  const rules = [{ model: 'a/1' }, { model: 'b/1' }, { model: 'a/1' }]
+  const groups = groupRulesOf(rules)
+  assert.deepEqual(groups.map((group) => group.model), ['a/1', 'b/1'])
+  assert.deepEqual(groups[0].slots.map((slot) => slot.index), [0, 2])
+  assert.deepEqual(groups[1].slots.map((slot) => slot.index), [1])
+  groups[0].slots.forEach((slot, i) => assert.equal(slot.rule, rules[[0, 2][i]]))
+})
+
+test('groupRulesOf 空表返回空组列表', () => {
+  assert.deepEqual(groupRulesOf([]), [])
+})
+
+test('partitionGroupOf 组末无条件规则为默认价,其余为附加规则且保序', () => {
+  // Given 组槽位 [条件0, 条件1, 无条件2] When 划分 Then 默认价=索引2,附加=[0,1]
+  const cond = { kind: 'dailyWindow', from: '00:00', to: '08:00' }
+  const group = { model: 'a/1', slots: [
+    { rule: { model: 'a/1', conditions: [cond] }, index: 0 },
+    { rule: { model: 'a/1', conditions: [{ kind: 'weekdays', days: [1] }] }, index: 1 },
+    { rule: { model: 'a/1', conditions: [] }, index: 2 },
+  ] }
+  const { defaultSlot, extras } = partitionGroupOf(group)
+  assert.equal(defaultSlot.index, 2)
+  assert.deepEqual(extras.map((slot) => slot.index), [0, 1])
+})
+
+test('partitionGroupOf 全条件规则组无默认价', () => {
+  // Given 组内全部带条件 When 划分 Then defaultSlot 为 null,附加=全部槽位
+  const group = { model: 'a/1', slots: [
+    { rule: { model: 'a/1', conditions: [{ kind: 'weekdays', days: [1] }] }, index: 0 },
+    { rule: { model: 'a/1', conditions: [{ kind: 'weekdays', days: [2] }] }, index: 1 },
+  ] }
+  const { defaultSlot, extras } = partitionGroupOf(group)
+  assert.equal(defaultSlot, null)
+  assert.deepEqual(extras.map((slot) => slot.index), [0, 1])
+})
+
+test('partitionGroupOf 多条无条件规则时末条为默认价,前条按附加规则显示', () => {
+  // Given 组槽位 [无条件0, 无条件1] When 划分 Then 默认价=索引1,附加=[0](存量数据自然收敛)
+  const group = { model: 'a/1', slots: [
+    { rule: { model: 'a/1', conditions: [] }, index: 0 },
+    { rule: { model: 'a/1', conditions: [] }, index: 1 },
+  ] }
+  const { defaultSlot, extras } = partitionGroupOf(group)
+  assert.equal(defaultSlot.index, 1)
+  assert.deepEqual(extras.map((slot) => slot.index), [0])
+})
+
+test('moveRuleTo 跨位移动返回新数组且不动原数组', () => {
+  // Given [A,B,C] When 索引 2 移到索引 0 Then [C,A,B],原数组不变
+  const rules = [{ model: 'a/1' }, { model: 'b/1' }, { model: 'a/2' }]
+  const moved = moveRuleTo(rules, 2, 0)
+  assert.deepEqual(moved.map((rule) => rule.model), ['a/2', 'a/1', 'b/1'])
+  assert.deepEqual(rules.map((rule) => rule.model), ['a/1', 'b/1', 'a/2'])
+  assert.notEqual(moved, rules)
+})
+
+test('moveRuleTo 组内上移等价于移到组内前一槽位平面位', () => {
+  // Given [a1,b1,a2] When a2 移到 a1 平面位 0 Then [a2,a1,b1],a 组内序为 a2,a1
+  const rules = [{ model: 'a/1' }, { model: 'b/1' }, { model: 'a/1' }]
+  assert.deepEqual(moveRuleTo(rules, 2, 0).map((rule) => rule.model), ['a/1', 'a/1', 'b/1'])
+})
+
+test('moveRuleTo 同位或越界返回原数组引用', () => {
+  // Given 同源同目标/越界 When 移动 Then 恒返回原引用,UI 无操作
+  const rules = [{ model: 'a/1' }, { model: 'a/2' }]
+  assert.equal(moveRuleTo(rules, 0, 0), rules)
+  assert.equal(moveRuleTo(rules, -1, 1), rules)
+  assert.equal(moveRuleTo(rules, 0, rules.length), rules)
+  assert.equal(moveRuleTo(rules, rules.length, 0), rules)
+})
+
+test('renameRulesAt 批量改组内模型键,其余规则不动', () => {
+  // Given 索引 [0,2] 改名 x/y When 应用 Then 仅这两条 model 变 x/y
+  const rules = [{ model: 'a/1' }, { model: 'b/1' }, { model: 'a/1' }]
+  const renamed = renameRulesAt(rules, [0, 2], 'x/y')
+  assert.deepEqual(renamed.map((rule) => rule.model), ['x/y', 'b/1', 'x/y'])
+  assert.notEqual(renamed[0], rules[0])
+  assert.equal(renamed[1], rules[1])
+  assert.notEqual(renamed[2], rules[2])
+})
+test('insertRuleAt 插入到目标位之后', () => {
+  // Given 组内末槽位平面索引 2 When 插入新槽位 Then 落在索引 3,后续元素后移
+  const rules = [{ model: 'a/1' }, { model: 'b/1' }, { model: 'a/1' }]
+  const next = insertRuleAt(rules, 2, { model: 'a/1' })
+  assert.equal(next.length, 4)
+  assert.equal(next[3].model, 'a/1')
+  assert.equal(next[1].model, 'b/1')
+})
+
+test('removeRulesAt 批量移除组内槽位', () => {
+  // Given 索引 [0,2] When 删除 Then 仅剩 b 组
+  const rules = [{ model: 'a/1' }, { model: 'b/1' }, { model: 'a/1' }]
+  const rest = removeRulesAt(rules, [0, 2])
+  assert.deepEqual(rest.map((rule) => rule.model), ['b/1'])
+})

package/test/collector.test.mjs

@@ -72,17 +72,46 @@ function fakeSessions(handles = []) {
 }
 
 // definitions: [{ id, events?, inheritedEventCount?, fail? }]
+// 内部统一契约形状(list → [{id}],readLog → {inheritedEventCount, events}),
+// 宿主 persistence 的多版本映射由 archive-reader 测试单独覆盖
 function fakePersistence(definitions = []) {
   const byId = new Map(definitions.map((def) => [def.id, def]))
   return {
     async list() {
       return definitions.map((def) => ({ id: def.id }))
     },
-    async inspect(id) {
+    async readLog(id) {
       const def = byId.get(id)
       if (!def) throw new Error(`session "${id}" not found`)
       if (def.fail) throw new Error(def.fail)
-      return { meta: { id }, inheritedEventCount: def.inheritedEventCount ?? 0, events: def.events ?? [] }
+      return { inheritedEventCount: def.inheritedEventCount ?? 0, events: def.events ?? [] }
+    },
+  }
+}
+
+// 宿主 handle 代形状(list 返回 snapshot,open/read/close 读体),供走
+// rescan → 工厂分派 → backfill 的装配路径测试使用
+function fakeHostPersistence(definitions = []) {
+  const byId = new Map(definitions.map((def) => [def.id, def]))
+  return {
+    async list() {
+      return definitions.map((def) => ({ header: { id: def.id }, revision: {} }))
+    },
+    async open(id, access) {
+      const def = byId.get(id)
+      if (!def) throw new Error(`session "${id}" not found`)
+      return {
+        header: { id },
+        inheritedEventCount: def.inheritedEventCount ?? 0,
+        access,
+        async read(offset, length) {
+          if (def.fail) throw new Error(def.fail)
+          const all = def.events ?? []
+          const start = typeof offset === 'number' && offset > 0 ? offset : 0
+          return { eventState: 'detached', events: all.slice(start, typeof length === 'number' ? start + length : undefined) }
+        },
+        async close() {},
+      }
     },
   }
 }
@@ -250,6 +279,67 @@ test('四桶全零 usage 为噪声不产样本', async () => {
   assert.equal(store.samples.length, 0)
 })
 
+test('V3 日志兼容:V3 专有事件与新字段被折叠忽略不炸', async () => {
+  const { ctx, store } = liveCollector()
+  const t = local(2026, 8, 2, 10, 0)
+  // V3 新增事件(SESSION_FORMAT_VERSION 3):统计不消费,折叠必须安全忽略
+  ctx.emit('session/event', session('s1'), ev('system/message', 1, t, { turn: 0, step: 0, message: { role: 'system', content: 'sys' } }))
+  ctx.emit('session/event', session('s1'), ev('assistant/attempt', 2, t, { turn: 0, step: 0, stream: [] }))
+  ctx.emit('session/event', session('s1'), ev('request/header', 3, t, { header: { config: {} }, reason: 'initial' }))
+  ctx.emit('session/event', session('s1'), ev('user/message', 4, t, { role: 'user', content: 'hi' }, ))
+  ctx.emit('session/event', session('s1'), ev('tool/call', 5, t, { turn: 0, step: 0, callId: 'c1', name: 'n', arguments: '{}' }))
+  ctx.emit('session/event', session('s1'), ev('tool/result', 6, t, { turn: 0, step: 0, message: { role: 'toolResult', content: 'r' } }))
+  ctx.emit('session/event', session('s1'), ev('session/end-seed', 7, t, {}))
+  ctx.emit('session/event', session('s1'), ev('step/end', 8, t, { turn: 0, step: 0 }))
+  ctx.emit('session/event', session('s1'), ev('turn/start', 9, t, { turn: 1 }))
+  // V3 assistant/message 携带 stream/surfaceOp/interrupted 等新字段:usage 折叠不受影响
+  ctx.emit('session/event', session('s1'), ev('assistant/message', 10, t, {
+    turn: 1,
+    step: 0,
+    usage: usage({ inputTokens: 5 }),
+    message: { role: 'assistant', source: { provider: 'p', model: 'm' } },
+    stream: [{ type: 'text-delta', text: 'x' }],
+    surfaceOp: 'append',
+    interrupted: true,
+  }))
+  await tick()
+  assert.equal(store.samples.length, 1)
+  assert.equal(store.samples[0].inputTokens, 5)
+  assert.equal(store.samples[0].model, 'p/m')
+})
+
+test('V3 日志兼容:回扫重放 V3 事件流,样本与游标正确', async () => {
+  const t = local(2026, 8, 2, 14, 0)
+  const persistence = fakePersistence([{
+    id: 'v3session',
+    events: [
+      ev('request/header', 0, t, { header: { config: {} }, reason: 'resume' }),
+      ev('system/message', 1, t, { turn: 0, step: 0, message: { role: 'system', content: 'sys' } }),
+      ev('user/message', 2, t, { role: 'user', content: 'q' }),
+      ev('step/start', 3, t, { turn: 0, step: 0 }),
+      ev('assistant/attempt', 4, t, { turn: 0, step: 0, stream: [] }),
+      ev('assistant/message', 5, t, {
+        turn: 0,
+        step: 0,
+        usage: usage({ inputTokens: 7 }),
+        message: { role: 'assistant', source: { provider: 'p', model: 'm' } },
+        stream: [],
+      }),
+      ev('step/end', 6, t, { turn: 0, step: 0 }),
+      ev('turn/end', 7, t, { turn: 0, reason: { kind: 'completed' } }),
+    ],
+  }])
+  const store = fakeStore()
+  const collector = new UsageCollector(fakeCtx({ persistence }), store)
+  await collector.backfill(persistence, fakeSessions())
+  assert.deepEqual(store.samples.map((sample) => [sample.request ?? sample.turn ?? false, sample.inputTokens]), [
+    [true, 0],
+    [false, 7],
+    [true, 0],
+  ])
+  assert.deepEqual([...store.state.backfilledSessions], ['v3session'])
+})
+
 test('纯缓存调用(仅缓存桶非零)仍产样本', async () => {
   const { ctx, store } = liveCollector()
   const t = local(2026, 8, 2, 10, 0)
@@ -578,6 +668,56 @@ test('回扫:record 失败使会话失败并保留游标重试机会', async ()
   assert.equal(collector.status().done, 1)
 })
 
+test('回扫:skipped 计数独立累加,超过日志上限不漂移', async () => {
+  const t = local(2026, 8, 2, 14, 0)
+  const defs = Array.from({ length: 210 }, (_, i) => ({ id: `bad${i}`, fail: 'uses unsupported descriptor version 2' }))
+  const persistence = fakePersistence(defs)
+  const store = fakeStore()
+  const collector = new UsageCollector(fakeCtx({ persistence }), store)
+  await collector.backfill(persistence, fakeSessions())
+  assert.equal(collector.status().skippedSessions, 210)
+  assert.equal(collector.status().log.length, 200)
+  assert.deepEqual(collector.status().skippedBreakdown, { descriptor: 210, corrupt: 0, legacy: 0, other: 0 })
+})
+
+test('回扫:skipped 按 detail 归因分类,次轮扫描计数复位', async () => {
+  const t = local(2026, 8, 2, 14, 0)
+  const persistence = fakePersistence([
+    { id: 'a', fail: 'uses unsupported descriptor version 2; source v0 artifact remains unchanged' },
+    { id: 'b', fail: 'stored log is corrupt: SessionFormatError: seq gap' },
+    { id: 'c', fail: 'format v0 contains unknown member "editor"' },
+    { id: 'd', fail: 'mystery failure' },
+    { id: 'ok', events: [ev('turn/end', 0, t)] },
+  ])
+  const store = fakeStore()
+  const collector = new UsageCollector(fakeCtx({ persistence }), store)
+  await collector.backfill(persistence, fakeSessions())
+  assert.deepEqual(collector.status().skippedBreakdown, { descriptor: 1, corrupt: 1, legacy: 1, other: 1 })
+  assert.equal(collector.status().skippedSessions, 4)
+  // 次轮:失败档不进游标会重现,但本轮从空游标重扫,计数从头累计且包含上一轮成功档
+  await collector.backfill(persistence, fakeSessions())
+  assert.equal(collector.status().skippedSessions, 4)
+  assert.deepEqual(collector.status().skippedBreakdown, { descriptor: 1, corrupt: 1, legacy: 1, other: 1 })
+})
+
+test('回扫:list 失败记入 error 并向上传播,running 复位', async () => {
+  const failure = new Error('sessionPersistence API 未识别')
+  const persistence = {
+    async list() {
+      throw failure
+    },
+    async readLog() {
+      throw new Error('not reached')
+    },
+  }
+  const store = fakeStore()
+  const collector = new UsageCollector(fakeCtx({ persistence }), store)
+  await assert.rejects(collector.backfill(persistence, fakeSessions()), (error) => error === failure)
+  assert.equal(collector.status().error, failure.message)
+  assert.equal(collector.status().running, false)
+  assert.equal(store.samples.length, 0)
+})
+
 test('abort:已中止 signal 直接返回不进入扫描', async () => {
   const persistence = fakePersistence([{ id: 's1', events: [] }])
   const store = fakeStore()
@@ -597,9 +737,9 @@ test('abort:扫描中中断停止处理且不写游标', async () => {
     async list() {
       return [{ id: 's1' }]
     },
-    async inspect(id) {
+    async readLog() {
       controller.abort()
-      return { meta: { id }, inheritedEventCount: 0, events: [ev('turn/end', 0, t)] }
+      return { inheritedEventCount: 0, events: [ev('turn/end', 0, t)] }
     },
   }
   const store = fakeStore()
@@ -625,14 +765,14 @@ test('回扫并发受默认并发 4 约束', async () => {
     async list() {
       return defs.map((def) => ({ id: def.id }))
     },
-    async inspect(id) {
+    async readLog(id) {
       inFlight += 1
       peak = Math.max(peak, inFlight)
       if (inFlight >= EXPECTED_CONCURRENCY) release()
       await Promise.race([gate, new Promise((resolve) => setTimeout(resolve, GATE_TIMEOUT_MS))])
       inFlight -= 1
       const def = defs.find((candidate) => candidate.id === id)
-      return { meta: { id }, inheritedEventCount: 0, events: def.events }
+      return { inheritedEventCount: 0, events: def.events }
     },
   }
   const store = fakeStore()
@@ -645,7 +785,7 @@ test('回扫并发受默认并发 4 约束', async () => {
 test('resetAndRescan 以 wipe 时刻日志长度为活跃会话边界并重扫', async () => {
   const t = local(2026, 8, 2, 9, 0)
   const events = Array.from({ length: 13 }, (_, seq) => ev('turn/end', seq, t))
-  const persistence = fakePersistence([{ id: 'live-a', events }])
+  const persistence = fakeHostPersistence([{ id: 'live-a', events }])
   const sessions = fakeSessions([{ id: 'live-a', seq: 10 }, { id: 'live-b' }])
   const store = fakeStore()
   store.state.liveFirstSeq.set('live-a', 3)
@@ -661,7 +801,7 @@ test('resetAndRescan 以 wipe 时刻日志长度为活跃会话边界并重扫',
 
 test('并发 resetAndRescan 合并为一次重建', async () => {
   const store = fakeStore()
-  const collector = new UsageCollector(fakeCtx(), store)
+  const collector = new UsageCollector(fakeCtx({ persistence: fakeHostPersistence() }), store)
   const first = collector.resetAndRescan()
   const second = collector.resetAndRescan()
   await Promise.all([first, second])
@@ -682,8 +822,12 @@ test('status() 返回快照,外部修改不影响内部状态', async () => {
     error: undefined,
     recordFailures: 0,
     skippedSessions: 0,
+    skippedBreakdown: { descriptor: 0, corrupt: 0, legacy: 0, other: 0 },
     log: [],
   })
+  const before = collector.status().skippedBreakdown
+  before.descriptor = 99
+  assert.equal(collector.status().skippedBreakdown.descriptor, 0)
   await collector.backfill(persistence, fakeSessions())
   const snapshot = collector.status()
   assert.equal(snapshot.running, false)