@bongos/core 1.19.1014 → 1.19.1016

package/modules/hall-ui/public/goal-map.js

@@ -1,232 +0,0 @@
-// goal-map.js — the goal map page (task 1003479, goal 1000089; ADR 0227 §6 item 3
-// and its §10.4 amendment). One read, GET /goals/graph, three surfaces from it:
-//   1. the map — the goals tied to another goal by a dependency, drawn in layers;
-//   2. the stand-alone list — the goals that have no edge, which §10.4 says belong
-//      in a list and not as dots on a canvas that has nothing to say about them;
-//   3. the table — EVERY goal, with both directions of each dependency by name.
-//
-// THE TABLE IS THE PAGE AND THE MAP IS THE ENHANCEMENT (ADR 0227 §5). Every fact
-// the picture carries is a cell in the table, on screen by default and not behind
-// a "view as table" toggle. The picture is therefore a `role="img"` figure with a
-// caption that says where the same facts are, and its nodes are NOT links or
-// focus stops — a keyboard or screen-reader reader gets each goal, once, from the
-// table, rather than thirty-six hidden interactive elements from a drawing.
-//
-// THERE IS NO CONTROL that changes what is drawn (ADR 0227 §7): no "show every
-// task", no "densify". The only input is the aggregate the endpoint returns,
-// which carries no task identity, so views A and D are unreachable by
-// construction and not by a flag that happens to be off.
-//
-// The layout is goal-map-lib.js (pure, run by tests/goal_map_lib.mjs). This file
-// draws what it returns, with createElementNS and textContent — the atlas's
-// idiom — so a goal title (builder-authored text) never becomes markup.
-(() => {
-  'use strict';
-
-  const API = '/api/bongos';
-  const SVGNS = 'http://www.w3.org/2000/svg';
-  const kit = window.OTBKit;
-  const lib = window.OTBGoalMapLib;
-  const textFit = window.OTBTextFit;
-  const { escapeHtml } = window.OTB;
-  const $ = (id) => document.getElementById(id);
-
-  const hallBase = () => (location.hostname.startsWith('builders.') ? '' : '/builders');
-  const goalHref = (id) => `${hallBase()}/goals#/goal/${encodeURIComponent(id)}`;
-
-  function svgEl(tag, attrs, parent) {
-    const el = document.createElementNS(SVGNS, tag);
-    Object.keys(attrs || {}).forEach((k) => el.setAttribute(k, attrs[k]));
-    if (parent) parent.appendChild(el);
-    return el;
-  }
-  function text(parent, cls, x, y, content) {
-    const t = svgEl('text', { class: cls, x, y }, parent);
-    t.textContent = content;
-    return t;
-  }
-
-  // ---- the map -----------------------------------------------------------------
-
-  // Node text is fitted to MEASURED width, not a character count (task 1004204;
-  // the forest's fix, task 1004200). Measuring needs the svg in the document, so
-  // drawGraph collects each line into `lines` and renderGraph fits them after
-  // appending. The clipPath is the backstop for a map drawn while hidden.
-  const TEXT_X = 16;
-  function fitNodeText(lines, maxWidth) {
-    lines.forEach(({ el, full }) => {
-      el.textContent = textFit.fitText(full, maxWidth, (s) => { el.textContent = s; return el.getComputedTextLength(); });
-    });
-  }
-
-  function drawGraph(a, lay, cats, lines) {
-    const svg = svgEl('svg', {
-      class: 'gm-svg', viewBox: `0 0 ${lay.width} ${lay.height}`, width: lay.width, height: lay.height,
-      role: 'img', 'aria-labelledby': 'gm-cap', focusable: 'false',
-    });
-    const defs = svgEl('defs', {}, svg);
-    const marker = svgEl('marker', { id: 'gm-arrow', viewBox: '0 0 10 10', refX: 9, refY: 5, markerWidth: 7, markerHeight: 7, orient: 'auto' }, defs);
-    svgEl('path', { class: 'gm-arrowhead', d: 'M0 0 L10 5 L0 10 z' }, marker);
-    const clip = svgEl('clipPath', { id: 'gm-text-clip' }, defs);
-    svgEl('rect', { width: lay.nodeW, height: lay.nodeH }, clip);
-
-    const edges = svgEl('g', { class: 'gm-edges' }, svg);
-    lay.edges.forEach((e) => {
-      const path = svgEl('path', { class: 'gm-edge', d: e.d, 'stroke-width': e.width, 'marker-end': 'url(#gm-arrow)' }, edges);
-      const dependent = lib.displayTitle(a.byId[e.from]);
-      const dependency = lib.displayTitle(a.byId[e.to]);
-      svgEl('title', {}, path).textContent = `${dependent} waits on ${dependency} — ${lib.plural(e.count, 'task')}`;
-    });
-
-    // The node's WEIGHT (ADR 0227 §6 item 3: "node weight = task count"), as a
-    // fraction of the busiest goal ACTUALLY DRAWN — a scale that means something
-    // on this map, not on the whole corpus most of which never appears here.
-    const maxTotal = lay.nodes.reduce((m, p) => Math.max(m, a.byId[p.id].task_total || 0), 0);
-
-    const nodes = svgEl('g', { class: 'gm-nodes' }, svg);
-    lay.nodes.forEach((p) => {
-      const n = a.byId[p.id];
-      const g = svgEl('g', { class: `gm-node gm-c${lib.colourOf(n, cats)}`, transform: `translate(${p.x} ${p.y})` }, nodes);
-      const cat = n.category ? n.category.label : 'No category';
-      svgEl('title', {}, g).textContent = `${lib.displayTitle(n)} — ${cat} — ${n.task_done} of ${n.task_total} tasks done`
-        + ` — waits on ${lib.plural(n.depends_on || 0, 'goal')}, needed by ${lib.plural(n.depended_on_by || 0, 'goal')}`;
-      svgEl('rect', { class: 'gm-card', width: p.w, height: p.h, rx: 8 }, g);
-      svgEl('rect', { class: 'gm-stripe', width: 6, height: p.h, rx: 3 }, g);
-      [['gm-name', 22, lib.displayTitle(n)], ['gm-cat', 38, cat], ['gm-tasks', 53, `${n.task_done} of ${lib.plural(n.task_total, 'task')} done`]]
-        .forEach(([cls, y, full]) => {
-          const el = text(g, cls, TEXT_X, y, full);
-          el.setAttribute('clip-path', 'url(#gm-text-clip)');
-          lines.push({ el, full });
-        });
-      const trackW = p.w - 32;
-      svgEl('rect', { class: 'gm-weight-track', x: 16, y: 60, width: trackW, height: 3, rx: 1.5 }, g);
-      const frac = lib.weightOf(n.task_total, maxTotal);
-      if (frac > 0) svgEl('rect', { class: 'gm-weight-fill', x: 16, y: 60, width: Math.max(3, trackW * frac), height: 3, rx: 1.5 }, g);
-    });
-    return svg;
-  }
-
-  function renderGraph(a, cats, described) {
-    const host = $('gm-graph');
-    if (!a.connected) {
-      host.innerHTML = `<p class="scroll__lede">${escapeHtml(described.graph || described.summary)}</p>`;
-      return;
-    }
-    host.innerHTML = `
-      <figure class="gm-figure">
-        <figcaption id="gm-cap" class="scroll__lede">
-          An arrow runs from the goal that has to ship first to the goal that waits on it, and a thicker line means more
-          tasks are waiting. Every goal in this map, and every dependency, is also in the table below.
-        </figcaption>
-        <div class="gm-scroll" id="gm-scroll" tabindex="0" role="region" aria-label="Goal map — scrolls sideways inside this box"></div>
-      </figure>`;
-    const lay = lib.layout(a);
-    const lines = [];
-    $('gm-scroll').appendChild(drawGraph(a, lay, cats, lines));
-    const fit = () => fitNodeText(lines, lay.nodeW - 2 * TEXT_X);
-    fit();
-    // A web font that lands after the first fit changes every width.
-    if (document.fonts && document.fonts.status !== 'loaded') document.fonts.ready.then(fit);
-  }
-
-  function renderLegend(cats) {
-    const host = $('gm-legend');
-    if (!cats.list.length && !cats.uncategorised) { host.hidden = true; return; }
-    const swatch = (cls) => `<span class="gm-swatch ${cls}" aria-hidden="true"></span>`;
-    host.innerHTML = cats.list.map((c) => `<li>${swatch(`gm-c${c.colour}`)}${escapeHtml(c.label)} <span class="gm-n">${c.count}</span></li>`).join('')
-      + (cats.uncategorised ? `<li>${swatch('gm-cnone')}No category <span class="gm-n">${cats.uncategorised}</span></li>` : '');
-    host.hidden = false;
-  }
-
-  // ---- the stand-alone goals ------------------------------------------------------
-
-  function renderAlone(a) {
-    const section = $('gm-alone-scroll');
-    if (!a.isolated.length || !a.connected) { section.hidden = true; return; }
-    $('gm-alone-lede').textContent = `${lib.plural(a.isolated.length, 'goal')} ${a.isolated.length === 1 ? 'has' : 'have'} no task that waits on another goal’s work, `
-      + 'and none that another goal waits on, so there is nothing to draw between them and another goal. They are listed here instead of drawn as dots.';
-    $('gm-alone').innerHTML = a.isolated.map((id) => {
-      const n = a.byId[id];
-      const label = lib.displayTitle(n);
-      const facts = (n.category ? `${escapeHtml(n.category.label)} · ` : '') + lib.plural(n.task_total, 'task');
-      const inner = `<span>${escapeHtml(label)}</span><span class="gm-n">${facts}</span>`;
-      return n.title
-        ? `<li><a class="fact-chip gm-chip" href="${goalHref(id)}">${inner}</a></li>`
-        : `<li><span class="fact-chip gm-chip">${inner}</span></li>`;
-    }).join('');
-    section.hidden = false;
-  }
-
-  // ---- the table (primary) ----------------------------------------------------------
-
-  const depList = (list) => (list.length
-    ? `<ul class="gm-deps">${list.map((x) => `<li>${escapeHtml(x.title)} <span class="gm-n">· ${lib.plural(x.count, 'task')}</span></li>`).join('')}</ul>`
-    : '<span class="gm-none">—</span>');
-
-  function rowHtml(r) {
-    const title = r.isPrivate
-      ? `<span class="gm-private">${escapeHtml(r.title)}</span>`
-      : `<a class="lb-name" href="${goalHref(r.id)}">${escapeHtml(r.title)}</a>`;
-    return `<tr>
-      <td>${title}</td>
-      <td>${r.category ? escapeHtml(r.category) : '<span class="gm-none">—</span>'}</td>
-      <td class="ledger__num">${r.done} of ${r.total}</td>
-      <td>${depList(r.waits)}</td>
-      <td>${depList(r.needed)}</td>
-      <td>${escapeHtml(r.clusterLabel)}</td>
-      <td>${escapeHtml(r.version)}</td>
-    </tr>`;
-  }
-
-  function renderTable(a) {
-    const section = $('gm-table-scroll');
-    const rows = lib.tableRows(a);
-    section.hidden = false;
-    const pager = kit.makePager('gm', 'hall-goal-map-per-page', { defaultPerPage: 100 });
-    const ledger = kit.makeLedger({
-      mount: $('gm-table'),
-      columns: ['Goal', 'Category', { label: 'Tasks done', class: 'ledger__num' }, 'Waits on', 'Needed by', 'Cluster', 'Version'],
-      rowHtml,
-      emptyMsg: 'No goal carries any work yet.',
-      pager,
-    });
-    ledger.render(rows);
-    const table = $('gm-table').querySelector('table');
-    if (table) table.setAttribute('aria-label', 'Every goal, with what it waits on and what waits on it');
-  }
-
-  // ---- boot ---------------------------------------------------------------------------
-
-  function notice(msg) {
-    $('gm-sub').textContent = msg;
-    $('gm-graph').innerHTML = `<p class="note">${escapeHtml(msg)}</p>`;
-  }
-
-  async function boot() {
-    let payload;
-    try {
-      const res = await fetch(`${API}/goals/graph`, { credentials: 'same-origin', headers: { Accept: 'application/json' } });
-      if (res.status === 401) { window.location.assign(`${API}/auth/web/start`); return; }
-      if (!res.ok) throw new Error(`graph → ${res.status}`);
-      payload = await res.json();
-    } catch (err) {
-      console.error('[goal-map] load failed', err);
-      notice('Couldn’t load the goal map right now.');
-      return;
-    }
-    const a = lib.analyse(payload);
-    const cats = lib.categories(a);
-    const described = lib.describe(a);
-    $('gm-sub').textContent = described.summary;
-    if (!a.order.length) {
-      $('gm-graph').innerHTML = kit.emptyStateHtml(described.summary);
-      return;
-    }
-    renderGraph(a, cats, described);
-    renderLegend(cats);
-    renderAlone(a);
-    renderTable(a);
-  }
-
-  boot();
-})();

package/tests/goal_map_lib.mjs

@@ -1,214 +0,0 @@
-// tests/goal_map_lib.mjs — the goal map's model and layout, EXECUTED (task
-// 1003479, goal 1000089, ADR 0227 §6 item 3 + the §10.4 amendment).
-//
-// goal-map-lib.js is pure, so this runs the real code over the real harness
-// fixture and over a synthetic corpus built to the SHAPE the ADR measured on the
-// live database (70 goals, 34 of them with no edge, the rest in one large cluster
-// and a scatter of small ones). What is pinned is what a reader would otherwise
-// have to trust the picture about: that no goal is drawn twice or on top of
-// another, that a goal always sits to the right of what it waits on, that the
-// stand-alone goals never reach the canvas, that the same data always gives the
-// same picture, and that every fact the picture carries is also a table cell.
-//
-// Run:  node tests/goal_map_lib.mjs
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { makeRunner } from './helpers.mjs';
-
-const require = createRequire(import.meta.url);
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const LIB_PATH = path.join(ROOT, 'modules/hall-ui/public/goal-map-lib.js');
-const L = require(LIB_PATH);
-const FIXTURE = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/goals__graph.json'), 'utf8'));
-
-const { test, summary } = makeRunner();
-
-const node = (id, extra = {}) => ({ goal_id: String(id), title: `Goal ${id}`, status: 'open', version_id: 'V1', category: null, task_total: 5, task_done: 2, ...extra });
-const edge = (from, to, count = 1) => ({ from: String(from), to: String(to), count });
-
-function overlaps(a, b) {
-  return a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
-}
-function assertSound(a, lay, label) {
-  const ids = lay.nodes.map((n) => n.id);
-  assert.equal(new Set(ids).size, ids.length, `${label}: no goal is drawn twice`);
-  assert.equal(ids.length, a.connected, `${label}: exactly the connected goals are drawn`);
-  for (let i = 0; i < lay.nodes.length; i++) {
-    for (let j = i + 1; j < lay.nodes.length; j++) {
-      assert.equal(overlaps(lay.nodes[i], lay.nodes[j]), false, `${label}: ${lay.nodes[i].id} overlaps ${lay.nodes[j].id}`);
-    }
-  }
-  for (const n of lay.nodes) {
-    assert.ok(n.x >= 0 && n.y >= 0, `${label}: ${n.id} is on the canvas`);
-    assert.ok(n.x + n.w <= lay.width && n.y + n.h <= lay.height, `${label}: ${n.id} fits inside the svg's own size`);
-  }
-}
-
-// A deterministic synthetic corpus with the measured shape: `clusterSizes` goals
-// wired into connected clusters (each a chain plus a few extra edges) and `alone`
-// goals with no edge. A tiny LCG, so the test is the same on every machine.
-function synth(clusterSizes, alone) {
-  let seed = 20260919;
-  const rnd = () => { seed = (seed * 1664525 + 1013904223) % 4294967296; return seed / 4294967296; };
-  const nodes = []; const edges = []; let id = 1000;
-  for (const size of clusterSizes) {
-    const ids = [];
-    for (let i = 0; i < size; i++) { ids.push(++id); nodes.push(node(id, { category: rnd() < 0.5 ? { id: '1', slug: 'security', label: 'Security' } : null })); }
-    for (let i = 1; i < size; i++) edges.push(edge(ids[i], ids[Math.floor(rnd() * i)], 1 + Math.floor(rnd() * 4)));
-    for (let k = 0; k < Math.floor(size / 3); k++) {
-      const a = ids[Math.floor(rnd() * size)]; const b = ids[Math.floor(rnd() * size)];
-      if (a !== b && !edges.some((e) => e.from === String(a) && e.to === String(b))) edges.push(edge(a, b));
-    }
-  }
-  for (let i = 0; i < alone; i++) nodes.push(node(++id));
-  return { nodes, edges };
-}
-
-// ---- structure -----------------------------------------------------------------
-
-await test('the goals split into connected and stand-alone, and the two add up', () => {
-  const a = L.analyse({ nodes: [node(1), node(2), node(3), node(4)], edges: [edge(1, 2)] });
-  assert.equal(a.connected, 2);
-  assert.deepEqual(a.isolated, ['3', '4']);
-  assert.equal(a.connected + a.isolated.length, a.order.length);
-});
-
-await test('clusters are found, largest first, and every connected goal knows its cluster', () => {
-  const a = L.analyse({ nodes: [1, 2, 3, 4, 5, 6, 7].map((i) => node(i)), edges: [edge(1, 2), edge(3, 4), edge(4, 5), edge(5, 6)] });
-  assert.deepEqual(a.clusters.map((c) => c.length), [4, 2]);
-  assert.equal(a.clusterOf['3'].index, 1);
-  assert.equal(a.clusterOf['3'].size, 4);
-  assert.equal(a.clusterOf['1'].index, 2);
-  assert.equal(a.clusterOf['7'], undefined, 'a stand-alone goal belongs to no cluster');
-});
-
-await test('an edge to an unknown goal, a self edge and a duplicate are ignored, not drawn to nowhere', () => {
-  const a = L.analyse({ nodes: [node(1), node(2)], edges: [edge(1, 99), edge(2, 2), edge(1, 2, 3), edge(1, 2, 3)] });
-  assert.equal(a.edges.length, 1);
-});
-
-// ---- layout --------------------------------------------------------------------
-
-await test('a goal sits to the RIGHT of every goal it waits on (dependencies read left to right)', () => {
-  const a = L.analyse({ nodes: [1, 2, 3, 4].map((i) => node(i)), edges: [edge(2, 1), edge(3, 2), edge(4, 2)] });
-  const lay = L.layout(a);
-  const x = Object.fromEntries(lay.nodes.map((n) => [n.id, n.x]));
-  for (const e of a.edges) assert.ok(x[e.to] < x[e.from], `${e.from} waits on ${e.to}, so must be right of it`);
-});
-
-await test('stand-alone goals are never drawn — they are a list, not dots on an empty canvas', () => {
-  const a = L.analyse({ nodes: [node(1), node(2), node(3)], edges: [edge(1, 2)] });
-  const lay = L.layout(a);
-  assert.deepEqual(lay.nodes.map((n) => n.id).sort(), ['1', '2']);
-});
-
-await test('a loop (two goals each waiting on the other) terminates and places both', () => {
-  const a = L.analyse({ nodes: [node(1), node(2), node(3)], edges: [edge(1, 2), edge(2, 1), edge(3, 1)] });
-  const lay = L.layout(a);
-  assert.equal(lay.nodes.length, 3);
-  assertSound(a, lay, 'loop');
-});
-
-await test('the same data always gives the same picture (no random seed, no drift between visits)', () => {
-  const p = synth([9, 4, 3], 6);
-  assert.deepEqual(L.layout(L.analyse(p)), L.layout(L.analyse(p)));
-});
-
-await test('every edge path starts at its dependency and ends at its dependent', () => {
-  const a = L.analyse({ nodes: [node(1), node(2)], edges: [edge(2, 1, 4)] });
-  const lay = L.layout(a);
-  const by = Object.fromEntries(lay.nodes.map((n) => [n.id, n]));
-  const [e] = lay.edges;
-  assert.ok(e.d.startsWith(`M${by['1'].x + lay.nodeW} ${by['1'].y + lay.nodeH / 2}`), 'leaves the dependency’s right edge');
-  assert.ok(e.d.endsWith(`${by['2'].x} ${by['2'].y + lay.nodeH / 2}`), 'arrives at the dependent’s left edge');
-  assert.ok(e.width >= 1 && e.width <= 3);
-});
-
-await test('the harness fixture lays out soundly — one large cluster, pairs, a loop and a private goal', () => {
-  const a = L.analyse(FIXTURE);
-  const lay = L.layout(a);
-  assertSound(a, lay, 'fixture');
-  assert.ok(a.clusters.length >= 4 && a.clusters[0].length > a.clusters[1].length, 'reads as one cluster and a scatter');
-  assert.ok(a.isolated.length > 0);
-});
-
-await test('THE SCALE CHECK: the measured shape (70 goals, 34 alone, one big cluster) lays out soundly and fast', () => {
-  const p = synth([17, 6, 4, 3, 2, 2, 2], 34); // 36 connected + 34 alone = the measured 70
-  assert.equal(p.nodes.length, 70);
-  const a = L.analyse(p);
-  assert.equal(a.isolated.length, 34);
-  const t0 = Date.now();
-  const lay = L.layout(a);
-  const ms = Date.now() - t0;
-  assertSound(a, lay, 'scale');
-  assert.ok(ms < 500, `laid out in ${ms}ms`);
-  // The page scrolls the svg INSIDE its own box, so a wide picture is fine — but
-  // it must not be absurd: the largest cluster is a handful of columns, not a line.
-  assert.ok(lay.width < 3200, `width ${lay.width}`);
-});
-
-// ---- categories and the table ---------------------------------------------------
-
-await test('a category keeps its colour by alphabetical order of the labels present, and repeats past eight', () => {
-  const cats = ['Zeta', 'Alpha', 'Mid'].map((label, i) => ({ id: String(i), slug: label.toLowerCase(), label }));
-  const a = L.analyse({ nodes: [node(1, { category: cats[0] }), node(2, { category: cats[1] }), node(3, { category: cats[2] }), node(4)], edges: [] });
-  const c = L.categories(a);
-  assert.deepEqual(c.list.map((x) => x.label), ['Alpha', 'Mid', 'Zeta']);
-  assert.deepEqual(c.list.map((x) => x.colour), [0, 1, 2]);
-  assert.equal(c.uncategorised, 1);
-  assert.equal(L.colourOf(a.byId['4'], c), 'none', 'uncategorised is legal and wears no colour');
-  const many = Array.from({ length: 10 }, (_, i) => ({ id: String(i), slug: `c${String(i).padStart(2, '0')}`, label: `C${String(i).padStart(2, '0')}` }));
-  const big = L.categories(L.analyse({ nodes: many.map((m, i) => node(i + 1, { category: m })), edges: [] }));
-  assert.equal(big.list[8].colour, 0, 'the ninth wraps — the WORD on the node still says which it is');
-});
-
-await test('the table has one row per goal and carries every fact the picture does, both directions by name', () => {
-  const a = L.analyse({ nodes: [node(1, { title: 'Base', task_total: 9, task_done: 4, category: { id: '1', slug: 's', label: 'Security' } }), node(2, { title: 'Top' }), node(3, { title: 'Alone' })], edges: [edge(2, 1, 6)] });
-  const rows = L.tableRows(a);
-  assert.equal(rows.length, 3, 'stand-alone goals are rows too — the table is the whole map');
-  const base = rows.find((r) => r.id === '1');
-  const top = rows.find((r) => r.id === '2');
-  assert.equal(base.category, 'Security');
-  assert.equal(base.done + '/' + base.total, '4/9');
-  assert.deepEqual(top.waits, [{ id: '1', title: 'Base', count: 6 }]);
-  assert.deepEqual(base.needed, [{ id: '2', title: 'Top', count: 6 }]);
-  assert.equal(top.clusterLabel, 'Cluster 1 · 2 goals');
-  assert.equal(rows.find((r) => r.id === '3').clusterLabel, 'Stands alone');
-  assert.equal(rows[rows.length - 1].id, '3', 'stand-alone goals sort last');
-});
-
-await test('a private goal is named as one, in the table and in a neighbour’s dependency list', () => {
-  const a = L.analyse({ nodes: [node(1, { title: null }), node(2)], edges: [edge(2, 1)] });
-  const rows = L.tableRows(a);
-  assert.equal(rows.find((r) => r.id === '1').title, 'A private goal');
-  assert.equal(rows.find((r) => r.id === '1').isPrivate, true);
-  assert.equal(rows.find((r) => r.id === '2').waits[0].title, 'A private goal');
-});
-
-await test('the split is STATED, with the measured numbers only', () => {
-  const a = L.analyse({ nodes: [1, 2, 3, 4, 5].map((i) => node(i)), edges: [edge(1, 2), edge(2, 3)] });
-  const d = L.describe(a);
-  assert.match(d.summary, /5 goals carry work/);
-  assert.match(d.summary, /3 of them are tied to another goal/);
-  assert.match(d.summary, /the other 2 stand alone/);
-  assert.match(d.summary, /form 1 cluster, the largest with 3 goals/);
-});
-
-await test('no edges at all is said plainly and the table is called the whole map (ADR 0227 §3: the right amount of map may be none)', () => {
-  const d = L.describe(L.analyse({ nodes: [node(1), node(2)], edges: [] }));
-  assert.match(d.graph, /no graph to draw — the table below is the whole map/);
-  assert.match(L.describe(L.analyse({ nodes: [], edges: [] })).summary, /No goal carries any work/);
-});
-
-// ---- purity -----------------------------------------------------------------------
-
-await test('the lib is pure and cannot reach a task: no DOM, no fetch, no task input', () => {
-  const src = fs.readFileSync(LIB_PATH, 'utf8').replace(/^\s*\/\/.*$/gm, '');
-  assert.equal(/\bdocument\b|\bfetch\b|\bwindow\b|XMLHttpRequest/.test(src.replace(/root\.OTBGoalMapLib/, '')), false);
-  assert.equal(/task_id|\/tasks\b|\.tasks\b/.test(src), false, 'view A/D need task rows; this file has nowhere to put one (ADR 0227 §7)');
-});
-
-summary();