@bongos/core 1.21.5 → 1.21.7

package/tests/hall_audit.mjs

@@ -369,7 +369,16 @@ test('the module doc still records where the 2179 density pass landed', () => {
 // /thinking left this list in task 1004327 (owner decision 2026-09-27): it sits
 // in the hall chrome now, with the shell's full-screen switch to hide it. The
 // project sky (/goal-map) followed in task 1004430, so the list is empty again.
-const STANDALONE_EXEMPT = {};
+// THE GOVERNOR CITY's home (task 1004524, goal 1000125) is on it now, for the
+// reason the sky first was: the task and its reference design
+// (docs/design/mocks/governor-city/Street.dc.html, the home view) say nothing
+// else is on the page but the wordmark, a sun/moon switch, start governing and
+// one line. It still loads style.css (the hall's tokens, so no private palette:
+// city.css spends var(--bg), var(--ink), var(--accent) …), and reads and writes
+// the hall's own 'hall-theme' preference. Whether it should join the chrome
+// behind the full-screen switch, as the sky did in task 1004327, is the
+// owner's call, named in that task's ship notes.
+const STANDALONE_EXEMPT = { 'city.html': 'the governor city home: nothing on the page but the prototype home (task 1004524)' };
 
 test('every hall page loads style.css and shell.js', () => {
   const missing = [];

package/tests/hall_city.mjs

@@ -0,0 +1,369 @@
+// tests/hall_city.mjs — THE GOVERNOR CITY's home (task 1004524, goal 1000125).
+//
+// WHAT IT GUARDS. The page is the home view of the reference design
+// (docs/design/mocks/governor-city/Street.dc.html) built over the governor
+// docket (task 1004523) and the open goals' task rollups. What can go wrong:
+//   * the drawing drifts from the prototype (a civic recipe, the ground, a pin
+//     position) — pinned by running the PROTOTYPE'S OWN Component class beside
+//     city-draw.js and comparing the paths they emit, in both modes;
+//   * a pin drawn in the wrong state or over the wrong building, or invented
+//     where the docket has no matter;
+//   * a district for a goal that is not open, two goals on one plot, a plot on
+//     the ring road, or a task with no building;
+//   * the line under the button saying anything but the docket's own line;
+//   * the start governing button going anywhere but the street;
+//   * the switch not using the hall's own preference, so the city opens in a
+//     different mode from every other hall page;
+//   * motion that escapes the Kill Switch, or docket text reaching innerHTML.
+//
+// Run:  node tests/hall_city.mjs
+
+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 { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const require = createRequire(import.meta.url);
+const City = require(path.join(PUB, 'city-draw.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+
+// The prototype's Component class, run under a stub DCLogic: the reference
+// the port is held equal to.
+function prototype() {
+  const src = fs.readFileSync(path.join(ROOT, 'docs/design/mocks/governor-city/Street.dc.html'), 'utf8');
+  const script = src.split('data-dc-script')[1].split('>').slice(1).join('>').split('</script>')[0];
+  const DCLogic = class { constructor(p) { this.props = p || {}; this.state = {}; } setState() {} };
+  return new Function('DCLogic', `${script}\nreturn Component;`)(DCLogic);
+}
+const Proto = prototype();
+
+// A docket in the route's own shape (modules/government/docket.js buildDocket).
+function matter(over = {}) {
+  return { id: 'blockers:1', source: 'blockers', building: 'planning', rule: 'majority', state: 'needs', title: 'A matter', short: 'a matter', where: 'Planning', opened_at: null, deadline: null, proposer: null, tally: null, href: null, ref: null, ...over };
+}
+function docket(matters = [], line = null) {
+  const counts = { needs: 0, moving: 0, settled: 0 };
+  matters.forEach((m) => { counts[m.state] += 1; });
+  return { viewer: { id: '1' }, generated_at: '2026-10-02T00:00:00.000Z', counts, line: line || `${counts.needs} matters wait on you`, matters, buildings: [], sources: [], readings: [], vocabulary: {} };
+}
+const goal = (id, status = 'open') => ({ id: String(id), title: `Goal ${id}`, status });
+const rollup = (id, c) => ({ goal_id: String(id), done: 0, active: 0, ready: 0, blocked: 0, backlog: 0, cut: 0, ...c });
+
+// ── the drawing is the prototype's ───────────────────────────────────────────
+
+test('the nine civic recipes draw exactly the prototype paths, in both modes', () => {
+  for (const mode of ['dark', 'light']) {
+    const p = new Proto({ mode });
+    const T = p.theme(mode);
+    const pk = p.isoKit(60, 30, 720, 176, 30 / 28, T.iso, false);
+    const ck = City.isoKit(60, 30, 720, 176, 30 / 28, City.isoTheme(mode), false);
+    for (const [kind, x, y] of City.CIVIC_SLOTS) {
+      const a = []; const b = [];
+      p.isoInstitution(a, pk, kind, x, y, { fixes: false });
+      City.isoInstitution(b, ck, kind, x, y, { fixes: false });
+      assert.deepEqual(b, a, `${mode} ${kind}`);
+    }
+  }
+});
+
+test('the iso sub-palette is the prototype theme().iso, both modes', () => {
+  for (const mode of ['dark', 'light']) assert.deepEqual(City.isoTheme(mode), new Proto({ mode }).theme(mode).iso, mode);
+});
+
+test('every work kind the prototype draws is drawn the same way', () => {
+  const p = new Proto({ mode: 'dark' });
+  const pk = p.isoKit(60, 30, 720, 176, 30 / 28, p.theme('dark').iso, true);
+  const ck = City.isoKit(60, 30, 720, 176, 30 / 28, City.isoTheme('dark'), true);
+  for (const kind of ['tower', 'setback', 'shed', 'trees', 'scaffold']) {
+    const a = []; const b = [];
+    p.isoWork(a, pk, 6, 2, kind, 58);
+    City.isoWork(b, ck, 6, 2, kind, 58);
+    assert.deepEqual(b, a, kind);
+  }
+});
+
+test('the ground, ring road, lanes and plaza are the prototype home view, path for path', () => {
+  const p = new Proto({ mode: 'light' });
+  p.state = p.initial();
+  p.state.reviewHeld = true;
+  const T = p.theme('light');
+  const home = p.homeView(T, p.matters(), false);
+  const model = City.cityModel({ docket: docket([matter()]), goals: [], rollups: [], mode: 'light' });
+  // The prototype's flat list is ground, 4 roads, lanes, plaza, then its 4 plots and their grid.
+  assert.deepEqual(model.flat.slice(0, 7), home.flat.slice(0, 7));
+});
+
+test('with four goals the districts sit on the prototype\'s four plots, in its order', () => {
+  const lots = City.lotsFor(4).map((l) => [l.x0, l.x1, l.y0, l.y1, l.tall]);
+  assert.deepEqual(lots, [[5, 10, 0, 3, 60], [12, 15, 5, 10, 100], [0, 3, 5, 10, 120], [5, 10, 12, 15, 50]]);
+});
+
+test('the decision glyphs match the prototype (and the guide for first and signoff)', () => {
+  const p = new Proto({ mode: 'dark' });
+  for (const k of ['decide', 'majority', 'unanimous', 'consent', 'rule']) assert.deepEqual(City.glyph(k, 7, 7, 13), p.glyph(k, 7, 7, 13), k);
+  assert.ok(City.glyph('first', 7, 7, 13).fill && City.glyph('signoff', 7, 7, 13).line);
+  assert.deepEqual(City.glyph(null, 7, 7, 13), { fill: '', line: '' }, 'an unknown rule draws no mark, never the nearest one');
+});
+
+// ── pins come from the docket, and only from it ─────────────────────────────
+
+test('a pin per open matter, in its state, over its building', () => {
+  const ms = [
+    matter({ id: 'board:1', building: 'charter', state: 'needs', rule: 'unanimous' }),
+    matter({ id: 'blockers:2', building: 'planning', state: 'moving' }),
+    matter({ id: 'removal_proposals:3', building: 'disputes', state: 'settled', rule: 'decide' }),
+  ];
+  const m = City.cityModel({ docket: docket(ms), goals: [], rollups: [], mode: 'dark' });
+  assert.deepEqual(m.pins.map((p) => [p.key, p.building, p.state]), [
+    ['blockers:2', 'planning', 'moving'], ['board:1', 'charter', 'needs'], ['removal_proposals:3', 'disputes', 'settled'],
+  ]);
+  // the prototype's own pin position for a matter at the Charter: P(8, 8, 158 + 8)
+  const charter = m.pins.find((p) => p.building === 'charter');
+  const k = City.isoKit(60, 30, 720, 176, 30 / 28, City.isoTheme('dark'), false);
+  const top = k.P(8, 8, 166);
+  assert.equal(charter.x, Math.round((top[0] - 15) * 10) / 10);
+  assert.equal(charter.y, Math.round((top[1] - 52) * 10) / 10);
+});
+
+test('no docket, no pins: a failed read draws none and says so', () => {
+  const m = City.cityModel({ docket: null, goals: [goal(1)], rollups: [rollup(1, { done: 2 })], mode: 'dark' });
+  assert.equal(m.pins.length, 0);
+  assert.equal(m.line, City.FALLBACK_LINE);
+  assert.equal(m.districts.length, 1, 'the goals still stand when only the docket failed');
+});
+
+test('the line is the docket\'s own line, word for word', () => {
+  const m = City.cityModel({ docket: docket([matter()], '1 matter waits on you'), mode: 'dark' });
+  assert.equal(m.line, '1 matter waits on you');
+});
+
+test('at most three pins stand over one building, needs first as the docket ordered them', () => {
+  const ms = ['needs', 'needs', 'moving', 'moving', 'settled'].map((state, i) => matter({ id: `blockers:${i}`, state }));
+  const m = City.cityModel({ docket: docket(ms), mode: 'dark' });
+  assert.equal(m.pins.length, City.MAX_PINS_PER_BUILDING);
+  assert.deepEqual(m.pins.map((p) => p.state), ['needs', 'needs', 'moving']);
+  assert.equal(new Set(m.pins.map((p) => p.x)).size, 3, 'abreast, not stacked on one spot');
+});
+
+test('a matter at a building the city does not have is not drawn, and an unknown state is never "needs"', () => {
+  const m = City.cityModel({ docket: docket([matter({ building: 'nowhere' }), matter({ id: 'x:1', state: 'weird' })]), mode: 'dark' });
+  assert.equal(m.pins.length, 1);
+  assert.equal(m.pins[0].state, 'moving');
+});
+
+test('the windows light (evening) only when nothing waits on you', () => {
+  assert.equal(City.cityModel({ docket: docket([matter({ state: 'moving' })]), mode: 'dark' }).evening, true);
+  assert.equal(City.cityModel({ docket: docket([matter({ state: 'needs' })]), mode: 'dark' }).evening, false);
+  assert.equal(City.cityModel({ docket: null, mode: 'dark' }).evening, false, 'an unread docket is not an empty one');
+});
+
+// ── a district per open goal, a building per task ───────────────────────────
+
+test('one district per OPEN goal; achieved and archived goals build nothing', () => {
+  const m = City.cityModel({ docket: docket(), goals: [goal(1), goal(2, 'achieved'), goal(3), goal(4, 'archived')], rollups: [], mode: 'dark' });
+  assert.deepEqual(m.districts.map((d) => d.goal_id), ['1', '3']);
+});
+
+test('plots never overlap, never touch the roads or the plaza, and stay on the 16 x 16 ground', () => {
+  for (const n of [1, 4, 5, 8, 9, 12, 15, 16, 30]) {
+    const lots = City.lotsFor(n);
+    assert.equal(lots.length, Math.min(n, City.MAX_DISTRICTS), `n=${n}`);
+    const seen = new Set();
+    lots.forEach((l) => {
+      for (let x = l.x0; x <= l.x1; x++) for (let y = l.y0; y <= l.y1; y++) {
+        const key = `${x},${y}`;
+        assert.ok(!seen.has(key), `n=${n}: tile ${key} on two plots`);
+        seen.add(key);
+        assert.ok(x >= 0 && x <= 15 && y >= 0 && y <= 15, `n=${n}: ${key} off the ground`);
+        assert.ok(x !== 4 && x !== 11 && y !== 4 && y !== 11, `n=${n}: ${key} on the ring road`);
+        assert.ok(!(x >= 5 && x <= 10 && y >= 5 && y <= 10), `n=${n}: ${key} in the plaza`);
+      }
+    });
+  }
+});
+
+test('goals past sixteen are reported, not silently dropped', () => {
+  const goals = Array.from({ length: 19 }, (_, i) => goal(i + 1));
+  const m = City.cityModel({ docket: docket(), goals, rollups: [], mode: 'dark' });
+  assert.equal(m.districts.length, 16);
+  assert.deepEqual(m.unplaced, ['17', '18', '19']);
+});
+
+test('a building per task: shipped built, being built a scaffold, not started a slab', () => {
+  const lot = City.lotsFor(1)[0];
+  const work = City.districtWork(lot, rollup(1, { done: 3, active: 1, ready: 1, blocked: 1, cut: 9 })).filter((w) => w.kind !== 'trees');
+  assert.equal(work.length, 6, 'cut work builds nothing');
+  assert.equal(work.filter((w) => ['tower', 'setback', 'shed'].includes(w.kind)).length, 3);
+  assert.equal(work.filter((w) => w.kind === 'scaffold').length, 1);
+  assert.equal(work.filter((w) => w.kind === 'slab').length, 2);
+  assert.ok(work.every((w) => w.tasks === 1));
+});
+
+test('past a full plot, every task still stands in a building, and they rise', () => {
+  const lot = City.lotsFor(1)[0];
+  const tiles = (lot.x1 - lot.x0 + 1) * (lot.y1 - lot.y0 + 1);
+  const r = rollup(1, { done: 200, active: 3, ready: 20 });
+  const work = City.districtWork(lot, r).filter((w) => w.kind !== 'trees');
+  assert.ok(work.length <= tiles);
+  assert.equal(work.reduce((s, w) => s + w.tasks, 0), 223);
+  const one = City.districtWork(lot, rollup(1, { done: 1 }))[0];
+  const many = work.find((w) => w.gx === one.gx && w.gy === one.gy);
+  assert.ok(many.h > one.h, 'the same tile stands taller when it carries more work');
+  assert.ok(many.h <= Math.round((20 + lot.tall) * 1.25), 'but the rise is capped');
+});
+
+test('the drawing is deterministic: the same feeds give the same city', () => {
+  const input = { docket: docket([matter()]), goals: [goal(1), goal(2)], rollups: [rollup(1, { done: 5 }), rollup(2, { active: 2 })], mode: 'light' };
+  assert.deepEqual(City.cityModel(input), City.cityModel(input));
+});
+
+test('parcels ride only the roads of plots that hold a district, and leave through Release', () => {
+  const none = City.cityModel({ docket: docket(), goals: [], rollups: [], mode: 'dark' });
+  assert.equal(none.parcels.length, 0);
+  const two = City.cityModel({ docket: docket(), goals: [goal(1), goal(2)], rollups: [], mode: 'dark' });
+  assert.deepEqual(two.parcels.map((p) => p.key), ['p00', 'p01', 'p10', 'p11', 'out0', 'out1']);
+  assert.ok(two.parcels.filter((p) => p.out).length === 2);
+});
+
+// ── the page ────────────────────────────────────────────────────────────────
+
+test('the page holds only the wordmark, the switch, the city, one button and one line', () => {
+  const html = read('city.html').replace(/<!--[\s\S]*?-->/g, ''); // the markup, not the prose about it
+  assert.equal((html.match(/<header\b/g) || []).length, 1);
+  assert.equal((html.match(/<main\b/g) || []).length, 1);
+  assert.equal((html.match(/<h1\b/g) || []).length, 1);
+  assert.match(html, /<a class="city-start" id="cityStart" href="\/builders\/street"/);
+  assert.equal((html.match(/<a\b/g) || []).length, 1, 'one door');
+  assert.equal((html.match(/<button\b/g) || []).length, 1, 'one switch');
+  assert.match(html, /class="city-mark">\{\{productName\}\}</);
+  assert.doesNotMatch(html, /app-sidebar|shell\.js/, 'no hall chrome on the city');
+  assert.equal(City.STREET_HREF, '/builders/street');
+});
+
+test('motion is CSS only and dies under reduced motion; no page :root; no innerHTML', () => {
+  const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(css, /:root/);
+  assert.match(css, /@media \(prefers-reduced-motion: reduce\) \{[^}]*animation: none !important; transition: none !important;/);
+  for (const k of ['city-ring', 'city-zoom', 'city-travel', 'city-bob', 'city-drift']) assert.match(css, new RegExp(`@keyframes ${k} `));
+  assert.match(css, /offset-rotate/);
+  const js = (read('city.js') + read('city-draw.js')).replace(/^\s*\/\/.*$/gm, ''); // code, not its comments
+  assert.doesNotMatch(js, /innerHTML|insertAdjacentHTML|requestAnimationFrame|setInterval/);
+});
+
+test('the two dark blocks are byte-identical twins', () => {
+  const css = read('city.css');
+  const a = css.match(/html\[data-theme="dark"\] body\[data-page="city"\] \{([^}]*)\}/)[1];
+  const b = css.match(/html:not\(\[data-theme\]\) body\[data-page="city"\] \{([^}]*)\}/)[1];
+  assert.equal(a.replace(/\s+/g, ' ').trim(), b.replace(/\s+/g, ' ').trim());
+});
+
+// A small DOM, enough for city.js: ids, elements, SVG elements, attributes.
+function fakeDom() {
+  const byId = new Map();
+  const mk = (tag) => {
+    const el = {
+      tagName: tag, attrs: {}, children: [], style: { setProperty(k, v) { this[k] = v; } }, className: '', listeners: {}, _text: '',
+      get firstChild() { return this.children[0] || null; },
+      setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'id') byId.set(String(v), this); },
+      getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+      appendChild(c) { this.children.push(c); c.parentNode = this; return c; },
+      removeChild(c) { this.children = this.children.filter((x) => x !== c); return c; },
+      addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+      fire(t) { (this.listeners[t] || []).forEach((fn) => fn({ type: t })); },
+      set textContent(v) { this._text = String(v); this.children = []; },
+      get textContent() { return this._text; },
+      get innerHTML() { throw new Error('city.js must not read innerHTML'); },
+      set innerHTML(v) { throw new Error('city.js must not write innerHTML'); },
+    };
+    return el;
+  };
+  const html = mk('html');
+  for (const id of ['cityMode', 'cityModeIcon', 'cityStage', 'cityFlat', 'cityBlds', 'cityParcels', 'cityPins', 'cityLine', 'cityStart']) mk('x').setAttribute('id', id);
+  const document = {
+    documentElement: html,
+    getElementById: (id) => byId.get(id) || null,
+    createElement: (t) => mk(t),
+    createElementNS: (_ns, t) => mk(t),
+  };
+  return { document, byId, html };
+}
+
+async function bootPage({ feeds = {}, stored = null, osDark = true } = {}) {
+  const { document, byId, html } = fakeDom();
+  const store = new Map(stored ? [['hall-theme', stored]] : []);
+  const calls = [];
+  const window = {
+    innerWidth: 1440, innerHeight: 900,
+    localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) },
+    matchMedia: () => ({ matches: osDark, addEventListener() {} }),
+    addEventListener() {},
+  };
+  const fetch = (url) => {
+    calls.push(url);
+    const body = feeds[url];
+    return Promise.resolve(body === undefined ? { ok: false, json: async () => ({}) } : { ok: true, json: async () => body });
+  };
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, console });
+  ctx.globalThis = ctx;
+  window.GovCity = undefined;
+  vm.runInContext(read('city-draw.js'), ctx);
+  window.GovCity = ctx.GovCity || ctx.window.GovCity;
+  vm.runInContext(read('city.js'), ctx);
+  await window.GovCityPage.ready;
+  return { window, byId, html, store, calls };
+}
+
+const FEEDS = (ms, goals = [goal(1)], rollups = [rollup(1, { done: 2, active: 1 })]) => ({
+  '/api/bongos/government/docket': docket(ms, '2 matters wait on you · 1 moving'),
+  '/api/bongos/goals': { goals },
+  '/api/bongos/goals/rollups': { rollups },
+});
+
+test('the page reads the three feeds and draws the docket\'s pins and line', async () => {
+  const ms = [matter({ id: 'board:1', building: 'charter', state: 'needs' }), matter({ id: 'blockers:2', state: 'needs' }), matter({ id: 'gate_approvals:3', building: 'release', state: 'moving' })];
+  const p = await bootPage({ feeds: FEEDS(ms) });
+  assert.deepEqual([...p.calls].sort(), ['/api/bongos/goals', '/api/bongos/goals/rollups', '/api/bongos/government/docket']);
+  const pins = p.byId.get('cityPins').children;
+  assert.equal(pins.length, 3);
+  assert.deepEqual(pins.map((s) => s.className).sort(), ['city-pin city-pin--moving', 'city-pin city-pin--needs', 'city-pin city-pin--needs']);
+  const needs = pins.find((s) => s.attrs['data-matter'] === 'board:1');
+  assert.equal(needs.children[0].children[0].className, 'city-pin__ring', 'a needs pin pulses');
+  const moving = pins.find((s) => s.className.includes('moving'));
+  assert.ok(!moving.children[0].children.some((c) => c.className === 'city-pin__ring'), 'a moving pin only bobs');
+  assert.equal(p.byId.get('cityLine').textContent, '2 matters wait on you · 1 moving');
+  assert.equal(p.byId.get('cityStart').attrs.href, '/builders/street');
+  assert.ok(p.byId.get('cityBlds').children.length > 9, 'the civic quarter and the district are drawn');
+  assert.ok(p.byId.get('cityParcels').children.some((s) => /offset/.test(Object.keys(s.style).join(' '))), 'parcels carry an offset-path');
+});
+
+test('a failed docket read draws no pins and says the docket could not be read', async () => {
+  const feeds = FEEDS([]);
+  delete feeds['/api/bongos/government/docket'];
+  const p = await bootPage({ feeds });
+  assert.equal(p.byId.get('cityPins').children.length, 0);
+  assert.equal(p.byId.get('cityLine').textContent, City.FALLBACK_LINE);
+});
+
+test('the switch reads and writes the hall\'s own theme preference', async () => {
+  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: true });
+  assert.equal(p.html.attrs['data-theme'], 'light', 'the stored hall choice beats the OS');
+  assert.equal(p.byId.get('cityMode').attrs['aria-label'], 'Switch to dark mode');
+  const before = JSON.stringify(p.byId.get('cityFlat').children[0].attrs);
+  p.byId.get('cityMode').fire('click');
+  assert.equal(p.store.get('hall-theme'), 'dark');
+  assert.equal(p.html.attrs['data-theme'], 'dark');
+  assert.equal(p.byId.get('cityMode').attrs['aria-label'], 'Switch to light mode');
+  assert.notEqual(JSON.stringify(p.byId.get('cityFlat').children[0].attrs), before, 'the city redraws in the new mode');
+  const q = await bootPage({ feeds: FEEDS([]), stored: null, osDark: true });
+  assert.equal(q.html.attrs['data-theme'], 'dark', 'no stored choice follows the OS');
+});
+
+test('docket text lands as text: a title with markup is never parsed', async () => {
+  const p = await bootPage({ feeds: FEEDS([matter({ title: '<img src=x onerror=alert(1)>', short: '<b>x</b>' })]) });
+  assert.equal(p.byId.get('cityPins').children.length, 1);
+});

package/tests/hall_page_gate_map.mjs

@@ -140,6 +140,11 @@ const ORACLE = {
   // no ballot (ADR 0175 §9 made the ballot open on purpose).
   '/builders/board-room': 'requireBoardVotePage',
 
+  // task 1004524: the Governor City's home, on the same vote atom. Its one
+  // governed read, GET /government/docket, checks board.vote.cast, so the page's
+  // reach equals the right to read the docket it draws.
+  '/builders/city': 'requireBoardVotePage',
+
   // Deliberately UNGATED — the landing card, the rank ladder, the reward
   // schedule and a builder's public portfolio all render for a stranger.
   //