revert: remove usage elapsed clock calibration

frontend/src/features/usage/composables/__tests__/activeElapsedDisplayClockRenderScope.spec.ts

@@ -1,79 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest'
-import { createApp, defineComponent, h, nextTick, ref, type App, type Ref } from 'vue'
-import {
-  provideActiveElapsedDisplayClock,
-  useActiveElapsedDisplayNowMs,
-} from '../useActiveElapsedDisplayClock'
-
-const mountedApps: Array<{ app: App, root: HTMLElement }> = []
-
-afterEach(() => {
-  for (const { app, root } of mountedApps.splice(0)) {
-    app.unmount()
-    root.remove()
-  }
-})
-
-function mountApp(component: ReturnType<typeof defineComponent>) {
-  const root = document.createElement('div')
-  document.body.appendChild(root)
-
-  const app = createApp(component)
-  app.mount(root)
-  mountedApps.push({ app, root })
-  return root
-}
-
-describe('active elapsed display clock render scope', () => {
-  it('updates injected elapsed text without re-rendering the surrounding table', async () => {
-    const displayNowMs = ref(1_000)
-    const rows = Array.from({ length: 1_000 }, (_, index) => ({
-      id: `row-${index}`,
-      model: `model-${index}`,
-    }))
-    let tableRenderCount = 0
-    let elapsedRenderCount = 0
-
-    const ElapsedTextProbe = defineComponent({
-      name: 'ElapsedTextProbe',
-      setup() {
-        const injectedDisplayNowMs = useActiveElapsedDisplayNowMs()
-        return () => {
-          elapsedRenderCount += 1
-          return h('span', injectedDisplayNowMs?.value)
-        }
-      },
-    })
-
-    const TableProbe = defineComponent({
-      name: 'TableProbe',
-      setup() {
-        return () => {
-          tableRenderCount += 1
-          return h('table', rows.map(row => h('tr', { key: row.id }, [
-            h('td', row.model),
-            row.id === 'row-0' ? h('td', h(ElapsedTextProbe)) : h('td', '-'),
-          ])))
-        }
-      },
-    })
-
-    const Harness = defineComponent({
-      name: 'Harness',
-      setup() {
-        provideActiveElapsedDisplayClock(displayNowMs as Ref<number>)
-        return () => h(TableProbe)
-      },
-    })
-
-    mountApp(Harness)
-    expect(tableRenderCount).toBe(1)
-    expect(elapsedRenderCount).toBe(1)
-
-    displayNowMs.value = 1_250
-    await nextTick()
-
-    expect(tableRenderCount).toBe(1)
-    expect(elapsedRenderCount).toBe(2)
-  })
-})

frontend/src/features/usage/composables/__tests__/useActiveElapsedDisplayClock.spec.ts

@@ -1,101 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { nextTick, ref } from 'vue'
-import { useActiveElapsedDisplayClock } from '../useActiveElapsedDisplayClock'
-
-type TestRecord = {
-  status: string
-}
-
-afterEach(() => {
-  vi.useRealTimers()
-})
-
-describe('useActiveElapsedDisplayClock', () => {
-  it('ticks only while visible active records exist', async () => {
-    vi.useFakeTimers()
-    let nowMs = 1_000
-
-    const records = ref<TestRecord[]>([])
-    const isPageVisible = ref(true)
-    const serverClockOffsetMs = ref(0)
-    const hasServerClockOffset = ref(false)
-    const clock = useActiveElapsedDisplayClock({
-      records,
-      isPageVisible,
-      serverClockOffsetMs,
-      hasServerClockOffset,
-      resolveStatus: record => record.status,
-      intervalMs: 250,
-      now: () => nowMs,
-    })
-
-    expect(clock.hasVisibleActiveRecords.value).toBe(false)
-    expect(clock.displayNowMs.value).toBe(1_000)
-
-    nowMs = 1_250
-    vi.advanceTimersByTime(250)
-    expect(clock.displayNowMs.value).toBe(1_000)
-
-    records.value = [{ status: 'streaming' }]
-    await nextTick()
-    expect(clock.hasVisibleActiveRecords.value).toBe(true)
-    expect(clock.displayNowMs.value).toBe(1_250)
-
-    nowMs = 1_500
-    vi.advanceTimersByTime(250)
-    expect(clock.displayNowMs.value).toBe(1_500)
-
-    isPageVisible.value = false
-    await nextTick()
-    nowMs = 1_750
-    vi.advanceTimersByTime(250)
-    expect(clock.displayNowMs.value).toBe(1_500)
-
-    clock.stopActiveElapsedDisplayClock()
-  })
-
-  it('applies server clock offset to the display time', () => {
-    vi.useFakeTimers()
-
-    const clock = useActiveElapsedDisplayClock({
-      records: ref<TestRecord[]>([{ status: 'pending' }]),
-      isPageVisible: ref(true),
-      serverClockOffsetMs: ref(-11_000),
-      hasServerClockOffset: ref(true),
-      resolveStatus: record => record.status,
-      intervalMs: 250,
-      now: () => 2_000,
-    })
-
-    expect(clock.calibratedDisplayNowMs.value).toBe(-9_000)
-    clock.stopActiveElapsedDisplayClock()
-  })
-
-  it('stops when active records disappear', async () => {
-    vi.useFakeTimers()
-    let nowMs = 3_000
-
-    const records = ref<TestRecord[]>([{ status: 'pending' }])
-    const clock = useActiveElapsedDisplayClock({
-      records,
-      isPageVisible: ref(true),
-      serverClockOffsetMs: ref(0),
-      hasServerClockOffset: ref(false),
-      resolveStatus: record => record.status,
-      intervalMs: 250,
-      now: () => nowMs,
-    })
-
-    nowMs = 3_250
-    vi.advanceTimersByTime(250)
-    expect(clock.displayNowMs.value).toBe(3_250)
-
-    records.value = [{ status: 'completed' }]
-    await nextTick()
-    nowMs = 3_500
-    vi.advanceTimersByTime(250)
-    expect(clock.displayNowMs.value).toBe(3_250)
-
-    clock.stopActiveElapsedDisplayClock()
-  })
-})

frontend/src/features/usage/composables/__tests__/useServerClock.spec.ts

@@ -1,102 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  calculateServerClockOffsetMs,
-  shouldUseServerClockSample,
-  useServerClock
-} from '../useServerClock'
-
-describe('useServerClock', () => {
-  it('calculates offset from the response receive time', () => {
-    const offset = calculateServerClockOffsetMs({
-      server_now_unix_ms: 10_500,
-      client_send_unix_ms: 20_000,
-      client_receive_unix_ms: 20_200,
-      round_trip_ms: 200,
-    })
-
-    expect(offset).toBe(-9_700)
-  })
-
-  it('ignores missing or invalid timing samples', () => {
-    expect(calculateServerClockOffsetMs(undefined)).toBeNull()
-    expect(calculateServerClockOffsetMs({
-      server_now_unix_ms: Number.NaN,
-      client_send_unix_ms: 20_000,
-      client_receive_unix_ms: 20_200,
-      round_trip_ms: 200,
-    })).toBeNull()
-    expect(calculateServerClockOffsetMs({
-      server_now_unix_ms: 10_500,
-      client_send_unix_ms: 20_200,
-      client_receive_unix_ms: 20_000,
-      round_trip_ms: 200,
-    })).toBeNull()
-    expect(calculateServerClockOffsetMs({
-      server_now_unix_ms: 10_500,
-      client_send_unix_ms: 20_000,
-      client_receive_unix_ms: 20_200,
-      round_trip_ms: Number.NaN,
-    })).toBeNull()
-  })
-
-  it('keeps the previous offset when a response has no server timing', () => {
-    const clock = useServerClock()
-
-    clock.updateServerClockOffset({
-      server_now_unix_ms: 10_500,
-      client_send_unix_ms: 20_000,
-      client_receive_unix_ms: 20_200,
-      round_trip_ms: 200,
-    })
-    clock.updateServerClockOffset(undefined)
-
-    expect(clock.hasServerClockOffset.value).toBe(true)
-    expect(clock.serverClockOffsetMs.value).toBe(-9_700)
-    expect(clock.serverClockSampleRoundTripMs.value).toBe(200)
-  })
-
-  it('does not let a much slower sample overwrite a better clock offset', () => {
-    const clock = useServerClock()
-
-    clock.updateServerClockOffset({
-      server_now_unix_ms: 10_500,
-      client_send_unix_ms: 20_000,
-      client_receive_unix_ms: 20_050,
-      round_trip_ms: 50,
-    })
-    clock.updateServerClockOffset({
-      server_now_unix_ms: 20_500,
-      client_send_unix_ms: 30_000,
-      client_receive_unix_ms: 30_500,
-      round_trip_ms: 500,
-    })
-
-    expect(clock.serverClockOffsetMs.value).toBe(-9_550)
-    expect(clock.serverClockSampleRoundTripMs.value).toBe(50)
-  })
-
-  it('accepts a faster sample after an initial slow sample', () => {
-    const clock = useServerClock()
-
-    clock.updateServerClockOffset({
-      server_now_unix_ms: 10_500,
-      client_send_unix_ms: 20_000,
-      client_receive_unix_ms: 20_500,
-      round_trip_ms: 500,
-    })
-    clock.updateServerClockOffset({
-      server_now_unix_ms: 20_500,
-      client_send_unix_ms: 30_000,
-      client_receive_unix_ms: 30_050,
-      round_trip_ms: 50,
-    })
-
-    expect(clock.serverClockOffsetMs.value).toBe(-9_550)
-    expect(clock.serverClockSampleRoundTripMs.value).toBe(50)
-  })
-
-  it('allows small RTT regressions so the offset can stay fresh', () => {
-    expect(shouldUseServerClockSample(140, 50)).toBe(true)
-    expect(shouldUseServerClockSample(151, 50)).toBe(false)
-  })
-})