Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

47.1 KB
Raw Blame
// @vitest-environment jsdom
import { cleanup, fireEvent, render, screen, within } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { createInstance } from 'i18next';
import { I18nextProvider, initReactI18next } from 'react-i18next';
import { afterEach, describe, expect, it, vi } from 'vitest';

import en from '../../../i18n/en.json';
import zh from '../../../i18n/zh.json';
import { readyRegion } from './regionRead';
import type {
  ServiceUsage,
  UsageBucket,
  UsageBucketEntry,
  UsageBucketRow,
  UsageCounters,
  UsageReport,
  UsageServiceBucketRow,
  UsageWindowKey,
} from './types';
import { UsageTab } from './UsageTab';
import { buildUsageCsv, csvCell, type UsageCsvHeaders } from './usageCsv';

const i18n = createInstance();
void i18n.use(initReactI18next).init({
  lng: 'en',
  fallbackLng: 'en',
  resources: { en: { translation: en } },
  interpolation: { escapeValue: false },
});

const counters = (over: Partial<UsageCounters> = {}): UsageCounters => ({
  requests: 2,
  token_reports: 2,
  input_tokens: 100,
  cached_input_tokens: 25,
  output_tokens: 40,
  ...over,
});

const row = (over: Partial<UsageBucketRow> = {}): UsageBucketRow => ({
  ...counters(),
  source_id: 'source-a',
  model_id: 'model-a',
  ...over,
});

const bucket = (
  key: string,
  rows: UsageBucketEntry[] = [row()],
  over: Partial<UsageBucket> = {},
): UsageBucket => ({
  key,
  start_at: `2026-09-24T${key}:00:00+08:00`,
  end_at: `2026-09-24T${String(Number(key) + 1).padStart(2, '0')}:00:00+08:00`,
  history_complete: true,
  rows,
  ...over,
});

const report = (over: Partial<UsageReport> = {}): UsageReport => ({
  window_days: 1,
  from_day: '2026-09-24',
  to_day: '2026-09-24',
  totals: counters({ requests: 6, token_reports: 6, input_tokens: 300, cached_input_tokens: 75, output_tokens: 120 }),
  sources: [{
    source_id: 'source-a',
    label: 'Shared label',
    last_metered_at: '2026-09-24T02:00:00+08:00',
    ...counters({ requests: 6, token_reports: 6, input_tokens: 300, cached_input_tokens: 75, output_tokens: 120 }),
    models: [{ model_id: 'model-a', label: 'Shared model', ...counters({ requests: 6, token_reports: 6, input_tokens: 300, cached_input_tokens: 75, output_tokens: 120 }) }],
  }],
  services: [],
  days: [],
  window_key: '24h',
  granularity: 'hour',
  from_at: '2026-09-24T00:00:00+08:00',
  to_at: '2026-09-24T03:00:00+08:00',
  buckets: [bucket('00'), bucket('01'), bucket('02')],
  ...over,
});

const draw = (
  value: UsageReport,
  over: { windowKey?: UsageWindowKey; onWindowChange?: (window: UsageWindowKey) => void } = {},
) => render(
  <I18nextProvider i18n={i18n}>
    <UsageTab
      usage={readyRegion(value)}
      windowKey={over.windowKey ?? '24h'}
      onWindowChange={over.onWindowChange ?? vi.fn()}
    />
  </I18nextProvider>,
);

const CSV_HEADERS = Object.fromEntries([
  'bucketKey', 'startAt', 'endAt', 'historyComplete', 'sourceId', 'modelId', 'ledgerKey', 'sourceLabel', 'modelLabel',
  'requests', 'tokenReports', 'inputTokens', 'nonCachedInputTokens', 'cachedInputTokens', 'outputTokens', 'totalTokens',
].map((key) => [key, key])) as UsageCsvHeaders;

afterEach(cleanup);

describe('UsageTab', () => {
  it('defaults to 24 hours and forwards the selected contract window', async () => {
    const onWindowChange = vi.fn();
    draw(report(), { onWindowChange });

    expect(screen.getByRole('radio', { name: '24 hours', checked: true })).toBeTruthy();
    await userEvent.click(screen.getByRole('radio', { name: '7 days' }));
    expect(onWindowChange).toHaveBeenCalledWith('7d');
  });

  it('MH-USAGE-016: names the window the report was served over, not the one asked for', () => {
    const { container } = draw(report({
      from_at: '2026-08-18T00:00:00+08:00',
      to_at: '2026-08-18T03:00:00+08:00',
    }), { windowKey: '7d' });

    const heading = container.querySelector('.model-hub-usage-heading');
    expect(heading?.textContent).toContain('Aug 18, 2026');
    expect(heading?.textContent).not.toContain('Sep 24, 2026');
  });

  it('MH-USAGE-017: folds a vanished Source into Removed providers and never shows its IDs', async () => {
    const vanishedModelId = 'model-opaque-digest-9f2c1d';
    const { container } = draw(report({
      sources: [
        {
          source_id: 'source-a',
          label: 'Live supplier',
          last_metered_at: null,
          ...counters(),
          models: [{ model_id: 'model-a', label: 'Live model', ...counters() }],
        },
        {
          source_id: 'src_vanished01',
          label: null,
          last_metered_at: null,
          ...counters({ requests: 4 }),
          models: [
            { model_id: vanishedModelId, label: null, ...counters() },
            { model_id: 'glm-5.3', label: null, ...counters() },
          ],
        },
      ],
      buckets: [bucket('00', [
        row({ source_id: 'src_vanished01', model_id: vanishedModelId, requests: 5 }),
        row({ source_id: 'src_vanished01', model_id: 'glm-5.3', requests: 5 }),
        row(),
      ])],
    }));
    const table = () => within(screen.getByRole('table'));
    const names = () => [...container.querySelectorAll('tbody .model-hub-usage-row-name')].map((cell) => cell.textContent);

    expect(names()).toEqual(['Live supplier · Live model', 'Removed providers']);
    expect(table().getByText('Usage kept after these providers were deleted')).toBeTruthy();
    expect(table().getByText('10')).toBeTruthy();
    await userEvent.click(screen.getByRole('button', { name: 'By source' }));
    expect(names()).toEqual(['Live supplier', 'Removed providers']);
    // The aggregate closes the table whichever way it is sorted.
    await userEvent.click(screen.getByRole('button', { name: /sorted descending/i }));
    expect(names()).toEqual(['Live supplier', 'Removed providers']);
    await userEvent.click(screen.getByRole('button', { name: 'Model' }));
    expect(container.querySelector('.model-hub-usage-legend')?.textContent).toContain('Removed providers');
    await userEvent.click(screen.getByRole('button', { name: 'All Source' }));
    expect(screen.getByRole('option', { name: /Removed providers/ })).toBeTruthy();
    for (const hidden of ['src_vanished01', vanishedModelId, 'glm-5.3', 'Unknown model']) {
      expect(container.textContent).not.toContain(hidden);
    }
  });

  it('MH-USAGE-034: a picked Source deleted before the next report reads as the whole Removed providers aggregate', async () => {
    const source = (source_id: string, label: string | null) => ({
      source_id, label, last_metered_at: null, ...counters(), models: [],
    });
    const rows = [
      row({ source_id: 'source-a', requests: 1 }),
      row({ source_id: 'src_doomed01', model_id: 'model-d', requests: 2 }),
      row({ source_id: 'src_gone01', model_id: 'model-g', requests: 4 }),
    ];
    const page = (value: UsageReport) => (
      <I18nextProvider i18n={i18n}>
        <UsageTab usage={readyRegion(value)} windowKey="24h" onWindowChange={vi.fn()} />
      </I18nextProvider>
    );
    const before = report({
      sources: [source('source-a', 'Live supplier'), source('src_doomed01', 'Doomed supplier'), source('src_gone01', null)],
      buckets: [bucket('00', rows)],
    });
    const { container, rerender } = render(page(before));
    await userEvent.click(screen.getByRole('button', { name: 'All Source' }));
    await userEvent.click(screen.getByRole('option', { name: /Doomed supplier/ }));
    await userEvent.keyboard('{Escape}');
    await userEvent.click(screen.getByRole('button', { name: 'By source' }));
    const names = () => [...container.querySelectorAll('tbody .model-hub-usage-row-name')].map((cell) => cell.textContent);
    expect(names()).toEqual(['Doomed supplier']);

    rerender(page({ ...before, sources: [source('source-a', 'Live supplier'), source('src_doomed01', null), source('src_gone01', null)] }));
    expect(screen.getByRole('button', { name: 'Removed providers' })).toBeTruthy();
    expect(names()).toEqual(['Removed providers']);
    expect(within(screen.getByRole('table')).getAllByText('6').length).toBeGreaterThan(0);
    expect(container.textContent).not.toContain('src_');
  });

  it('MH-USAGE-035: a picked aggregate the next report no longer offers is dropped, not kept for a later one', async () => {
    const page = (value: UsageReport) => (
      <I18nextProvider i18n={i18n}>
        <UsageTab usage={readyRegion(value)} windowKey="24h" onWindowChange={vi.fn()} />
      </I18nextProvider>
    );
    const live = report();
    const withRemoved = {
      ...live,
      sources: [...live.sources, { source_id: 'src_gone01', label: null, last_metered_at: null, ...counters(), models: [] }],
      buckets: [bucket('00', [row(), row({ source_id: 'src_gone01', model_id: 'model-g' })])],
    };
    const { container, rerender } = render(page(withRemoved));
    await userEvent.click(screen.getByRole('button', { name: 'All Source' }));
    await userEvent.click(screen.getByRole('option', { name: /Removed providers/ }));
    await userEvent.keyboard('{Escape}');
    expect(screen.getByRole('button', { name: 'Reset filters' })).toBeTruthy();

    rerender(page(live));
    expect(screen.getByRole('button', { name: 'All Source' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'Reset filters' })).toBeNull();
    expect(container.querySelector('.model-hub-usage-empty-state')).toBeNull();
    expect(within(screen.getByRole('table')).getAllByText('Shared label · Shared model').length).toBeGreaterThan(0);

    // Dropped means gone: a later report offering it again does not bring it back.
    rerender(page(withRemoved));
    expect(screen.getByRole('button', { name: 'All Source' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'Reset filters' })).toBeNull();
  });

  it('MH-USAGE-018: reads a shortfall as reports that never arrived', () => {
    const shortfall = counters({
      requests: 4,
      token_reports: 1,
      input_tokens: 100,
      cached_input_tokens: 25,
      output_tokens: 40,
    });
    const { container } = draw(report({
      totals: shortfall,
      sources: [],
      buckets: [bucket('00', [row(shortfall)])],
    }));

    expect(container.textContent).toContain('3 requests have no token report');
    expect(container.textContent).toContain('All tokens');
  });

  it('names an unlisted model by its model ID and keeps the translated unknown name for a folded key', async () => {
    const translated = createInstance();
    await translated.use(initReactI18next).init({
      lng: 'de',
      fallbackLng: 'en',
      resources: {
        en: { translation: en },
        de: { translation: { settings: { models: { usage: { unknownModel: 'Historisches Modell', removedModel: 'Entfernt' } } } } },
      },
      interpolation: { escapeValue: false },
    });
    const foldedKey = `${'m'.repeat(200)}~${'0'.repeat(64)}`;
    const value = report({
      sources: [{
        source_id: 'source-a',
        label: 'Supplier',
        last_metered_at: null,
        ...counters(),
        models: [{ model_id: 'model-a', label: 'Model', ...counters() }],
      }],
      buckets: [bucket('00', [row({ model_id: 'removed-model' }), row({ model_id: foldedKey }), row()])],
    });
    const { container } = render(
      <I18nextProvider i18n={translated}>
        <UsageTab usage={readyRegion(value)} windowKey="24h" onWindowChange={vi.fn()} />
      </I18nextProvider>,
    );
    const labels = ['Supplier · removed-model', 'Supplier · Historisches Modell', 'Supplier · Model'];
    for (const label of labels) expect(within(screen.getByRole('table')).getByText(label)).toBeTruthy();
    expect(within(screen.getByRole('table')).getAllByText('Supplier · Entfernt')).toHaveLength(2);
    await userEvent.click(screen.getByRole('button', { name: 'All Model' }));
    for (const label of labels) expect(screen.getByRole('option', { name: new RegExp(label) })).toBeTruthy();
    fireEvent.pointerDown(document.body);
    await userEvent.click(screen.getByRole('button', { name: 'Model' }));
    for (const label of labels) expect(container.querySelector('.model-hub-usage-legend')?.textContent).toContain(label);
    expect(container.textContent).not.toContain(foldedKey);
  });

  it('formats every percentage in the active locale even when translations fall back', async () => {
    const translated = createInstance();
    await translated.use(initReactI18next).init({
      lng: 'de-DE',
      fallbackLng: 'en',
      resources: { en: { translation: en } },
      interpolation: { escapeValue: false },
    });
    const { container } = render(
      <I18nextProvider i18n={translated}>
        <UsageTab usage={readyRegion(report({
          buckets: [bucket('00', [
            row({ input_tokens: 2, cached_input_tokens: 1, output_tokens: 0 }),
            row({ model_id: 'model-b', input_tokens: 14, cached_input_tokens: 1, output_tokens: 0 }),
          ])],
        }))} windowKey="24h" onWindowChange={vi.fn()} />
      </I18nextProvider>,
    );

    expect(container.querySelector('.model-hub-usage-stat-grid')?.textContent).toContain('12,5\u00a0%');
    expect(container.querySelector('tbody')?.textContent).toContain('12,5\u00a0%');
    expect(container.querySelector('tbody')?.textContent).toContain('87,5\u00a0%');
    expect(container.querySelector('tfoot')?.textContent).toContain('100\u00a0%');
    expect(container.textContent).not.toContain('12.5%');
  });

  it('exposes the current sort direction together with the actual detail row order', async () => {
    const { container } = draw(report({
      buckets: [bucket('00', [
        row({ input_tokens: 2, cached_input_tokens: 1, output_tokens: 0 }),
        row({ model_id: 'model-b', input_tokens: 14, cached_input_tokens: 1, output_tokens: 0 }),
      ])],
    }));
    const header = screen.getByRole('columnheader', { name: /All tokens/ });
    const amounts = () => within(container.querySelector('tbody')!).getAllByRole('row').map(
      (detail) => within(detail).getAllByRole('cell')[5]?.textContent,
    );

    expect(header.getAttribute('aria-sort')).toBe('descending');
    expect(within(header).getByRole('button', { name: /Sorted descending/ })).toBeTruthy();
    expect(amounts()).toEqual(['14', '2']);
    await userEvent.click(within(header).getByRole('button'));
    expect(header.getAttribute('aria-sort')).toBe('ascending');
    expect(within(header).getByRole('button', { name: /Sorted ascending/ })).toBeTruthy();
    expect(amounts()).toEqual(['2', '14']);
    await userEvent.click(within(header).getByRole('button'));
    expect(header.getAttribute('aria-sort')).toBe('descending');
    expect(amounts()).toEqual(['14', '2']);
  });

  it('MH-USAGE-019: plots every bucket in the window, including the ones that carried nothing', () => {
    const { container } = draw(report({
      buckets: [bucket('00', []), bucket('01', []), bucket('02', [row()])],
    }));

    expect(screen.getAllByRole('button', { name: /Usage bucket/ })).toHaveLength(3);
    expect(container.textContent).toContain('3 hourly points');
  });

  it('MH-USAGE-021: draws calls whose tokens never came back, and names the window unreported', () => {
    const unreported = counters({
      requests: 4,
      token_reports: 0,
      input_tokens: 0,
      cached_input_tokens: 0,
      output_tokens: 0,
    });
    const { container } = draw(report({
      totals: unreported,
      sources: [],
      buckets: [bucket('00', [row(unreported)])],
    }));

    expect(container.textContent).toContain('Some requests have no token report; token values are unavailable');
    expect(container.textContent).toContain('—');
    expect(container.querySelector('tfoot')?.textContent).not.toContain('100%');
  });

  it('MH-USAGE-023: states every bucket in accessible text, not only in a pointer tooltip', () => {
    draw(report());
    const buckets = screen.getAllByRole('button', { name: /Usage bucket/ });

    expect(buckets.map((item) => item.getAttribute('aria-label'))).toEqual([
      'Usage bucket Sep 24, 2026, 00:00 UTC+08:00 – Sep 24, 2026, 01:00 UTC+08:00',
      'Usage bucket Sep 24, 2026, 01:00 UTC+08:00 – Sep 24, 2026, 02:00 UTC+08:00',
      'Usage bucket Sep 24, 2026, 02:00 UTC+08:00 – Sep 24, 2026, 03:00 UTC+08:00',
    ]);
  });

  it('MH-USAGE-024: every figure the report states names the row and the column it answers', () => {
    draw(report());
    const table = screen.getByRole('table');
    const headers = within(table).getAllByRole('columnheader');
    const rows = within(table).getAllByRole('row').filter((item) => within(item).queryAllByRole('rowheader').length > 0);

    expect(headers.length).toBeGreaterThan(1);
    expect(rows.length).toBeGreaterThan(0);
    for (const rowElement of rows) {
      expect(within(rowElement).getAllByRole('rowheader')).toHaveLength(1);
      expect(within(rowElement).getAllByRole('cell')).toHaveLength(headers.length - 1);
    }
  });

  it('MH-USAGE-025: reads a window whose reports all came back zero as measured, not as missing', () => {
    const measuredZero = counters({
      requests: 4,
      token_reports: 4,
      input_tokens: 0,
      cached_input_tokens: 0,
      output_tokens: 0,
    });
    const { container } = draw(report({
      totals: measuredZero,
      sources: [],
      buckets: [bucket('00', [row(measuredZero)])],
    }));

    expect(container.textContent).not.toContain('Some requests have no token report');
    const card = container.querySelector('.model-hub-usage-stat-label')?.parentElement;
    expect(card?.textContent).toContain('0');
  });

  it('does not claim a 100% share when the selected total is zero', () => {
    const measuredZero = counters({
      requests: 4,
      token_reports: 4,
      input_tokens: 0,
      cached_input_tokens: 0,
      output_tokens: 0,
    });
    const { container } = draw(report({
      totals: measuredZero,
      sources: [],
      buckets: [bucket('00', [row(measuredZero)])],
    }));

    expect(container.querySelector('tfoot')?.textContent).not.toContain('100%');
  });

  it('MH-USAGE-026: every token figure on screen states its own coverage', () => {
    const unreported = counters({
      requests: 2,
      token_reports: 0,
      input_tokens: 0,
      cached_input_tokens: 0,
      output_tokens: 0,
    });
    const { container } = draw(report({
      totals: unreported,
      sources: [],
      buckets: [bucket('00', [row(unreported)])],
    }));

    expect(container.textContent).toContain('Some requests have no token report; token values are unavailable');
    expect(container.querySelector('.model-hub-usage-table-scroll')?.textContent).toContain('—');
  });

  it('MH-USAGE-027: keeps the usage surface within a narrow semantic layout', () => {
    const { container } = draw(report());
    const chart = container.querySelector('.model-hub-usage-chart-wrap');
    const tableScroll = container.querySelector('.model-hub-usage-table-scroll');

    expect(chart).not.toBeNull();
    expect(tableScroll).not.toBeNull();
    expect(screen.getAllByRole('button', { name: /Usage bucket/ })).toHaveLength(3);
  });

  // API price is a report beside the token counts: offered only when the server
  // priced the report, never read as a charge, and never $0 for a model with no
  // price.
  const pricedReport = (): UsageReport => {
    const cost = (usd: number, excluded = 0) => ({ api_cost_usd: usd, excluded_tokens: excluded, api_cost_lower_bound: false });
    const pricedRow = row(cost(0.5));
    const unpricedRow = row({ source_id: 'source-b', model_id: 'relay-model', ...cost(0, 140) });
    return report({
      totals: counters({ requests: 4, token_reports: 4, input_tokens: 200, cached_input_tokens: 50, output_tokens: 80, ...cost(0.5, 140) }),
      sources: [
        { source_id: 'source-a', label: 'Claude', last_metered_at: null, ...counters(cost(0.5)),
          models: [{ model_id: 'model-a', label: 'Opus', ...counters(cost(0.5)) }] },
        { source_id: 'source-b', label: 'Relay', last_metered_at: null, ...counters(cost(0, 140)),
          models: [{ model_id: 'relay-model', label: 'Relay model', ...counters(cost(0, 140)) }] },
      ],
      buckets: [bucket('00', [pricedRow, unpricedRow])],
      pricing: { currency: 'USD', price_table_date: '2026-09-23' },
    });
  };
  // No price is not an amount: its table cell reads muted, never in the money colour.
  const mutedCostCells = (root: Element) => [...root.querySelectorAll('tbody .model-hub-usage-table-total.is-unpriced')]
    .map((cell) => cell.textContent);

  it('MH-USAGE-030: offers the API-price metric only for a priced report', () => {
    draw(report());
    const metric = () => screen.getByRole('combobox', { name: 'Metric' }) as HTMLSelectElement;
    expect([...metric().options].map((option) => option.value)).not.toContain('cost');
    cleanup();
    draw(pricedReport());
    expect([...metric().options].map((option) => option.value)).toContain('cost');
  });

  it('MH-USAGE-029: states the API-price value, what it leaves out, and its price table', async () => {
    const { container } = draw(pricedReport());
    const stats = container.querySelector('.model-hub-usage-stat-grid--priced');
    expect(stats).not.toBeNull();
    expect(stats!.textContent).toContain('At API price');
    expect(stats!.textContent).toContain('$0.50');
    expect(stats!.textContent).toContain('At published API prices, not a charge');
    expect(stats!.textContent).toContain('140 tokens have no price and are left out');
    expect(stats!.textContent).toContain('Price table from 2026-09-23');

    await userEvent.selectOptions(screen.getByRole('combobox', { name: 'Metric' }), 'cost');
    expect(container.querySelector('.model-hub-usage-cost-note')?.textContent).toBe('At published API prices, not a charge');
    expect(container.querySelector('.model-hub-usage-table-scroll')?.textContent).toContain('No price yet');
    expect(container.querySelector('.model-hub-usage-table-scroll')?.textContent).toContain('$0.50');
    expect(container.querySelector('.model-hub-usage-table-scroll')?.textContent).not.toContain('≥');
    expect(container.querySelector('.model-hub-usage-table-scroll tbody')?.textContent).toMatch(/\d%/);
    expect(mutedCostCells(container)).toEqual(['No price yet']);
    cleanup();

    // A floor keeps its 「≥」 in the itemized rows and the table total, not only the card.
    const floor = pricedReport();
    const lower = <T extends object>(value: T): T => ({ ...value, api_cost_lower_bound: true });
    floor.buckets = floor.buckets.map((item) => ({ ...item, rows: item.rows.map((entry, index) => (index === 0 ? lower(entry) : entry)) }));
    floor.sources = floor.sources.map((source, index) => (index === 0 ? { ...lower(source), models: source.models.map(lower) } : source));
    floor.totals = lower(floor.totals);
    const drawn = draw(floor);
    await userEvent.selectOptions(screen.getByRole('combobox', { name: 'Metric' }), 'cost');
    const table = drawn.container.querySelector('.model-hub-usage-table-scroll')!;
    expect(table.querySelector('tbody')!.textContent).toContain('≥ $0.50');
    expect(table.querySelector('tfoot')!.textContent).toContain('≥ $0.50');
    // A floor is still money; only the row with nothing priced reads muted.
    expect(mutedCostCells(table)).toEqual(['No price yet']);
    // A share of a floor total is not a known fraction.
    expect(table.querySelector('tbody')!.textContent).not.toMatch(/\d%/);
  });

  it('MH-USAGE-032: a floor bucket reads 「≥」 in the chart legend and the bucket detail, an exact one does not', async () => {
    const floor = pricedReport();
    floor.buckets = [
      bucket('00', [row({ api_cost_usd: 0.5, excluded_tokens: 0, api_cost_lower_bound: true })]),
      bucket('01', [row({ api_cost_usd: 0.25, excluded_tokens: 0, api_cost_lower_bound: false })]),
    ];
    const { container } = draw(floor);
    await userEvent.selectOptions(screen.getByRole('combobox', { name: 'Metric' }), 'cost');
    expect(container.querySelector('.model-hub-usage-legend')!.textContent).toContain('≥ $0.75');

    const buckets = screen.getAllByRole('button', { name: /Usage bucket/ });
    fireEvent.pointerEnter(buckets[0]);
    const detail = () => screen.getByRole('dialog', { name: 'Usage bucket details' });
    expect(detail().querySelector('.model-hub-usage-tooltip-total')!.textContent).toContain('≥ $0.50');
    expect(detail().querySelector('.model-hub-usage-tooltip-lines')!.textContent).toContain('≥ $0.50');
    fireEvent.pointerEnter(buckets[1]);
    await screen.findByText('$0.25', { selector: '.model-hub-usage-tooltip-total strong' });
    expect(detail().textContent).not.toContain('≥');
  });

  it('MH-USAGE-033: a cost with nothing priced reads no price on every surface, a partial one 「≥」, a full one exact', async () => {
    const cost = (usd: number, excluded: number, floor: boolean) => ({ api_cost_usd: usd, excluded_tokens: excluded, api_cost_lower_bound: floor });
    // Bucket 00 has only an unpriced model; bucket 01 a priced one beside it; bucket 02 is fully priced.
    const relay = (over: Partial<UsageBucketRow>) => row({ source_id: 'source-b', model_id: 'relay-model', ...cost(0, 140, true), ...over });
    const value = pricedReport();
    value.buckets = [
      bucket('00', [relay({})]),
      bucket('01', [row(cost(0.5, 0, false)), relay({})]),
      bucket('02', [row(cost(0.25, 0, false))]),
    ];
    const { container } = draw(value);
    await userEvent.selectOptions(screen.getByRole('combobox', { name: 'Metric' }), 'cost');
    await userEvent.click(screen.getByRole('button', { name: 'Model' }));
    const legend = () => container.querySelector('.model-hub-usage-legend')!;
    // The unpriced model's legend total is no price, never 「≥ $0.00」; the priced one's is exact.
    expect(legend().textContent).toContain('No price yet');
    expect(legend().textContent).toContain('$0.75');
    expect(legend().textContent).not.toContain('$0.00');

    const buckets = screen.getAllByRole('button', { name: /Usage bucket/ });
    const detail = () => screen.getByRole('dialog', { name: 'Usage bucket details' });
    fireEvent.pointerEnter(buckets[0]);
    const relayLine = () => within(detail().querySelector('.model-hub-usage-tooltip-lines') as HTMLElement)
      .getByText('Relay · Relay model').closest('div')!.textContent;
    expect(detail().querySelector('.model-hub-usage-tooltip-total')!.textContent).toBe('No price yetAt API price');
    expect(relayLine()).toContain('No price yet');
    fireEvent.pointerEnter(buckets[1]);
    await screen.findByText('≥ $0.50', { selector: '.model-hub-usage-tooltip-total strong' });
    // Within a partly priced bucket, the line with nothing priced still says so.
    expect(relayLine()).toContain('No price yet');
    fireEvent.pointerEnter(buckets[2]);
    await screen.findByText('$0.25', { selector: '.model-hub-usage-tooltip-total strong' });

    // Pinned to the unpriced bucket, the table total has nothing priced either.
    fireEvent.pointerEnter(buckets[0]);
    await userEvent.click(screen.getByRole('button', { name: 'Pin this bucket' }));
    const table = container.querySelector('.model-hub-usage-table-scroll')!;
    expect(table.querySelector('tbody')!.textContent).toContain('No price yet');
    expect(table.querySelector('tfoot .model-hub-usage-table-total, tfoot td:nth-last-child(2)')!.textContent).toBe('No price yet');
    expect(table.textContent).not.toContain('$0.00');
  });

  it('MH-PRICE-014: while the first price table is still being fetched, says so rather than no price', async () => {
    const value = pricedReport();
    value.pricing = { currency: 'USD', price_table_date: null, pending: true };
    value.totals = { ...value.totals, api_cost_usd: 0, excluded_tokens: 280, api_cost_lower_bound: true };
    value.buckets = value.buckets.map((item) => ({ ...item, rows: item.rows.map((entry) => ({ ...entry, api_cost_usd: 0, excluded_tokens: 140, api_cost_lower_bound: true })) }));
    const { container } = draw(value);
    const stats = container.querySelector('.model-hub-usage-stat-grid--priced')!;
    expect(stats.textContent).toContain('Fetching prices…');
    expect(stats.textContent).toContain('Fetching the price table…');
    expect(stats.textContent).not.toContain('No price yet');
    await userEvent.selectOptions(screen.getByRole('combobox', { name: 'Metric' }), 'cost');
    expect(container.querySelector('.model-hub-usage-legend')!.textContent).toContain('Fetching prices…');
    expect(container.querySelector('.model-hub-usage-table-scroll')!.textContent).toContain('Fetching prices…');
    expect(container.textContent).not.toContain('No price yet');
    expect(mutedCostCells(container)).toEqual(['Fetching prices…', 'Fetching prices…']);
  });

  it('MH-USAGE-031: reads the API-price value in Chinese as a conversion, not a charge', async () => {
    await i18n.addResourceBundle('zh', 'translation', zh, true, true);
    await i18n.changeLanguage('zh');
    try {
      const { container } = draw(pricedReport());
      const stats = container.querySelector('.model-hub-usage-stat-grid--priced')!;
      expect(stats.textContent).toContain('折合 API 价格');
      expect(stats.textContent).toContain('不是实际扣费');
      expect(stats.textContent).toContain('价格表日期 2026-09-23');
      await userEvent.selectOptions(screen.getByRole('combobox', { name: '指标' }), 'cost');
      expect(container.querySelector('.model-hub-usage-cost-note')?.textContent).toContain('不是实际扣费');
      expect(container.querySelector('.model-hub-usage-table-scroll')?.textContent).toContain('暂无价格');
    } finally {
      await i18n.changeLanguage('en');
    }
  });

  it('MH-USAGE-037: tables search services below the models, adding only their cost to the API-price total', async () => {
    const search = (over: Partial<UsageServiceBucketRow> = {}): UsageServiceBucketRow => ({
      kind: 'service', source_id: 'src_exa', service_id: 'exa/search', requests: 3, billable_requests: 2, uncertain_requests: 1,
      reported_requests: 2, reported_usd: 0.0135, api_cost_usd: 0.014, api_cost_lower_bound: true, ...over,
    });
    const listing = (entry: UsageServiceBucketRow, over: Partial<ServiceUsage> = {}): ServiceUsage => ({
      source_id: entry.source_id, service_id: entry.service_id, label: null, service_label: null, last_metered_at: null,
      requests: entry.requests, billable_requests: entry.billable_requests, uncertain_requests: entry.uncertain_requests,
      reported_requests: entry.reported_requests, ...over,
    });
    const exa = search();
    // A deleted Source, on a service a later catalog no longer prices.
    const retired = search({ source_id: 'src_gone', service_id: 'retired/search', requests: 1, billable_requests: 1, uncertain_requests: 0, reported_requests: 0, reported_usd: 0, api_cost_usd: 0 });
    const value = pricedReport();
    value.buckets = [bucket('00', [...value.buckets[0]!.rows, exa, retired])];
    value.services = [listing(exa, { label: 'Exa key', service_label: 'Exa', priced: true }), listing(retired, { priced: false })];
    value.pricing = { ...value.pricing!, service_price_date: '2026-10-19' };
    const { container } = draw(value);

    const stats = container.querySelector('.model-hub-usage-stat-grid--priced')!;
    // The model calls alone, and every cost beside the vendors' own figure.
    expect(stats.textContent).toContain('Requests4');
    expect(stats.textContent).toContain('≥ $0.51');
    expect(stats.textContent).toContain('Vendors reported $0.01');
    expect(stats.textContent).toContain('1 search request has no price and is left out');
    const services = within(screen.getByRole('region', { name: /^Search services/ }));
    const rowsOf = (scope: HTMLElement) => [...scope.querySelectorAll('tbody tr')].map((line) => [...line.children].map((cell) => cell.textContent));
    expect(rowsOf(services.getByRole('table'))).toEqual([
      ['Exa keyExa', '3', '2+1 with unknown billing', '≥ $0.01', '$0.01'],
      ['Removed providersUsage kept after these providers were deleted', '1', '1', 'No price yet', '—'],
    ]);
    expect(services.getByRole('table').querySelector('tfoot')!.textContent).toBe('Total43+1 with unknown billing≥ $0.01$0.01');
    expect(services.getByText(/Search prices from 2026-10-19/)).toBeTruthy();
    const details = within(screen.getByRole('region', { name: /^Exact usage details/ }));
    expect(details.queryByText(/Exa key|Removed providers/)).toBeNull();
    // Exports and the model filter are model usage only; a tool-only Source is a Source.
    expect(buildUsageCsv(value, { sourceIds: [], modelKeys: [] }, null, CSV_HEADERS, 'Unknown model')).not.toContain('search');
    await userEvent.click(screen.getByRole('button', { name: 'All Source' }));
    const options = (label: string) => within(screen.getByRole('listbox', { name: label })).getAllByRole('option').map((option) => option.textContent);
    expect(options('Source')).toEqual(['All Source', 'Claude', 'Relay', 'Exa key', 'Removed providers']);
    await userEvent.keyboard('{Escape}');
    await userEvent.click(screen.getByRole('button', { name: 'All Model' }));
    expect(options('Model')).toEqual(['All Model', 'Claude · Opus', 'Relay · Relay model']);
    await userEvent.click(screen.getByRole('option', { name: 'Claude · Opus' }));
    expect(services.getByText('No matching usage')).toBeTruthy();
    expect(stats.textContent).toContain('$0.50');
    cleanup();

    // Search alone is usage, and without a price table it reads counts only.
    const counted: UsageServiceBucketRow = {
      kind: 'service', source_id: 'src_exa', service_id: 'exa/search', requests: 3, billable_requests: 2, uncertain_requests: 1, reported_requests: 2,
    };
    const only = draw(report({ sources: [], services: [listing(counted, { label: 'Exa key' })], buckets: [bucket('00', [counted])] }));
    expect(screen.queryByText('No usage in this window')).toBeNull();
    expect(only.container.querySelector('.model-hub-usage-stat-grid')!.textContent).toContain('Requests0');
    const countsOnly = within(screen.getByRole('region', { name: /^Search services/ })).getByRole('table');
    expect([...countsOnly.querySelectorAll('thead th')].map((cell) => cell.textContent)).toEqual(['Source / service', 'Requests', 'Billable']);
  });

  it('renders exact accounting and preserves source/model pair rows', () => {
    const second = row({ source_id: 'source-b', model_id: 'model-a' });
    const value = report({
      totals: counters({ requests: 4, token_reports: 4, input_tokens: 200, cached_input_tokens: 50, output_tokens: 80 }),
      sources: [
        {
          source_id: 'source-a',
          label: 'Same source label',
          last_metered_at: null,
          ...counters(),
          models: [{ model_id: 'model-a', label: 'Same model label', ...counters() }],
        },
        {
          source_id: 'source-b',
          label: 'Same source label',
          last_metered_at: null,
          ...counters(),
          models: [{ model_id: 'model-a', label: 'Same model label', ...counters() }],
        },
      ],
      buckets: [bucket('00', [row(), second]), bucket('01', []), bucket('02', [])],
    });
    draw(value);

    expect(screen.getByText('Same source label · Same model label')).toBeTruthy();
    expect(screen.getByText('Same source label (2) · Same model label')).toBeTruthy();
    expect(screen.getByText('All tokens = input + output. Cache reads are included in input and shown separately.')).toBeTruthy();
    expect(screen.getAllByText('50.0%').length).toBeGreaterThan(0);
  });

  it('keeps incomplete empty buckets out of the ordinary empty state and shows gaps', () => {
    const incomplete = report({
      totals: counters({ requests: 0, token_reports: 0, input_tokens: 0, cached_input_tokens: 0, output_tokens: 0 }),
      sources: [],
      buckets: [
        bucket('00', [], { history_complete: false }),
        bucket('01', [], { history_complete: false }),
        bucket('02', [], { history_complete: false }),
      ],
    });
    const { container } = draw(incomplete);

    expect(screen.getAllByText('Some buckets have incomplete history').length).toBeGreaterThan(0);
    expect(screen.queryByText('No usage in this window')).toBeNull();
    expect(container.querySelectorAll('.model-hub-usage-unknown-point')).toHaveLength(9);
    expect(screen.getAllByText('—').length).toBeGreaterThan(0);
  });

  it.each([
    ['en', 'Includes historical usage without hourly time'],
    ['zh', '含无具体小时记录的历史用量'],
  ])('shows one localized historical-hourly notice in %s, only for incomplete hourly reports', async (language, note) => {
    const translated = createInstance();
    await translated.use(initReactI18next).init({
      lng: language,
      fallbackLng: 'en',
      resources: { en: { translation: en }, zh: { translation: zh } },
      interpolation: { escapeValue: false },
    });
    const page = (value: UsageReport) => (
      <I18nextProvider i18n={translated}>
        <UsageTab usage={readyRegion(value)} windowKey={value.window_key} onWindowChange={vi.fn()} />
      </I18nextProvider>
    );
    const partial = report({ buckets: [bucket('00', [row()], { history_complete: false })] });
    const { rerender } = render(page(partial));

    expect(screen.getAllByText(note)).toHaveLength(1);
    expect(within(screen.getByRole('status')).getByText(note)).toBeTruthy();
    rerender(page(report()));
    expect(screen.queryByText(note)).toBeNull();
    rerender(page({ ...partial, window_key: '7d', granularity: 'day' }));
    expect(screen.queryByText(note)).toBeNull();
  });

  it('keeps ordinary detail dismissible and pins directly from hover', async () => {
    const { container } = draw(report());
    const buckets = screen.getAllByRole('button', { name: /Usage bucket/ });
    fireEvent.pointerEnter(buckets[0]);
    expect(screen.getByRole('dialog', { name: 'Usage bucket details' })).toBeTruthy();

    fireEvent.pointerDown(document.body);
    expect(screen.queryByRole('dialog', { name: 'Usage bucket details' })).toBeNull();

    fireEvent.pointerEnter(buckets[1]);
    const pin = screen.getByRole('button', { name: 'Pin this bucket' });
    await userEvent.click(pin);
    expect(screen.getByRole('dialog', { name: 'Usage bucket details' }).getAttribute('data-pinned')).toBe('true');
    fireEvent.pointerDown(document.body);
    expect(screen.getByRole('dialog', { name: 'Usage bucket details' })).toBeTruthy();
    expect(container.querySelector('.model-hub-usage-details-header p')?.textContent).toContain('Showing Sep 24, 2026');

    await userEvent.click(screen.getByRole('button', { name: 'Unpin this bucket' }));
    expect(screen.getByRole('dialog', { name: 'Usage bucket details' }).getAttribute('data-pinned')).toBe('false');
    fireEvent.pointerDown(document.body);
    expect(screen.queryByRole('dialog', { name: 'Usage bucket details' })).toBeNull();
  });

  it('moves keyboard focus into detail and restores the bucket without reopening on Escape', async () => {
    const rendered = draw(report());
    const bucketButton = screen.getAllByRole('button', { name: /Usage bucket/ })[0]!;
    const user = userEvent.setup();

    for (let step = 0; step < 32 && document.activeElement !== bucketButton; step += 1) {
      await user.tab();
    }
    expect(document.activeElement).toBe(bucketButton);

    await user.keyboard('{Enter}');
    const pin = screen.getByRole('button', { name: 'Pin this bucket' });
    expect(document.activeElement).toBe(pin);

    await user.keyboard('{Escape}');
    expect(screen.queryByRole('dialog', { name: 'Usage bucket details' })).toBeNull();
    expect(document.activeElement).toBe(bucketButton);

    await user.keyboard(' ');
    const repinned = screen.getByRole('button', { name: 'Pin this bucket' });
    expect(document.activeElement).toBe(repinned);

    await user.keyboard('{Enter}');
    expect(screen.getByRole('dialog', { name: 'Usage bucket details' }).getAttribute('data-pinned')).toBe('true');

    rendered.rerender(
      <I18nextProvider i18n={i18n}>
        <UsageTab
          usage={readyRegion(report({ buckets: [bucket('00', [row({ requests: 3 })]), bucket('01'), bucket('02')] }))}
          windowKey="24h"
          onWindowChange={vi.fn()}
        />
      </I18nextProvider>,
    );

    expect(screen.getByRole('dialog', { name: 'Usage bucket details' }).getAttribute('data-pinned')).toBe('true');
    expect(document.activeElement).toBe(screen.getByRole('button', { name: 'Unpin this bucket' }));

    await user.keyboard('{Escape}');
    expect(screen.queryByRole('dialog', { name: 'Usage bucket details' })).toBeNull();
    expect(document.activeElement).toBe(bucketButton);

    // A non-modal detail must not reclaim focus after the user tabs elsewhere.
    await user.keyboard('{Enter}');
    await user.tab();
    const tableGrouping = screen.getByRole('button', { name: 'By model' });
    expect(document.activeElement).toBe(tableGrouping);
    await user.keyboard('{Escape}');
    expect(screen.queryByRole('dialog', { name: 'Usage bucket details' })).toBeNull();
    expect(document.activeElement).toBe(tableGrouping);
  });

  it('dismisses pinned details on the first Escape', async () => {
    draw(report());
    fireEvent.pointerEnter(screen.getAllByRole('button', { name: /Usage bucket/ })[0]!);
    await userEvent.click(screen.getByRole('button', { name: 'Pin this bucket' }));
    expect(screen.getByRole('dialog', { name: 'Usage bucket details' })).toBeTruthy();

    fireEvent.keyDown(document, { key: 'Escape' });

    expect(screen.queryByRole('dialog', { name: 'Usage bucket details' })).toBeNull();
  });

  it('clears a pinned bucket that disappears from a same-window refresh', async () => {
    const value = report();
    const rendered = draw(value);
    fireEvent.pointerEnter(screen.getAllByRole('button', { name: /Usage bucket/ })[1]!);
    await userEvent.click(screen.getByRole('button', { name: 'Pin this bucket' }));
    expect(screen.getByRole('dialog', { name: 'Usage bucket details' }).getAttribute('data-pinned')).toBe('true');

    rendered.rerender(
      <I18nextProvider i18n={i18n}>
        <UsageTab usage={readyRegion(report({ buckets: [bucket('00')] }))} windowKey="24h" onWindowChange={vi.fn()} />
      </I18nextProvider>,
    );

    expect(screen.queryByRole('dialog', { name: 'Usage bucket details' })).toBeNull();
    expect(rendered.container.querySelector('.model-hub-usage-details-header p')?.textContent).toContain('same filters');
  });

  it('shows both offsets in the report heading across a DST change', () => {
    const { container } = draw(report({
      from_at: '2026-11-01T01:00:00-04:00',
      to_at: '2026-11-01T01:00:00-05:00',
    }));

    expect(container.textContent).toContain('UTC-04:00');
    expect(container.textContent).toContain('UTC-05:00');
  });

  it('includes both bucket offsets in DST-adjacent detail text', () => {
    const dst = report({
      buckets: [bucket('00', [row()], {
        start_at: '2026-11-01T01:00:00-04:00',
        end_at: '2026-11-01T01:00:00-05:00',
      })],
    });
    draw(dst);
    fireEvent.pointerEnter(screen.getByRole('button', { name: /Usage bucket/ }));
    expect(screen.getByRole('dialog').textContent).toContain('UTC-04:00');
    expect(screen.getByRole('dialog').textContent).toContain('UTC-05:00');
  });

  it('labels the current 24-hour bucket when it is only partially elapsed', () => {
    const value = report({
      to_at: '2026-09-24T02:15:00+08:00',
      buckets: [
        bucket('00'),
        bucket('01'),
        bucket('02', [row()], { end_at: '2026-09-24T02:15:00+08:00' }),
      ],
    });
    draw(value);

    fireEvent.pointerEnter(screen.getAllByRole('button', { name: /Usage bucket/ })[2]!);

    expect(screen.getByRole('dialog').textContent).toContain('Current partial hour');
    expect(screen.getByRole('dialog').textContent).toContain('History complete');
  });

  it('neutralizes formula-like supplier/model labels without quoting numeric counters', () => {
    expect(csvCell('=supplier')).toBe("'=supplier");
    expect(csvCell('@model')).toBe("'@model");
    expect(csvCell('\tmodel')).toBe("'\tmodel");
    expect(csvCell(120)).toBe('120');
  });

  it('exports pinned raw rows with identity and interval metadata', () => {
    const value = report({
      sources: [{
        source_id: 'source-formula',
        label: '=supplier',
        last_metered_at: null,
        ...counters({ input_tokens: 148230, cached_input_tokens: 96010, output_tokens: 4120 }),
        models: [{ model_id: 'model-formula', label: '@model', ...counters() }],
      }],
      buckets: [
        bucket('00', [row({
          source_id: 'source-formula',
          model_id: 'model-formula',
          requests: 4,
          token_reports: 1,
          input_tokens: 148230,
          cached_input_tokens: 96010,
          output_tokens: 4120,
        })]),
        bucket('01', [row()]),
      ],
    });
    const headers = {
      bucketKey: 'bucket_key',
      startAt: 'start_at',
      endAt: 'end_at',
      historyComplete: 'history_complete',
      sourceId: 'source_id',
      modelId: 'model_id',
      ledgerKey: 'ledger_key',
      sourceLabel: 'source_label',
      modelLabel: 'model_label',
      requests: 'requests',
      tokenReports: 'token_reports',
      inputTokens: 'input_tokens',
      nonCachedInputTokens: 'non_cached_input_tokens',
      cachedInputTokens: 'cached_input_tokens',
      outputTokens: 'output_tokens',
      totalTokens: 'total_tokens',
    };
    const csv = buildUsageCsv(value, { sourceIds: [], modelKeys: [] }, '00', headers, 'Unknown model');

    expect(csv.split('\r\n')).toHaveLength(2);
    expect(csv).toContain('2026-09-24T00:00:00+08:00');
    expect(csv).toContain("source-formula,'@model,model-formula");
    expect(csv).toContain("'=supplier");
    expect(csv).toContain("'@model");
    expect(csv).toContain('4,1,148230');
    expect(csv).toContain('148230');
    expect(csv).not.toContain('148,230');
    expect(csv).toContain('152350');

    const unknownCsv = buildUsageCsv(report({
      buckets: [bucket('00', [row({ token_reports: 0 })])],
    }), { sourceIds: [], modelKeys: [] }, '00', headers, 'Unknown model');
    expect(unknownCsv.split('\r\n')[0]).toContain('token_reports');
    expect(unknownCsv.split('\r\n')[1]?.split(',').slice(-7)).toEqual(['2', '0', '', '', '', '', '']);

    const idleCsv = buildUsageCsv(report({
      buckets: [bucket('00', [])],
    }), { sourceIds: [], modelKeys: [] }, '00', headers, 'Unknown model');
    expect(idleCsv.split('\r\n')[1]?.split(',').slice(-7)).toEqual(['0', '0', '0', '0', '0', '0', '0']);
  });

  it('does not export a folded ledger key as the canonical model ID', () => {
    const foldedKey = `model-head-${'x'.repeat(180)}`;
    const csv = buildUsageCsv(report({
      sources: [{
        source_id: 'source-removed',
        label: null,
        last_metered_at: null,
        ...counters(),
        models: [],
      }],
      buckets: [bucket('00', [row({
        source_id: 'source-removed',
        model_id: foldedKey,
      })])],
    }), { sourceIds: [], modelKeys: [] }, '00', {
      bucketKey: 'bucket_key',
      startAt: 'start_at',
      endAt: 'end_at',
      historyComplete: 'history_complete',
      sourceId: 'source_id',
      modelId: 'model_id',
      ledgerKey: 'ledger_key',
      sourceLabel: 'source_label',
      modelLabel: 'model_label',
      requests: 'requests',
      tokenReports: 'token_reports',
      inputTokens: 'input_tokens',
      nonCachedInputTokens: 'non_cached_input_tokens',
      cachedInputTokens: 'cached_input_tokens',
      outputTokens: 'output_tokens',
      totalTokens: 'total_tokens',
    }, 'Unknown model');

    const [header, line] = csv.split('\r\n');
    expect(header).toContain('model_id,ledger_key');
    expect(line?.split(',').slice(5, 7)).toEqual(['', foldedKey]);
  });
});