The main timeline is the only time control; the Weather panel shows its frame time

The Weather panel kept a second time transport of its own: a slider, step
buttons, Latest and Play, backed by a replay in the weather clock that
stepped the observed frames every two seconds and went round from the last
to the first. The weather clock also attached itself to the world clock as
a driver, so the timeline's Play became that replay whenever weather was on.

The panel now shows the frame time only: the newest frame and its age while
live, the timeline time alone at a past time. The weather clock no longer
has setTarget, step, latest, play, pause or togglePlay, its state no longer
has playing, and it no longer drives the world clock. It still follows the
world time, registers each product's frames as marks the timeline's arrow
keys step to, holds its products, and gates the world's continuous play at
each next frame until it loads. weatherClock.world names the world clock it
follows.

A weather row's play, latest and step params move the world clock as the
timeline does: play toggles continuous play (from the start of the covered
time when live), latest goes live, and step goes to the previous or next
mark. The rail timeline component, which only the panel used, is removed,
along with its unused messages in every locale.
This commit is contained in:
Sameh Khamis committed 2026-11-14 18:28:53 -08:00
1 parent 4ddce7f38b
commit 5150279ccf
35 files changed
+331 -1040

No files matched your search

-178
View File
@@ -1,178 +0,0 @@
<script setup>
import { computed, onBeforeUnmount, shallowRef, watch } from 'vue';
import { formatUtcDayMonth, t } from '../../i18n/index.js';
import { utcClock } from './utcClock.js';
import UiSlider from '../kit/UiSlider.js';
// Stable native transport with local preview and a coalesced 150 ms drag
// commit. While the handle is dragged the slider keeps the ticks it was
// dragged over; the owner's updates apply once the drag ends.
const props = defineProps({
state: { type: Object, required: true },
sliderClassName: { type: String, default: '' },
heading: { type: Boolean, default: true },
onCommit: { type: Function, default: () => {} },
onPreview: { type: Function, default: () => {} },
onStep: { type: Function, default: () => {} },
onLatest: { type: Function, default: () => {} },
onPlay: { type: Function, default: () => {} },
});
const utc = (tick) =>
Number.isFinite(Date.parse(tick))
? `${formatUtcDayMonth(tick)} ${utcClock(tick)}`
: '';
// What the slider shows: the owner's ticks, index and readout, frozen while
// dragging.
const shown = shallowRef({ ticks: [], index: 0, readout: '' });
let dragging = false;
let timer = null;
let pending = null;
let live = true;
const cancel = () => {
if (timer !== null) clearTimeout(timer);
timer = null;
};
const sync = () => {
if (dragging) return;
const ticks = [...props.state.ticks];
shown.value = {
ticks,
index: Math.max(0, Math.min(props.state.index, ticks.length - 1)),
readout: props.state.readout || '',
};
};
watch(
() => props.state,
(state) => {
if (state.disabled) {
cancel();
pending = null;
dragging = false;
}
sync();
},
{ immediate: true, flush: 'sync' },
);
onBeforeUnmount(() => {
live = false;
cancel();
});
const disabled = computed(() => Boolean(props.state.disabled));
const latestActive = computed(() => props.state.mode === 'latest');
const playing = computed(() => Boolean(props.state.playing));
function commit() {
cancel();
const value = pending;
pending = null;
if (live && value && !props.state.disabled)
props.onCommit(value.tick, value.index);
}
function preview(event) {
if (props.state.disabled) return;
dragging = true;
const index = Number(event.target.value);
const tick = shown.value.ticks[index];
if (!tick) return;
pending = { tick, index };
// Shown before the owner hears of it: an update from inside onPreview
// must not move the handle back.
shown.value = { ...shown.value, index };
const readout = props.onPreview(tick, index);
// The owner may have ended the drag (disabled) from inside onPreview.
if (!dragging) return;
if (typeof readout === 'string') shown.value = { ...shown.value, readout };
if (timer === null) timer = setTimeout(commit, 150);
}
// The handle shows the shown index again. A drag that ends where it began
// (an input and a cancel, or a refused commit, before the next render)
// leaves the slider's model unchanged, so it would not render.
const place = (input) => {
const index = String(shown.value.index);
if (input && input.value !== index) input.value = index;
};
function change(event) {
if (props.state.disabled) return;
const index = Number(event.target.value);
pending = { tick: shown.value.ticks[index], index };
dragging = false;
commit();
sync();
place(event.target);
}
function reset(event) {
cancel();
pending = null;
dragging = false;
sync();
place(event?.target);
}
function blur(event) {
if (dragging) change(event);
}
const act = (fn) => {
reset();
if (live && !props.state.disabled) fn();
};
</script>
<template>
<section class="rail-timeline"
><div v-if="heading" class="panel-title">{{ t('Observed history') }}</div
><div class="rail-timeline-track"
><button
type="button"
class="data-toggle-chip"
:title="t('Earlier observation')"
:disabled="disabled || state.index <= 0"
@click="act(() => onStep(-1))"
>‹</button
><UiSlider
:class="sliderClassName || undefined"
min="0"
:max="String(Math.max(0, shown.ticks.length - 1))"
step="1"
:model-value="String(shown.index)"
:disabled="disabled"
:aria-label="t('Observed history')"
:aria-valuetext="utc(shown.ticks[shown.index])"
@input="preview"
@change="change"
@pointercancel="reset"
@blur="blur"
/><button
type="button"
class="data-toggle-chip"
:title="t('Later observation')"
:disabled="disabled || state.index >= state.ticks.length - 1"
@click="act(() => onStep(1))"
>›</button
><div class="rail-timeline-endpoints"
><span>{{ utcClock(shown.ticks[0]) }}</span
><span>{{ utcClock(shown.ticks.at(-1)) }}</span></div
></div
><div class="rail-timeline-controls"
><button
type="button"
:class="`data-toggle-chip${latestActive ? ' active' : ''}`"
:title="t('Newest frame per product')"
:disabled="disabled"
:aria-pressed="String(latestActive)"
@click="act(onLatest)"
>{{ t('Latest') }}</button
><button
type="button"
:class="`data-toggle-chip${playing ? ' active' : ''}`"
:title="t('Replay observed history')"
:disabled="disabled"
:aria-pressed="String(playing)"
@click="act(onPlay)"
>{{ playing ? t('Pause') : t('Play') }}</button
><span class="rail-timeline-readout">{{ shown.readout }}</span></div
></section
>
</template>
-56
View File
@@ -1,56 +0,0 @@
import { h, render } from 'vue';
import RailTimeline from './rail/RailTimeline.vue';
export { utcClock } from './rail/utcClock.js';
/**
* Stable native transport with local preview and a coalesced 150 ms drag
* commit. Renders the RailTimeline component into `container` and patches it
* synchronously on every update.
*/
export function createRailTimeline({
container,
document = container?.ownerDocument,
sliderClassName = '',
heading = true,
onCommit = () => {},
onPreview = () => {},
onStep = () => {},
onLatest = () => {},
onPlay = () => {},
} = {}) {
if (!document?.createElement || !container) return null;
let destroyed = false;
const paint = (state) =>
render(
h(RailTimeline, {
state,
sliderClassName,
heading,
onCommit,
onPreview,
onStep,
onLatest,
onPlay,
}),
container,
);
paint({
ticks: [],
index: 0,
mode: 'latest',
playing: false,
readout: '',
disabled: true,
});
return {
update(state) {
if (!destroyed) paint(state);
},
destroy() {
if (destroyed) return;
destroyed = true;
render(null, container);
},
};
}
-178
View File
@@ -1,178 +0,0 @@
import '../testSupport/registerDom.mjs';
import test from 'node:test';
import assert from 'node:assert/strict';
import { assertSameNode } from '../testSupport/domAssert.mjs';
import { nextTick } from 'vue';
import { createRailTimeline } from './railTimeline.js';
import { railDocumentFixture as railFixture } from './railTestFixture.mjs';
const ticks = [
'2026-09-22T01:00:00Z',
'2026-09-22T01:05:00Z',
'2026-09-22T01:10:00Z',
];
const props = {
ticks,
index: 2,
mode: 'latest',
playing: false,
readout: 'Latest',
disabled: false,
};
test('preview is immediate, commits are coalesced and the drag DOM and tick mapping stay stable', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const f = railFixture();
const previews = [];
const commits = [];
const view = createRailTimeline({
...f,
onPreview: (tick) => {
previews.push(tick);
return tick;
},
onCommit: (tick) => commits.push(tick),
});
view.update(props);
const slider = f.find((n) => n.tagName === 'INPUT');
const row = slider.parentElement;
assert.equal(slider.getAttribute('aria-label'), 'Observed history');
slider.value = '0';
slider.dispatchEvent(new Event('input'));
assert.deepEqual(commits, []);
assert.deepEqual(previews, [ticks[0]]);
await nextTick();
assert.equal(slider.getAttribute('aria-valuetext'), '09-22 01:00 UTC');
view.update({
...props,
ticks: ticks.slice(1),
index: 1,
readout: 'Refresh',
});
assertSameNode(slider.parentElement, row);
assertSameNode(row.children[1], slider);
assert.equal(slider.value, '0');
assert.equal(slider.max, '2');
assert.equal(
f.find((n) => n.className === 'rail-timeline-readout').textContent,
ticks[0],
);
t.mock.timers.tick(149);
assert.equal(commits.length, 0);
slider.value = '1';
slider.dispatchEvent(new Event('input'));
t.mock.timers.tick(1);
assert.deepEqual(commits, [ticks[1]]);
slider.value = '2';
slider.dispatchEvent(new Event('input'));
slider.dispatchEvent(new Event('change'));
assert.deepEqual(commits, [ticks[1], ticks[2]]);
t.mock.timers.tick(150);
assert.equal(commits.length, 2);
await nextTick();
assert.equal(slider.max, '1', 'release applies the latest update');
view.destroy();
});
test('identical updates write nothing; controls call actions and destruction cancels commits', (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const f = railFixture();
const calls = [];
const view = createRailTimeline({
...f,
onCommit: () => calls.push('commit'),
onStep: (n) => calls.push(n),
onLatest: () => calls.push('latest'),
onPlay: () => calls.push('play'),
});
view.update({ ...props, index: 1 });
f.writes();
view.update({ ...props, index: 1 });
assert.equal(f.writes(), 0);
for (const label of ['‹', '›', 'Latest', 'Play'])
f.find((n) => n.textContent === label).click();
assert.deepEqual(calls, [-1, 1, 'latest', 'play']);
view.update({ ...props, playing: true });
assert.ok(f.find((n) => n.textContent === 'Pause'));
const slider = f.find((n) => n.tagName === 'INPUT');
slider.value = '0';
slider.dispatchEvent(new Event('change'));
assert.equal(calls.at(-1), 'commit');
slider.dispatchEvent(new Event('input'));
view.destroy();
t.mock.timers.tick(150);
assert.equal(calls.length, 5);
assert.equal(f.container.children.length, 0);
});
test('observed history label and endpoint times track the advertised tick range', () => {
const f = railFixture();
const view = createRailTimeline(f);
view.update(props);
assert.equal(
f.find((n) => n.className === 'panel-title').textContent,
'Observed history',
);
const endpoints = f.find((n) => n.className === 'rail-timeline-endpoints');
assert.equal(endpoints.parentElement.className, 'rail-timeline-track');
assert.deepEqual(
[...endpoints.children].map((n) => n.textContent),
['01:00 UTC', '01:10 UTC'],
);
view.update({ ...props, ticks: ticks.slice(1) });
assert.equal(endpoints.children[0].textContent, '01:05 UTC');
view.destroy();
});
test('an update from inside the preview neither moves the handle back nor survives a disable', async () => {
const f = railFixture();
let view;
let next = null;
const commits = [];
view = createRailTimeline({
...f,
onPreview: () => {
if (next) view.update(next);
return 'preview';
},
onCommit: (tick, index) => commits.push(index),
});
view.update(props);
const slider = f.find((n) => n.tagName === 'INPUT');
next = { ...props, readout: 'Refresh' };
slider.value = '0';
slider.dispatchEvent(new Event('input'));
assert.equal(slider.value, '0');
slider.dispatchEvent(new Event('change'));
assert.deepEqual(commits, [0]);
next = { ...props, disabled: true };
slider.value = '1';
slider.dispatchEvent(new Event('input'));
await nextTick();
assert.equal(slider.value, '2', 'the disabled owner keeps its position');
assert.equal(slider.getAttribute('aria-valuetext'), '09-22 01:10 UTC');
view.destroy();
});
test('a drag that ends where it began puts the handle back on the shown index', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const f = railFixture();
const commits = [];
const view = createRailTimeline({
...f,
onCommit: (tick) => commits.push(tick),
});
view.update(props);
await nextTick();
const slider = f.find((n) => n.tagName === 'INPUT');
slider.value = '0';
slider.dispatchEvent(new Event('input'));
slider.dispatchEvent(new Event('pointercancel'));
await nextTick();
assert.equal(slider.value, '2', 'a cancelled drag');
assert.deepEqual(commits, []);
// A refused commit: the owner keeps its index.
slider.value = '1';
slider.dispatchEvent(new Event('input'));
slider.dispatchEvent(new Event('change'));
await nextTick();
assert.deepEqual(commits, [ticks[1]]);
assert.equal(slider.value, '2', 'a refused commit');
view.destroy();
});
+5 -5
View File
@@ -125,8 +125,8 @@ export const useWorldTimeStore = defineStore('gev-world-time', () => {
/**
* Play runs the track at the speed chosen, from the start when it is at
* its end (at live, say), as a video plays again from the top. It runs
* the clock itself, past weather's own replay: weather follows the time
* frame by frame like every other layer the track covers.
* the clock itself: weather follows the time frame by frame like every
* other layer the track covers.
*/
togglePlay() {
const { playing, live, timeMs, span } = time.value;
@@ -138,9 +138,9 @@ export const useWorldTimeStore = defineStore('gev-world-time', () => {
},
speed,
/**
* Choose how fast play runs; playing, it changes at once. Weather's own
* replay steps at its own pace, so a speed chosen while it plays takes
* playback over from where it is.
* Choose how fast play runs; playing, it changes at once. A driver steps
* at its own pace, so a speed chosen while one plays takes playback over
* from where it is.
*/
setSpeed(next) {
if (!Object.hasOwn(WORLD_TIME_SPEEDS, next)) return;
+4 -46
View File
@@ -56,8 +56,7 @@
}
/* Card typography follows the layer rows and app tokens. */
.weather-readout,
.rail-card,
.rail-timeline {
.rail-card {
min-width: 0;
color: var(--text-dim);
font: 9px/1.45 var(--font-mono);
@@ -128,7 +127,7 @@
text-align: right;
}
.rail-card-line,
.rail-timeline-readout {
.weather-frame-time {
font-family: var(--font-mono);
font-size: 9px;
letter-spacing: 0.5px;
@@ -188,54 +187,13 @@ html:not([lang='en']) .weather-card [data-line-id='status'] {
letter-spacing: 0.5px;
}
.rail-card [hidden],
.weather-timeline-block[hidden],
.weather-frame-time[hidden],
.weather-observed-group[hidden] {
display: none !important;
}
.rail-timeline {
.weather-frame-time {
padding: 5px;
border-bottom: 1px solid var(--weather-card-border);
}
.rail-timeline-track {
display: grid;
grid-template-columns: auto minmax(0, 1fr) auto;
align-items: center;
gap: 3px 8px;
margin-top: 6px;
}
.rail-timeline-track input {
min-width: 0;
width: 100%;
margin: 0;
}
.rail-timeline-endpoints {
display: flex;
grid-column: 2;
justify-content: space-between;
flex-wrap: wrap;
gap: 3px 8px;
font: 8px/1.45 var(--font-mono);
font-variant-numeric: tabular-nums;
}
.rail-timeline-endpoints span {
white-space: nowrap;
}
.rail-timeline-endpoints span:last-child {
margin-left: auto;
}
.rail-timeline-controls .data-toggle-chip {
flex: 0 0 auto;
}
.rail-timeline-controls {
display: flex;
align-items: center;
flex-wrap: wrap;
gap: 6px;
margin-top: 6px;
}
.rail-timeline-readout {
flex: 1 1 auto;
min-width: 0;
overflow-wrap: anywhere;
font-variant-numeric: tabular-nums;
color: var(--text-secondary);
+5 -13
View File
@@ -1,15 +1,14 @@
<script setup>
import { t } from '../../i18n/index.js';
import RailCards from '../rail/RailCards.vue';
import RailTimeline from '../rail/RailTimeline.vue';
// Active weather: forecast and event cards, then the observed products with
// their shared history timeline. The owner computes every value shown.
// the time of the frame they show. The world timeline moves time; the owner
// computes every value shown.
defineProps({
view: { type: Object, required: true },
onParams: { type: Function, default: () => {} },
onOpen: { type: Function, default: () => {} },
transport: { type: Object, required: true },
});
</script>
@@ -31,16 +30,9 @@ defineProps({
:aria-label="t('Observed history')"
><h3 class="panel-title">{{ t('Observed history') }}</h3
><div class="weather-observed-scope">{{ view.scope }}</div
><div class="weather-timeline-block" :hidden="!view.observed"
><RailTimeline
:state="view.timeline"
slider-class-name="weather-timeline"
:heading="false"
:on-commit="transport.onCommit"
:on-preview="transport.onPreview"
:on-step="transport.onStep"
:on-latest="transport.onLatest"
:on-play="transport.onPlay" /></div
><div class="weather-frame-time" :hidden="!view.frameTime">{{
view.frameTime
}}</div
><div class="weather-cards"
><RailCards
:cards="view.observedCards"
+10 -38
View File
@@ -98,13 +98,6 @@ export function createWeatherPanel({
openPanels.set(page, id);
render();
},
transport: {
onCommit: (tick) => clock?.setTarget(tick),
onPreview: (time) => historyTime(time, clock?.getState()),
onStep: (direction) => clock?.step(direction),
onLatest: () => clock?.latest(),
onPlay: () => clock?.togglePlay(),
},
};
// The readout patches synchronously, so a newly opened card can be measured.
const paint = (view) =>
@@ -113,14 +106,7 @@ export function createWeatherPanel({
hidden: true,
observed: false,
scope: '',
timeline: {
ticks: [],
index: 0,
mode: 'latest',
playing: false,
readout: '',
disabled: true,
},
frameTime: '',
cards: [],
observedCards: [],
});
@@ -135,32 +121,18 @@ export function createWeatherPanel({
.filter(({ summary }) => summary)
.sort((a, b) => ORDER.indexOf(a.id) - ORDER.indexOf(b.id));
const observed = active.filter(({ id }) => OBSERVED.has(id));
const showTimeline = observed.length > 0;
const showObserved = observed.length > 0;
const names = {
'weather-radar': t('Rain radar'),
'weather-satellite': t('Satellite clouds'),
'weather-lightning': t('Lightning density'),
};
const index =
state.mode === 'latest'
? state.timeline.length - 1
: Math.max(
0,
state.timeline.findLastIndex(
(tick) => Date.parse(tick) <= Date.parse(state.target),
),
);
const timeline = {
ticks: state.timeline,
index,
mode: state.mode,
playing: Boolean(state.playing),
disabled: !showTimeline || state.timeline.length < 2,
readout:
state.mode === 'latest'
? t('LATEST · newest per product')
: historyTime(state.target, state),
};
// While live, the newest frame and its age; at a past time, the timeline
// time alone. The world timeline moves the time.
const shownTime =
state.mode === 'latest' ? state.timeline.at(-1) : state.target;
const frameTime =
showObserved && shownTime ? historyTime(shownTime, state) : '';
const models = active.map((entry) => {
const { id, icon, summary, legend = [], list } = entry;
// Discrete classes (storm geometry, AQHI bands) list swatches, not a ramp.
@@ -245,9 +217,9 @@ export function createWeatherPanel({
const hidden = active.length === 0;
paint({
hidden,
observed: showTimeline,
observed: showObserved,
scope: observed.map(({ id }) => names[id]).join(' · '),
timeline,
frameTime,
cards: models.filter(({ id }) => !OBSERVED.has(id)),
observedCards: models.filter(({ id }) => OBSERVED.has(id)),
});
+25 -37
View File
@@ -55,10 +55,6 @@ function fixture() {
listeners.add(fn);
return () => listeners.delete(fn);
},
setTarget: (tick) => calls.push(['target', tick]),
latest: () => calls.push(['latest']),
togglePlay: () => calls.push(['play']),
step: (n) => calls.push(['step', n]),
};
return {
...f,
@@ -75,39 +71,36 @@ function fixture() {
},
};
}
const timelineHost = (f) =>
f.find((n) => n.className === 'weather-timeline-block');
const frameTime = (f) => f.find((n) => n.className === 'weather-frame-time');
const card = (f, id) => f.find((n) => n.dataset.cardId === id);
const line = (f, id, name) =>
f.find((n) => n.dataset.lineId === name, card(f, id));
test('timeline stays visible with any observed product; native preview and transport use the clock', (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
test('the frame time shows with any observed product; the panel has no time controls of its own', (t) => {
t.mock.timers.enable({
apis: ['Date'],
now: Date.parse('2026-09-22T01:17:00Z'),
});
const f = fixture();
const view = createWeatherPanel(f);
view.update([wind]);
assert.equal(timelineHost(f).hidden, true);
assert.equal(frameTime(f).hidden, true);
view.update([wind, radar]);
assert.equal(timelineHost(f).hidden, false);
assert.equal(frameTime(f).hidden, false);
assert.equal(frameTime(f).textContent, '01:05 UTC · 12 min ago');
f.state({ timeline: [ticks[0]] });
assert.equal(timelineHost(f).hidden, false);
assert.equal(f.find((n) => n.tagName === 'INPUT').disabled, true);
assert.equal(frameTime(f).textContent, '01:00 UTC · 17 min ago');
f.state({ timeline: [] });
assert.equal(timelineHost(f).hidden, false);
f.state({ timeline: ticks });
assert.equal(timelineHost(f).hidden, false);
const slider = f.find((n) => n.tagName === 'INPUT');
slider.value = '0';
slider.dispatchEvent(new Event('input'));
assert.deepEqual(f.calls, []);
slider.dispatchEvent(new Event('change'));
assert.deepEqual(f.calls, [['target', ticks[0]]]);
f.find((n) => n.textContent === 'Latest' && n.tagName === 'BUTTON').click();
f.find((n) => n.textContent === 'Play').click();
assert.deepEqual(f.calls.slice(1), [['latest'], ['play']]);
slider.dispatchEvent(new Event('input'));
view.update([wind]);
t.mock.timers.tick(150);
assert.equal(f.calls.length, 3, 'hiding cancels pending drag');
assert.equal(frameTime(f).hidden, true);
f.state({ timeline: ticks, mode: 'history', target: ticks[0] });
assert.equal(frameTime(f).textContent, '01:00 UTC');
assert.equal(
f.find((n) => n.tagName === 'INPUT'),
null,
);
assert.equal(
f.find((n) => ['Play', 'Latest'].includes(n.textContent)),
null,
);
view.destroy();
assert.equal(f.listeners.size, 0);
});
@@ -180,7 +173,7 @@ test('cyclone readout retains advisory, position, intensity, geometry, coverage,
],
};
view.update([cyclone]);
assert.equal(timelineHost(f).hidden, true);
assert.equal(frameTime(f).hidden, true);
assert.match(
line(f, cyclone.id, 'time').textContent,
/JULIO.*Hurricane.*Advisory 10.*UTC/,
@@ -411,7 +404,7 @@ test('cyclones lead, and observed history owns one bordered group with only acti
group.children[1].textContent,
'Rain radar · Satellite clouds · Lightning density',
);
assertSameNode(group.children[2], timelineHost(f));
assertSameNode(group.children[2], frameTime(f));
assert.deepEqual(
[...group.children[3].children].map((n) => n.dataset.cardId),
['weather-radar', 'weather-satellite', 'weather-lightning'],
@@ -674,13 +667,8 @@ test('history time keeps the hour whatever the length of the localized date', ()
const f = fixture();
const view = createWeatherPanel(f);
view.update([wind, radar]);
const ends = f.find((n) => n.className === 'rail-timeline-endpoints');
assert.deepEqual(
[...ends.children].map((n) => n.textContent),
['01:00 UTC', '01:05 UTC'],
locale,
);
f.state({ mode: 'history', target: ticks[1] });
assert.equal(frameTime(f).textContent, '01:05 UTC', locale);
assert.match(
line(f, radar.id, 'time').textContent,
/(^|[^\d:])01:05 UTC/,
@@ -808,7 +796,7 @@ test('at a past time, frame ages and the timeline readout count from the timelin
);
const readout = f.find((n) => n.textContent === '01:20 UTC');
assert.ok(readout, 'the readout names the timeline time');
assert.doesNotMatch(timelineHost(f).textContent, /min ago/);
assert.doesNotMatch(frameTime(f).textContent, /min ago/);
view.destroy();
});