@bongos/core 1.19.534 → 1.19.536

package/tests/hall_kit_charts.mjs

@@ -349,6 +349,10 @@ test('the kit is loaded before every page that draws through it', () => {
     ['index.html', 'hall-render.js'],
     ['watch.html', 'watch.js'],
     ['profile.html', 'profile-charts.js'],
+    // task 1003447: the roadmap's own series module reads the kit, and the page
+    // reads that. Both edges of the chain are ordered here.
+    ['roadmap.html', 'roadmap-timeline.js'],
+    ['roadmap.html', 'roadmap.js'],
   ]) {
     // The loaded ORDER, read off the script tags — index.html's prose mentions
     // hall-render.js ~90 lines above where it loads it, so a substring search
@@ -375,3 +379,172 @@ test('the migrated pages run for real against the kit and emit its classes', ()
     /class="kit-bars"/,
   );
 });
+
+// ---- 5. the SPAN bar and the fitted axis (task 1003447) --------------------
+//
+// Two options, both added so the goal's last two charts needed no new drawing
+// code and no new class family: a bar that starts somewhere other than the
+// track's left edge (which is what makes a bar series a TIMELINE), and a plot
+// whose axis sits at something other than zero (which is what makes a step line
+// readable for a LEVEL rather than a running total).
+
+test('a row\'s `start` offsets the bar and leaves its length alone', () => {
+  // The roadmap's shape: version A ran for the first quarter of the axis,
+  // version B for the middle half. Same primitive, same classes.
+  const html = kit.barSeriesHtml([
+    { label: 'A', value: 25 },
+    { label: 'B', value: 50, start: 25 },
+  ], { max: 100 });
+  const fills = [...html.matchAll(/class="kit-bars__fill" style="([^"]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(fills, ['width:25%', 'margin-left:25%;width:50%']);
+  assert.equal((html.match(/class="kit-bars"/g) || []).length, 1, 'still one class family');
+});
+
+test('a bar with no `start` writes no offset at all', () => {
+  // The compatibility contract: every caller that predates the span option gets
+  // byte-identical markup, so `margin-left:0%` never appears in a diff or in a
+  // snapshot of an existing chart.
+  const html = kit.barSeriesHtml([{ label: 'a', value: 3 }, { label: 'b', value: 1, start: 0 }]);
+  assert.doesNotMatch(html, /margin-left/);
+  // A nonsense start is ignored rather than written through into the style.
+  const junk = kit.barSeriesHtml([{ label: 'a', value: 3, start: 'nope' }], { max: 10 });
+  assert.doesNotMatch(junk, /margin-left/);
+  assert.doesNotMatch(junk, /NaN/);
+});
+
+test('a tiny non-zero `start` still offsets, so "first" stays a real claim', () => {
+  // The offset takes the same floor the width does. Without it a span beginning
+  // just after the axis origin rounds to 0% and draws flush left — which on a
+  // timeline reads as "this one started first", a claim about ordering rather
+  // than a rounding artefact.
+  const html = kit.barSeriesHtml([
+    { label: 'first', value: 500 },
+    { label: 'barely later', value: 500, start: 1 },
+  ], { max: 1000 });
+  const fills = [...html.matchAll(/class="kit-bars__fill" style="([^"]+)"/g)].map((m) => m[1]);
+  assert.equal(fills[0], 'width:50%', 'the one at the origin carries no offset');
+  assert.match(fills[1], /^margin-left:1%/, 'and the one after it is visibly after it');
+});
+
+test('a positive value never draws nothing, however small its share', () => {
+  // Rounding alone sends anything under half a percent to `width:0%`, which
+  // reads as "none" — the one thing it is not. Load-bearing for the roadmap: a
+  // version that started and shipped inside one day is a real span.
+  const html = kit.barSeriesHtml([{ label: 'tiny', value: 1 }, { label: 'huge', value: 100000 }]);
+  assert.match(html, /width:1%/, 'the sliver survives');
+  // and zero is still zero: an empty track is the honest picture of nothing.
+  assert.match(kit.barSeriesHtml([{ label: 'a', value: 0 }, { label: 'b', value: 9 }]), /width:0%/);
+});
+
+test('plotWindow puts a reachable-zero series on a zero floor', () => {
+  const w = kit.plotWindow([0, 3, 1, 4]);
+  assert.equal(w.yMin, 0, 'a count sits on zero — the distance from it IS the reading');
+  assert.ok(w.yMax > 4, 'with air above, so the peak does not ride the top edge');
+  assert.equal(w.lo, 0);
+  assert.equal(w.hi, 4);
+});
+
+test('plotWindow fits the floor for a level, which is why the caller must say so', () => {
+  const w = kit.plotWindow([24880, 27195], { zeroBased: false });
+  assert.ok(w.yMin > 24000 && w.yMin < 24880, 'the axis rises to just under the minimum');
+  assert.ok(w.yMax > 27195);
+  // The whole point: on a zero floor this month of change would occupy the top
+  // 9% of the box. Fitted, it occupies the whole of it.
+  const zero = kit.plotWindow([24880, 27195]);
+  assert.ok((w.yMax - w.yMin) < (zero.yMax - zero.yMin) / 5, 'the fitted window is far tighter');
+});
+
+test('plotWindow survives a flat series and an empty one', () => {
+  // A flat series has no range to take a fraction of, and dividing by it is how
+  // a chart renders as an invisible NaN.
+  const flat = kit.plotWindow([5, 5, 5]);
+  assert.ok(flat.yMax > 5, 'flat still gets air, so the line is not welded to the top');
+  const flatFit = kit.plotWindow([5, 5, 5], { zeroBased: false });
+  assert.ok(flatFit.yMin < 5 && flatFit.yMax > 5, 'and a fitted flat line lands mid-box');
+  const zeros = kit.plotWindow([0, 0, 0]);
+  assert.equal(zeros.yMin, 0);
+  assert.ok(zeros.yMax > 0, 'a month of honest zeros still divides by something');
+  assert.deepEqual(kit.plotWindow([]), { lo: 0, hi: 0, yMin: 0, yMax: 1, n: 0 });
+});
+
+test('plotWindow DROPS a non-finite reading rather than counting it as zero', () => {
+  // The trap this exists to close: Number(null) is 0 and finite, so a snapshot
+  // that predates a column would drag `lo` to zero and draw a cliff.
+  const w = kit.plotWindow([100, null, 120, undefined, 110]);
+  assert.equal(w.lo, 100);
+  assert.equal(w.n, 3, 'three readings, not five');
+});
+
+test('yMin lifts the axis, and its default leaves every existing series where it was', () => {
+  const box = { width: 100, height: 100, pad: { l: 0, r: 0, t: 0, b: 0 } };
+  const pts = [{ x: 0, value: 10 }, { x: 10, value: 20 }];
+  // Default (0): 20 of a 20-high window is the top, 10 is halfway.
+  const zero = kit.timeStepGeometry(pts, { x0: 0, x1: 10, yMax: 20, ...box });
+  assert.equal(zero.py(20).toFixed(1), '0.0');
+  assert.equal(zero.py(10).toFixed(1), '50.0');
+  // Fitted to 10..20: the same two points now span the whole box.
+  const fitted = kit.timeStepGeometry(pts, { x0: 0, x1: 10, yMin: 10, yMax: 20, ...box });
+  assert.equal(fitted.py(20).toFixed(1), '0.0');
+  assert.equal(fitted.py(10).toFixed(1), '100.0');
+  // A degenerate window (yMin === yMax) must not divide by zero.
+  const flat = kit.timeStepGeometry(pts, { x0: 0, x1: 10, yMin: 5, yMax: 5, ...box });
+  assert.doesNotMatch(flat.d, /NaN|Infinity/);
+});
+
+test('RUN: the roadmap timeline draws the real versions as spans on one axis', async () => {
+  // The page's own series module, run against the checked-in /public/versions
+  // fixture — the arithmetic a source assertion cannot reach. It is imported
+  // rather than stubbed for the same reason the kit is: a copy of the maths
+  // agreeing with itself proves nothing about what a reader gets.
+  const modPath = path.join(HALL, 'roadmap-timeline.js');
+  const tl = await import(`file://${modPath.replace(/\\/g, '/')}`).then((m) => m.default);
+  // public__versions.json, NOT versions.json — the deck calls /public/versions,
+  // and the authenticated list is a different payload. Reading the wrong one
+  // here is precisely the trap this task's own CLAUDE.md note warns about.
+  const fixture = JSON.parse(fs.readFileSync(
+    path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'public__versions.json'), 'utf8'));
+  const all = fixture.versions.map((v) => ({ id: v.id, start: v.started_at, ship: v.shipped_at }));
+  const now = Date.parse('2026-09-03T12:00:00Z');
+
+  const rows = tl.timelineRows(all, now);
+  assert.equal(rows.length, all.length, 'every fixture version has a start date');
+  const starts = rows.map((r) => r.from);
+  assert.deepEqual(starts, [...starts].sort((a, b) => a - b), 'oldest first');
+  assert.ok(rows.some((r) => r.open), 'the in-flight version runs to today');
+  assert.ok(rows.every((r) => r.to >= r.from), 'no span runs backwards');
+
+  const card = tl.timelineCardHtml(all, now, kit);
+  assert.equal(card.count, rows.length);
+  assert.doesNotMatch(card.html, /NaN|Infinity|undefined/);
+  assert.match(card.html, /class="kit-bars"/, 'drawn by the kit, not by hand');
+  const offsets = [...card.html.matchAll(/margin-left:(\d+)%/g)].map((m) => Number(m[1]));
+  assert.ok(offsets.length >= 2, 'later versions start further along the axis');
+  assert.deepEqual(offsets, [...offsets].sort((a, b) => a - b), 'and their offsets grow with their start dates');
+  // PMS-V1 started and shipped inside ONE day of a four-month axis: the span
+  // that rounds to nothing without the 1% floor. It is also the earliest
+  // version, so it correctly carries no offset — assert the floor, not a
+  // margin-left the axis origin has no reason to write.
+  const pms = card.html.match(/PMS-V1<\/span><span class="kit-bars__track"[^>]*><span class="kit-bars__fill" style="([^"]+)"/);
+  assert.ok(pms, 'PMS-V1 has a bar');
+  assert.match(pms[1], /width:[1-9]/, 'a one-day span still draws, rather than rounding to nothing');
+  assert.doesNotMatch(pms[1], /margin-left/, 'and the earliest version sits at the axis origin');
+});
+
+test('RUN: the timeline refuses to draw rather than drawing an empty axis', async () => {
+  const modPath = path.join(HALL, 'roadmap-timeline.js');
+  const tl = await import(`file://${modPath.replace(/\\/g, '/')}`).then((m) => m.default);
+  const now = Date.parse('2026-09-03T12:00:00Z');
+  assert.equal(tl.timelineCardHtml([], now, kit), null, 'nothing at all');
+  assert.equal(tl.timelineCardHtml([{ id: 'A', start: '2026-01-01' }], now, kit), null,
+    'one version is not a timeline');
+  // A version with no start date is left OUT and counted in the foot, never
+  // drawn at the axis origin — which would read as "began with the project".
+  const card = tl.timelineCardHtml([
+    { id: 'A', start: '2026-01-01', ship: '2026-02-01' },
+    { id: 'B', start: '2026-03-01', ship: null },
+    { id: 'C', start: null, ship: null },
+  ], now, kit);
+  assert.equal(card.count, 2);
+  assert.doesNotMatch(card.html, />C</, 'the unstarted version is not a bar');
+  assert.match(card.html, /1 version with no start date is not shown/, 'the foot says so');
+});

package/tests/hall_nav.mjs

@@ -170,7 +170,9 @@ test('sidebar groups read by audience, in order', () => {
   assert.deepEqual(nav[3].items.map((i) => i.id),
     ['primer', 'ranks', 'economy', 'diagrams', 'atlas', 'modules', 'apidocs'], 'Docs = reference material');
   // 'government' (the Permissions tab, BV1.R113) is the group's one archon-gated item.
-  assert.deepEqual(nav[4].items.map((i) => i.id), ['watch', 'harbor', 'gate', 'sessions', 'government']);
+  // 'project-settings' joins the Government group at the metic floor (task 1003280,
+  // goal 1000072) — it sits before 'government', which is the one archon-only item.
+  assert.deepEqual(nav[4].items.map((i) => i.id), ['watch', 'harbor', 'gate', 'sessions', 'project-settings', 'government']);
 });
 
 test('Economy lives in Docs and points at the reward-schedule page', () => {

package/tests/hall_oversight_world.mjs

@@ -11,6 +11,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
+import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -116,3 +117,161 @@ test('the vocabulary wall holds: the family is named oversight on the government
     assert.ok(!/governance/i.test(read(f)), `${f} does not say the pre-ADR-0174 word`);
   }
 });
+
+// ---- the repo-health trend (task 1003447, `legibility-series-are-drawn`) ----
+//
+// /public/repo-health has always answered with `latest` PLUS a trend[], and the
+// route's own comment says the trend exists "so the status page can draw LOC /
+// dead-exports / stale-branch lines over time ... oldest->newest so the
+// dashboard can plot left->right". Watch requested it WITH ?days=30 — paying for
+// the whole window — and renderLedger read one snapshot off it. The series
+// arrived over the wire and went on the floor.
+//
+// The AXIS arithmetic is the kit's (plotWindow / timeStepSeriesHtml) and
+// tests/hall_kit_charts.mjs runs it for real. What lives here is Watch's half:
+// that the section composes the kit rather than drawing by hand, and — the part
+// no source assertion can reach — that booting the REAL page against the REAL
+// checked-in fixture puts four finite plots on the panel.
+
+const FIXTURES = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const repoHealthFixture = () => JSON.parse(fs.readFileSync(path.join(FIXTURES, 'public__repo-health.json'), 'utf8'));
+
+// Boot watch.js in a stub DOM with the real dom-utils and the real kit, answer
+// /me as an archon and /public/repo-health with the fixture, and hand back what
+// landed in #ledger-trend. Every OTHER endpoint answers 500, which is the
+// page's own design (each section loads independently) and keeps this harness
+// to the one panel it is about.
+async function bootWatchLedger(overrides = {}) {
+  const payload = { ...repoHealthFixture(), ...overrides };
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, disabled: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; }, removeAttribute() {},
+    addEventListener() {}, appendChild() {}, insertAdjacentHTML(_, h) { this._html += h; },
+    closest() { return null; },
+    querySelector() { return null; }, querySelectorAll() { return []; },
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  const documentObj = {
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
+    querySelector(sel) {
+      const s = String(sel);
+      return s.startsWith('#') ? this.getElementById(s.slice(1)) : makeEl();
+    },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {},
+  };
+  const client = {
+    request: async (method, urlPath) => {
+      if (urlPath.endsWith('/me')) {
+        return { ok: true, status: 200, data: { builder: { id: '1', rank: 'archon', github_login: 'x' } } };
+      }
+      if (urlPath.includes('/public/repo-health')) return { ok: true, status: 200, data: payload };
+      return { ok: false, status: 500, data: {} };
+    },
+  };
+  const windowObj = {
+    BongosClient: { createClient: () => client },
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} },
+    location: { hash: '', pathname: '/watch', search: '', assign() {} },
+    addEventListener() {}, matchMedia: () => ({ matches: false, addEventListener() {} }),
+  };
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    localStorage: windowObj.localStorage,
+    // The two browser globals the kit reaches for outside `window`: CSS.escape
+    // (tab selectors) and history.replaceState (the tab's deep link).
+    CSS: { escape: (s) => String(s) },
+    history: { replaceState() {} },
+    console: { ...console, error() {}, warn() {} },
+    setTimeout, clearTimeout, URLSearchParams, Intl,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const f of ['dom-utils.js', 'hall-kit.js', 'watch.js']) {
+    vm.runInContext(read(f), sandbox, { filename: f });
+  }
+  // load() is async: let every section's promise settle before reading the DOM.
+  for (let i = 0; i < 8; i++) await new Promise((r) => setTimeout(r, 0));
+  return { html: documentObj.getElementById('ledger-trend').innerHTML, latest: payload.latest, windowObj };
+}
+
+test('the repo-health trend has a mount, and renderLedger fills it', () => {
+  const js = read('watch.js');
+  assert.match(read('watch.html'), /id="ledger-trend"/, 'the mount exists in the markup');
+  assert.match(js, /renderTrend\(data\);/, 'renderLedger hands the whole payload on, not just latest');
+  assert.match(js, /'\/public\/repo-health\?days=30'/, 'the request still asks for the window');
+  assert.match(js, /data\.window_days/, 'and the heading says which window it drew');
+});
+
+test('every mark in the trend is the kit\'s — no hand-drawn plot on the oversight page', () => {
+  const js = read('watch.js');
+  for (const fn of ['plotWindow', 'timeStepSeriesHtml', 'plotSvgHtml', 'plotValueLabelHtml']) {
+    assert.match(js, new RegExp(`kit\\.${fn}\\(`), `the trend draws through ${fn}`);
+  }
+  // §6b holds this globally; pinned here too because this is the page that
+  // hand-rolled a bar chart once already (task 1003445).
+  assert.doesNotMatch(js, /<(?:path|polyline|rect)\b[^>]*\b(?:d|points)="\$\{/,
+    'no hand-built SVG geometry on Watch');
+  // No readout is wired, so the plot must drop the focus stop AND the crosshair
+  // together — the task 1003446 pairing. Half of it is worse than neither.
+  assert.match(js, /interactive: false/, 'the trend plots are not fake-interactive');
+  assert.match(js, /class="pchart__twin"/, 'and each carries its table twin instead');
+});
+
+test('a fitted axis says so in words, because it magnifies every move', () => {
+  // total_loc is the one metric drawn off a non-zero floor: on a zero floor a
+  // month of real change is a flat band across the top of the box. That choice
+  // makes small movement look large, so the figure states its baseline rather
+  // than letting the picture imply a collapse to nothing.
+  const js = read('watch.js');
+  assert.match(js, /key: 'total_loc',[\s\S]{0,120}zeroBased: false/, 'total_loc fits its floor');
+  for (const k of ['dead_exports', 'stale_branches', 'confirmed_unshipped']) {
+    assert.match(js, new RegExp(`key: '${k}',[\\s\\S]{0,120}zeroBased: true`), `${k} keeps the zero floor`);
+  }
+  assert.match(js, /not zero/, 'and a fitted figure names its baseline in the foot');
+});
+
+test('RUN: the real page against the real fixture puts four finite plots on the panel', async () => {
+  // The half a source assertion cannot see. A NaN in a path `d` renders as an
+  // invisible chart with no error anywhere — a grep never finds that, and a
+  // stub agreeing with a stub never would either.
+  const { html, latest } = await bootWatchLedger();
+  assert.ok(html.length > 0, 'the panel drew something');
+  assert.doesNotMatch(html, /NaN|Infinity|undefined/, 'no broken geometry reaches the DOM');
+  const figures = [...html.matchAll(/id="ledger-trend-([a-z_]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(figures, ['total_loc', 'dead_exports', 'stale_branches', 'confirmed_unshipped'],
+    'all four metrics draw, in the reading order');
+  assert.equal((html.match(/class="kit-plot"/g) || []).length, 4, 'four plots');
+  assert.ok(!/tabindex="0"/.test(html), 'none of them is a focus stop with nothing to do');
+  assert.equal((html.match(/class="kit-plot__hair"/g) || []).length, 0, 'and none carries a crosshair nothing moves');
+  // The plot and the figure band above it derive from ONE payload, so they
+  // cannot disagree: the labelled endpoint is the number the snapshot states.
+  const compact = `${(latest.total_loc / 1e3).toFixed(1)}k`;
+  assert.ok(html.includes(`>${compact}<`), `the line ends on ${compact}, the value the snapshot figure shows`);
+});
+
+test('RUN: a payload with no trend renders nothing rather than an empty panel', async () => {
+  // The honest exit the module doc requires. The figures above already say what
+  // today's numbers are; an empty card under them would be worse than no card.
+  const { html } = await bootWatchLedger({ trend: [] });
+  assert.equal(html.trim(), '', 'no heading, no card, no "no data" box');
+});
+
+test('RUN: one snapshot is a reading, not a trend', async () => {
+  // A single point draws a dot on an axis with nothing to compare it to.
+  const { html } = await bootWatchLedger({ trend: repoHealthFixture().trend.slice(-1) });
+  assert.equal(html.trim(), '');
+});
+
+test('RUN: a metric its snapshots never carried is skipped, not drawn as a cliff', async () => {
+  // An older snapshot predates a column and sends null. Reading that as 0 would
+  // draw a fall to the floor that never happened, so the figure is dropped.
+  const trend = repoHealthFixture().trend.map((r) => ({ ...r, dead_exports: null }));
+  const { html } = await bootWatchLedger({ trend });
+  const figures = [...html.matchAll(/id="ledger-trend-([a-z_]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(figures, ['total_loc', 'stale_branches', 'confirmed_unshipped']);
+});

package/tests/hall_page_gate_map.mjs

@@ -68,6 +68,10 @@ const ORACLE = {
   '/builders/harbor': 'requireGovernmentPage',
   '/builders/gate': 'requireGovernmentPage',
   '/builders/sessions': 'requireGovernmentPage',
+  // The five fundamentals of the project (task 1003280, goal 1000072). Same tier as
+  // its neighbours: a steering surface, metic+ per ADR 0157. Its two WRITES gate
+  // independently on `project.settings.manage`, so this row is only about the shell.
+  '/builders/project-settings': 'requireGovernmentPage',
 
   // Metic+ via the `project.curate` atom — the exact permission GET /scouting
   // checks, so the page can never drift wider than the API it fronts. Its

package/tests/hall_reading_world.mjs

@@ -520,3 +520,156 @@ test('the vouched shapes still become links, exactly as before', () => {
   const degraded = MD.parseMarkdown('[t](../../CLAUDE.md)\n', MD.makeResolveLinkHref({ baseDir: 'docs/onboarding/' })).html;
   assert.ok(degraded.includes('<a href="../../CLAUDE.md"'), 'and with no bases a repo path still degrades to a link, as §10 pins above');
 });
+
+// ---- the deck draws its dates (task 1003447, `legibility-series-are-drawn`) --
+//
+// /public/versions has always carried started_at and shipped_at per version, and
+// the deck drew NEITHER: both dates reached the browser and came out as "Sep
+// 2026" on a shipped pill. The SERIES lives in roadmap-timeline.js and
+// tests/hall_kit_charts.mjs runs it against the real fixture; what belongs here
+// is the deck's half — that the section is composed, gated and placed the way
+// the reading rooms compose everything else.
+
+test('the deck asks the kit to draw its timeline, and hand-rolls nothing', () => {
+  const js = read('roadmap.js');
+  assert.match(js, /window\.OTBRoadmapTimeline/, 'the series comes from its own module');
+  assert.match(js, /timelineCardHtml\(all, now\)/, 'over the merged versions');
+  assert.match(js, /html \+= timelineHtml\(all, Date\.now\(\)\)/, 'and lands in the deck');
+  // §6b holds this globally; pinned here because a Gantt is the shape most
+  // likely to be reached for as "just a few divs with a left offset".
+  for (const f of ['roadmap.js', 'roadmap-timeline.js']) {
+    assert.doesNotMatch(read(f), /<(?:path|polyline|rect)\b[^>]*\b(?:d|points)="\$\{/,
+      `${f} builds no SVG geometry by hand`);
+    assert.doesNotMatch(read(f), /class="[^"]*(?:__|-)(?:fill|bar|track)[^"]*"[^>]*style="width:/,
+      `${f} draws no bar by hand`);
+  }
+  assert.match(read('roadmap-timeline.js'), /k\.barSeriesHtml\(/, 'the spans are the kit\'s bar series');
+});
+
+test('a missing timeline module leaves the deck exactly as it was', () => {
+  // The section is additive: the module is a <script> that can 404 behind a bad
+  // deploy, and when it does the deck must render its hero and its cards rather
+  // than an empty band or a thrown boot.
+  const js = read('roadmap.js');
+  const fn = js.slice(js.indexOf('function timelineHtml'), js.indexOf('function sectionHtml'));
+  assert.match(fn, /mod \? mod\.timelineCardHtml/, 'the module is checked before it is called');
+  assert.match(fn, /card \? sectionHtml\([\s\S]*?\) : ''/, 'and a null card renders no section at all');
+});
+
+// Boot roadmap.js in a stub DOM with the real dom-utils, the real kit and the
+// real timeline module, answer /public/progress + /public/versions with the
+// checked-in fixtures, and hand back what landed in #rm-root.
+//
+// This is the half the source pins and the kit's own RUN test both miss: the
+// GLUE. `mergeVersions()` maps `m.started_at`/`m.shipped_at` onto `start`/`ship`
+// and the timeline reads those names — a rename or a typo on either side leaves
+// every span unparsable, the section renders nothing, and every other test in
+// this file still passes because none of them run the mapping.
+async function bootRoadmap({ progress, versions } = {}) {
+  const FIX = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+  const fx = (f) => JSON.parse(fs.readFileSync(path.join(FIX, f), 'utf8'));
+  const prog = progress || fx('public__progress.json');
+  // public__versions.json, not versions.json: the deck calls the PUBLIC route.
+  const vers = versions || fx('public__versions.json');
+
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; },
+    addEventListener() {}, appendChild() {}, insertAdjacentHTML(_, h) { this._html += h; },
+    closest() { return null; }, querySelector() { return null; }, querySelectorAll() { return []; },
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  const documentObj = {
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
+    querySelector(sel) {
+      const s = String(sel);
+      return s.startsWith('#') ? this.getElementById(s.slice(1)) : makeEl();
+    },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {},
+  };
+  const client = {
+    request: async (_m, urlPath) => {
+      if (urlPath.includes('/public/progress')) return { ok: true, status: 200, data: prog };
+      if (urlPath.includes('/public/versions')) return { ok: true, status: 200, data: vers };
+      // No goals: goalSummary() swallows the failure by design, and the goal
+      // layer is not what this test is about.
+      return { ok: false, status: 500, data: {} };
+    },
+  };
+  const windowObj = {
+    BongosClient: { createClient: () => client },
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} },
+    location: { hash: '', pathname: '/roadmap', search: '', assign() {} },
+    addEventListener() {}, matchMedia: () => ({ matches: false, addEventListener() {} }),
+  };
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    localStorage: windowObj.localStorage,
+    CSS: { escape: (s) => String(s) }, history: { replaceState() {} },
+    console: { ...console, error() {}, warn() {} },
+    setTimeout, clearTimeout, URLSearchParams, Intl,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const f of ['dom-utils.js', 'hall-kit.js', 'roadmap-timeline.js', 'roadmap.js']) {
+    vm.runInContext(read(f), sandbox, { filename: f });
+  }
+  for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+  return { html: documentObj.getElementById('rm-root').innerHTML, prog, vers };
+}
+
+test('RUN: the deck really draws its timeline — mergeVersions\' field mapping included', async () => {
+  const { html, vers } = await bootRoadmap();
+  assert.ok(html.length > 0, 'the deck rendered');
+  assert.match(html, /class="rm-sec__t">In time</, 'the timeline section is on the page');
+  assert.match(html, /class="kit-bars"/, 'and it is the kit drawing it');
+  assert.doesNotMatch(html, /NaN|Infinity|undefined/, 'no broken geometry reaches the DOM');
+
+  // Every version the fixture gives a start date has a bar, labelled by its id.
+  // This is the assertion that fails if `start`/`ship` ever drift from
+  // `started_at`/`shipped_at`: the mapping breaks, no date parses, and the
+  // section quietly disappears.
+  const started = vers.versions.filter((v) => v.started_at);
+  assert.ok(started.length >= 2, 'the fixture has enough started versions to be a timeline');
+  for (const v of started) {
+    assert.ok(html.includes(`class="kit-bars__label">${v.id}<`), `${v.id} has a bar`);
+  }
+  // A version still running says "now" rather than naming a date nothing recorded.
+  if (vers.versions.some((v) => v.started_at && !v.shipped_at)) {
+    assert.match(html, /→ now</, 'an open span reads "now"');
+  }
+  // Later versions sit further along the shared axis — the whole point of a
+  // timeline, and the thing a plain bar series would NOT show.
+  const offsets = [...html.matchAll(/margin-left:(\d+)%/g)].map((m) => Number(m[1]));
+  assert.ok(offsets.length >= 1, 'spans are offset, not all flush left');
+  assert.deepEqual(offsets, [...offsets].sort((a, b) => a - b), 'offsets grow with start date');
+});
+
+test('RUN: a deck whose versions carry no dates renders every other section unharmed', async () => {
+  // The degradation that matters: /public/versions is fetched with a
+  // `.catch(() => [])`, so a 404 or a stripped payload must cost the timeline
+  // and nothing else. Before this task the whole page relied on that silently.
+  const { html } = await bootRoadmap({
+    versions: { versions: [{ id: 'BONGOS-V1', name: 'x', status: 'building', started_at: null, shipped_at: null }] },
+  });
+  assert.doesNotMatch(html, /In time</, 'no timeline section');
+  assert.match(html, /rm-hero/, 'but the hero still renders');
+  assert.doesNotMatch(html, /NaN|undefined/);
+});
+
+test('the timeline module is a pure builder, so it is testable and cannot boot itself', () => {
+  const src = read('roadmap-timeline.js');
+  // The node-require-safe tail (the hall-kit.js / dom-utils.js contract): the
+  // ONLY eval-time side effect is the assignment, and only when a window exists.
+  assert.match(src, /if \(typeof window !== 'undefined'\) window\.OTBRoadmapTimeline = api;/);
+  assert.match(src, /if \(typeof module !== 'undefined' && module\.exports\) module\.exports = api;/);
+  // It must not reach for the page: no document, no fetch, no client.
+  for (const forbidden of [/\bdocument\./, /\bfetch\(/, /BongosClient/]) {
+    assert.doesNotMatch(src, forbidden, `roadmap-timeline.js touches ${forbidden} — it is a builder, not a page`);
+  }
+});