@bongos/core 1.21.10 → 1.21.11

package/tests/hall_street_inside.mjs

@@ -0,0 +1,519 @@
+// tests/hall_street_inside.mjs — INSIDE EVERY BUILDING AND DISTRICT (task
+// 1004526, goal 1000125).
+//
+// WHAT IT GUARDS. The interiors are the reference design's buildingView() and
+// districtView() (docs/design/mocks/governor-city/Street.dc.html), filled from
+// the governor docket and the goal's tasks. What can go wrong:
+//   * the section drifts from the prototype (a slab, a wall, a lamp, the sign
+//     plate, a level number, the lift, the frame, the crown, the annex) —
+//     pinned by running the PROTOTYPE'S OWN Component class on its own sample
+//     floors beside street-inside.js and comparing what they emit, every
+//     building, both modes, before and after a pick;
+//   * the floor symbols or the district work drifting from the library;
+//   * a floor saying a number the docket does not hold (invented data), or a
+//     floor nothing reads yet looking like one that is read;
+//   * the lift not travelling (a node rebuilt on every draw cannot transition),
+//     the chosen floor's block not re-entering, the amendment button doing
+//     nothing silently;
+//   * a district drawing work from another goal, or a status as the wrong stage.
+//
+// Run:  node --test tests/hall_street_inside.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 S = require(path.join(PUB, 'street-draw.js'));
+const I = require(path.join(PUB, 'street-inside.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const NOW = Date.parse('2026-10-02T12:00:00.000Z');
+const j = (v) => JSON.parse(JSON.stringify(v));
+
+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();
+function proto(mode, st = {}) {
+  const p = new Proto({ mode });
+  p.state = Object.assign(p.initial(), st);
+  return p;
+}
+
+// a docket in the route's 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: '2026-09-29T10:00:00.000Z', deadline: null, proposer: null, tally: null, href: null, ref: null, ...over };
+}
+const SOURCES = [['board', 'charter'], ['blockers', 'planning'], ['access_requests', 'people'], ['goal_join_requests', 'people'], ['override_requests', 'release'], ['removal_proposals', 'disputes'], ['redteam_reports', 'disputes'], ['criteria_uat', 'review'], ['core_update', 'release'], ['gate_approvals', 'release'], ['autobongos_fence', 'automation'], ['module_rechecks', 'release'], ['grade_appeals', 'disputes'], ['standing_rules', 'rules'], ['treasury_spending', 'treasury']];
+const READINGS = [['flow', 'review'], ['promises', 'planning'], ['money', 'treasury'], ['people', 'people'], ['fairness', 'disputes'], ['rules', 'rules']];
+function docket(matters = [], over = {}) {
+  const counts = { needs: 0, moving: 0, settled: 0 };
+  matters.forEach((m) => { counts[m.state] += 1; });
+  return {
+    viewer: { id: '95' }, counts, line: '', matters,
+    buildings: S.CIVIC_KEYS.map((key) => ({ key, name: key[0].toUpperCase() + key.slice(1), group: '', counts: {}, matter_ids: matters.filter((m) => m.building === key).map((m) => m.id) })),
+    sources: SOURCES.map(([source, building]) => ({ source, building, label: source, status: ['grade_appeals', 'standing_rules', 'treasury_spending'].includes(source) ? 'coming' : 'live', count: matters.filter((m) => m.source === source).length, reason: ['grade_appeals', 'standing_rules', 'treasury_spending'].includes(source) ? 'There is no way to appeal a grade yet.' : null })),
+    readings: READINGS.map(([key, building]) => ({ key, label: key, building, status: 'off', value: null, figure: null, line: null, hot: false, reason: 'The module that holds this is not enabled here.' })),
+    ...over,
+  };
+}
+const goal = (id, status = 'open', title = `Goal ${id}`) => ({ id: String(id), title, status });
+
+// ── the drawing is the prototype's ───────────────────────────────────────────
+
+const SECTION_KEYS = ['kicker', 'name', 'holds', 'whoText', 'howText', 'seats', 'fill', 'fillColor', 'growth', 'openKicker', 'sym', 'flipA', 'flipB', 'openTitle', 'openLines', 'drawerItems', 'onFile', 'shapes', 'texts', 'syms', 'lift', 'hasAnnex', 'annex'];
+
+test('every building in section is the prototype\'s, to the path, in both modes, before and after a pick', () => {
+  let compared = 0;
+  for (const mode of ['dark', 'light']) {
+    for (const st of [{}, { reviewHeld: true, floor: 1, drawer: 1, picks: 3 }, { floor: 99, drawer: 7, picks: 2 }]) {
+      for (const key of S.CIVIC_KEYS) {
+        const p = proto(mode, { view: key, ...st });
+        const want = p.buildingView(p.theme(mode), key, p.matters());
+        const vacant = key === 'review' && !p.state.reviewHeld;
+        const got = I.buildingView(S.theme(mode), key, p.civicInfo(key), { floor: p.state.floor, drawer: p.state.drawer, picks: p.state.picks, vacant, reviewHeld: p.state.reviewHeld, evening: false });
+        for (const k of SECTION_KEYS) assert.deepEqual(j(got[k]), j(want[k]), `${mode} ${key} ${JSON.stringify(st)} ${k}`);
+        assert.deepEqual(got.floors.map((f) => [f.key, f.x, f.y, f.w, f.h, f.aria]), want.floors.map((f) => [f.key, f.x, f.y, f.w, f.h, f.aria]), `${mode} ${key} floor hits`);
+        assert.deepEqual(got.drawers.map((d) => [d.label, d.count, d.aria, d.bg, d.border, d.handle]), want.drawers.map((d) => [d.label, d.count, d.aria, d.bg, d.border, d.handle]), `${mode} ${key} drawers`);
+        compared += 1;
+      }
+    }
+  }
+  assert.equal(compared, 54);
+});
+
+test('the rule glyph is the shared library\'s, which is the prototype\'s for every rule the prototype draws', () => {
+  const p = proto('dark');
+  for (const rule of ['decide', 'majority', 'unanimous', 'consent', 'rule']) assert.deepEqual(City.glyph(rule, 9, 9, 16), p.glyph(rule, 9, 9, 16), rule);
+  const bv = I.buildingView(S.theme('dark'), 'review', p.civicInfo('review'), { vacant: true });
+  const g = City.glyph('signoff', 9, 9, 16);
+  assert.deepEqual([bv.gf, bv.gl], [g.fill, g.line], 'Review\'s sign-off glyph is drawn (the guide\'s, which the prototype\'s street left blank)');
+});
+
+test('every district is the prototype\'s road of work, both modes', () => {
+  for (const mode of ['dark', 'light']) {
+    for (const key of ['onboarding', 'payments', 'hall', 'modules']) {
+      for (const st of [{}, { reviewHeld: true, released: true }]) {
+        const p = proto(mode, { view: key, ...st });
+        const want = p.districtView(p.theme(mode), key);
+        const got = I.districtView(S.theme(mode), key, p.districtInfo(key));
+        for (const k of ['kicker', 'name', 'line', 'road', 'ground', 'tx', 'ty', 's', 'shapes', 'legend']) assert.deepEqual(j(got[k]), j(want[k]), `${mode} ${key} ${k}`);
+        assert.deepEqual(got.items.map((i) => [i.x, i.y, i.w, i.name, i.meta, i.stage, i.stageColor, i.stageEdge]), want.items.map((i) => [i.x, i.y, i.w, i.name, i.meta, i.stage, i.stageColor, i.stageEdge]), `${mode} ${key} items`);
+      }
+    }
+  }
+});
+
+test('workItem and crown are verbatim: every craft at every stage, every crown', () => {
+  for (const mode of ['dark', 'light']) {
+    const p = proto(mode);
+    const T = p.theme(mode);
+    for (const craft of ['engineer', 'artist', 'ui', 'ideator']) {
+      for (const stage of ['backlog', 'ready', 'being built', 'shipped', 'being graded', 'awaiting a tester']) {
+        const a = []; const b = [];
+        p.workItem(a, T, craft, stage, 86, 40, 92);
+        I.workItem(b, S.theme(mode), craft, stage, 86, 40, 92);
+        assert.deepEqual(b, a, `${mode} ${craft} ${stage}`);
+      }
+    }
+    for (const key of S.CIVIC_KEYS) {
+      const a = []; const b = [];
+      p.crown(a, T, key, 130, 460, 208);
+      I.crown(b, S.theme(mode), key, 130, 460, 208);
+      assert.deepEqual(b, a, `${mode} crown ${key}`);
+    }
+  }
+});
+
+test('the floor symbols are the prototype\'s forty, and every floor the plan names has one', () => {
+  const p = proto('dark');
+  assert.equal(I.SYMBOL_NAMES.length, 40);
+  for (const name of I.SYMBOL_NAMES) assert.deepEqual(I.symbolPath(name), p.symbolPath(name), name);
+  assert.deepEqual(I.symbolPath('no such'), p.symbolPath('crate'), 'the fallback is the crate');
+  // every floor name the prototype maps keeps its symbol
+  for (const key of S.CIVIC_KEYS) {
+    for (const st of [{}, { reviewHeld: true }]) {
+      for (const f of proto('dark', st).civicInfo(key).floors) assert.equal(I.floorSymbol(f.name), p.floorSymbol(f.name), f.name);
+    }
+  }
+  for (const [key, plan] of Object.entries(I.PLAN)) {
+    for (const [name] of plan.floors) {
+      const sym = I.floorSymbol(name);
+      // the prototype itself signs Ready to go with the crate
+      if (name !== 'Ready to go') assert.notEqual(sym, 'crate', `${key}: ${name} has a symbol of its own`);
+      assert.ok(I.SYMBOL_NAMES.includes(sym), `${name} → ${sym} is one of the library's`);
+    }
+  }
+});
+
+test('each building keeps the prototype\'s capacity, words and floor order', () => {
+  for (const key of S.CIVIC_KEYS) {
+    const want = proto('dark', { reviewHeld: true }).civicInfo(key);
+    const plan = I.PLAN[key];
+    assert.equal(plan.cap, want.cap, `${key} cap`);
+    assert.equal(plan.holds, want.holds, `${key} holds`);
+    assert.ok(plan.floors.length <= plan.cap, `${key} fits`);
+    const b = I.civicInfo(key, { docket: docket(), goals: [], now: NOW });
+    assert.equal(b.group, want.group, `${key} group`);
+    assert.equal(b.name, want.name, `${key} name`);
+  }
+  // where the prototype's floor is about the government, the plan keeps it, in its order
+  const names = (k) => I.PLAN[k].floors.map((f) => f[0]);
+  assert.deepEqual(names('charter'), proto('dark').civicInfo('charter').floors.map((f) => f.name));
+  assert.deepEqual(names('automation'), proto('dark').civicInfo('automation').floors.map((f) => f.name));
+  assert.deepEqual(names('people'), proto('dark').civicInfo('people').floors.map((f) => f.name));
+});
+
+// ── what a floor says comes from the docket, and only from it ───────────────
+
+test('a floor no feed reads stands as not recorded yet: faint, no number, and says so', () => {
+  const b = I.civicInfo('charter', { docket: docket(), goals: [], now: NOW });
+  assert.ok(b.floors.every((f) => f.status === 'coming' && f.count === ''), 'nothing on the charter is read yet');
+  const bv = I.buildingModel({ key: 'charter', docket: docket(), mode: 'dark', now: NOW });
+  const quiet = bv.texts.filter((t) => t.v === 'not recorded yet');
+  assert.equal(quiet.length, 8, 'every used floor says it on the wall');
+  assert.ok(bv.texts.filter((t) => t.s === 14.5).every((t) => t.c === '#8e8e93'), 'its name lettered faint, like a proposed floor');
+  assert.equal(bv.openKicker, 'floor 8 · not recorded yet');
+});
+
+test('a floor bound to a source shows its open matters: the count, the line, needs you, the lines', () => {
+  const ms = [matter({ id: 'access_requests:1', source: 'access_requests', building: 'people', state: 'needs', title: 'Admit Kai', deadline: '2026-10-03T09:00:00.000Z' }), matter({ id: 'access_requests:2', source: 'access_requests', building: 'people', state: 'moving', title: 'Admit Lu' })];
+  const b = I.civicInfo('people', { docket: docket(ms), goals: [], now: NOW });
+  const f = b.floors.find((x) => x.name === 'Waiting to join');
+  assert.deepEqual([f.count, f.line, f.status], ['2', '1 needs you', 'pending']);
+  assert.deepEqual(f.lines, [['Admit Kai', 'needs you · sat'], ['Admit Lu', 'moving']]);
+  const bv = I.buildingModel({ key: 'people', docket: docket(ms), mode: 'dark', now: NOW });
+  assert.equal(bv.selFloor, 4, 'the floor being decided is the one chosen first, as the prototype');
+  assert.equal(bv.openKicker, 'floor 5 · being decided');
+  const goal2 = b.floors.find((x) => x.name === 'Goal teams');
+  assert.deepEqual([goal2.count, goal2.line, goal2.status], ['0', 'nothing open', 'ok'], 'a live source with nothing open says nothing open, and 0');
+});
+
+test('a source that is off, coming, not yours or unreadable never shows a number', () => {
+  const d = docket();
+  d.sources.find((s) => s.source === 'goal_join_requests').status = 'off';
+  d.sources.find((s) => s.source === 'access_requests').status = 'not_yours';
+  d.sources = d.sources.filter((s) => s.source !== 'redteam_reports');
+  const people = I.civicInfo('people', { docket: d, now: NOW }).floors;
+  const by = Object.fromEntries(people.map((f) => [f.name, f]));
+  assert.deepEqual([by['Goal teams'].status, by['Goal teams'].count], ['off', '']);
+  assert.deepEqual([by['Waiting to join'].status, by['Waiting to join'].count], ['not_yours', '']);
+  const disputes = Object.fromEntries(I.civicInfo('disputes', { docket: d, now: NOW }).floors.map((f) => [f.name, f]));
+  assert.deepEqual([disputes['Grade appeals'].status, disputes['Grade appeals'].lines[0]], ['coming', ['There is no way to appeal a grade yet.', 'coming']], 'coming says why, in the docket\'s words');
+  assert.deepEqual([disputes['Security reports'].status, disputes['Security reports'].count], ['unavailable', ''], 'a source missing from the docket is not read');
+  const none = I.civicInfo('release', { docket: null, now: NOW });
+  assert.ok(none.floors.every((f) => f.count === '' && f.status !== 'ok' && f.status !== 'pending'), 'no docket: no numbers anywhere');
+  assert.equal(none.onFile, 'the docket could not be read just now');
+  assert.deepEqual(none.table, []);
+});
+
+test('a floor bound to a reading shows its figure and line when live; Planning counts the open goals', () => {
+  const d = docket();
+  d.readings.find((r) => r.key === 'people').status = 'live';
+  Object.assign(d.readings.find((r) => r.key === 'people'), { figure: '12 builders', line: '7 shipped this month', hot: false });
+  Object.assign(d.readings.find((r) => r.key === 'money'), { status: 'live', figure: '$1,100 left', line: 'lasts about 3 weeks' });
+  const builders = I.civicInfo('people', { docket: d, now: NOW }).floors.find((f) => f.name === 'Builders');
+  assert.deepEqual([builders.count, builders.line, builders.lines[0]], ['12', '7 shipped this month', ['7 shipped this month', '12 builders']]);
+  assert.equal(I.civicInfo('treasury', { docket: d, now: NOW }).floors.find((f) => f.name === 'Reserve').count, '$1,100');
+  const goals = [goal(1), goal(2), goal(3), goal(4), goal(5), goal(6, 'achieved')];
+  const m = I.buildingModel({ key: 'planning', docket: d, goals, mode: 'dark', now: NOW });
+  const g = I.civicInfo('planning', { docket: d, goals: goals.filter((x) => x.status === 'open'), now: NOW }).floors[0];
+  assert.deepEqual([g.name, g.count, g.line], ['Goals', '5', '5 goals open']);
+  assert.equal(g.lines.length, 5, 'four goals and a line for the rest');
+  assert.ok(m.texts.some((t) => t.v === '5' && t.s === 20), 'only open goals are counted on the wall');
+});
+
+test('on the table: the building\'s matters, needs first; each row names the matter it opens', () => {
+  const ms = [matter({ id: 'board:1', source: 'board', building: 'charter', state: 'moving', title: 'B', deadline: '2026-10-04T09:00:00.000Z' }), matter({ id: 'board:2', source: 'board', building: 'charter', state: 'needs', title: 'A', deadline: '2026-10-02T20:00:00.000Z' }), matter({ id: 'blockers:3' })];
+  const m = I.buildingModel({ key: 'charter', docket: docket(ms), mode: 'light', now: NOW });
+  assert.deepEqual(m.table.map((r) => [r.matter, r.label, r.status, r.state]), [['board:2', 'A', 'needs you · today', 'needs'], ['board:1', 'B', 'moving · sun', 'moving']]);
+  assert.equal(m.table[0].color, S.theme('light').accentText);
+  assert.ok(m.hasTable);
+});
+
+test('the record files the building\'s matters by the month each was opened, newest drawer first', () => {
+  const ms = [matter({ id: 'a', opened_at: '2026-08-03T00:00:00.000Z', title: 'Aug' }), matter({ id: 'b', opened_at: '2026-10-01T00:00:00.000Z', title: 'Oct', state: 'settled' }), matter({ id: 'c', opened_at: '2025-12-30T00:00:00.000Z', title: 'Last year' }), matter({ id: 'd', opened_at: null, title: 'No date' })];
+  const r = I.recordOf(ms, NOW);
+  assert.deepEqual(r.map((x) => x.label), ['oct', 'aug', 'dec 25', 'undated']);
+  assert.deepEqual(r[0].items, [['Oct', 'settled']]);
+  const m = I.buildingModel({ key: 'planning', docket: docket(ms), mode: 'dark', now: NOW, drawer: 1 });
+  assert.deepEqual(m.drawers.map((d) => [d.label, d.count, d.selected]), [['oct', 1, false], ['aug', 1, true], ['dec 25', 1, false], ['undated', 1, false]]);
+  assert.deepEqual(m.drawerItems.map((x) => x.text), ['Aug']);
+  assert.equal(m.onFile, '4 matters on the docket');
+  const empty = I.buildingModel({ key: 'automation', docket: docket(), mode: 'dark', now: NOW });
+  assert.deepEqual([empty.drawers, empty.drawerItems, empty.onFile], [[], [], 'nothing on file yet']);
+});
+
+test('who holds it: the docket\'s holders when it names them, else an empty seat that says so', () => {
+  const none = I.buildingModel({ key: 'release', docket: docket(), mode: 'dark', now: NOW });
+  assert.deepEqual(none.seats.map((s) => s.key), ['—']);
+  assert.equal(none.whoText, 'who holds it is not set on this project yet');
+  assert.equal(none.howText, 'one person decides · by default', 'a default is named as one');
+  const fromMatter = I.holderOf('people', null, [matter({ rule: 'consent' })]);
+  assert.deepEqual([fromMatter.rule, fromMatter.how], ['consent', 'passes unless someone objects']);
+  const held = I.holderOf('treasury', { holders: [{ name: 'Mira' }], rule: 'majority', who: 'Mira, treasurer' }, []);
+  assert.deepEqual([held.seats, held.who, held.how], [['M'], 'Mira, treasurer', 'more than half must say yes']);
+});
+
+test('the annex lot stands only when the building is full; an unheld Review is the dashed ghost', () => {
+  assert.equal(I.buildingModel({ key: 'charter', docket: docket(), mode: 'dark', now: NOW }).hasAnnex, false, '8 of 9');
+  const save = I.PLAN.rules.cap;
+  try {
+    I.PLAN.rules.cap = 2;
+    const m = I.buildingModel({ key: 'rules', docket: docket(), mode: 'dark', now: NOW });
+    assert.deepEqual([m.hasAnnex, m.annex.text, m.annex.x, m.annex.w], [true, 'room for an annex, such as money rules', 628, 160]);
+  } finally { I.PLAN.rules.cap = save; }
+  const off = docket();
+  off.sources.find((s) => s.source === 'criteria_uat').status = 'off';
+  const ghost = I.buildingModel({ key: 'review', docket: off, mode: 'dark', now: NOW });
+  assert.equal(ghost.vacant, true);
+  assert.ok(ghost.shapes.some((s) => s.dash === '4 4'), 'drawn dashed');
+  assert.match(ghost.growth, /^Not built yet\. Nothing is built here until the charter says who holds the seat\.$/);
+  assert.equal(I.buildingModel({ key: 'review', docket: docket(), mode: 'dark', now: NOW }).vacant, false, 'a live source holds the seat, as on the street');
+});
+
+test('the lift runs to the chosen floor, and the chosen block flips on every pick', () => {
+  const a = I.buildingModel({ key: 'charter', docket: docket(), mode: 'dark', now: NOW, floor: 2, picks: 1 });
+  assert.equal(a.selFloor, 2);
+  assert.deepEqual(a.lift, { x: 92, y: 630, ty: -104, h: 36 });
+  assert.deepEqual([a.flipA, a.flipB], [false, true]);
+  const b = I.buildingModel({ key: 'charter', docket: docket(), mode: 'dark', now: NOW, floor: 50, picks: 2 });
+  assert.equal(b.selFloor, 7, 'a pick past the top is the top floor');
+  assert.deepEqual([b.flipA, b.flipB], [true, false]);
+  assert.ok(b.floors[7].selected && !b.floors[2].selected);
+  assert.ok(a.shapes.some((s) => s.s === '#fb9569' && s.w === 1.5), 'the orange frame');
+  assert.equal(a.syms[2].c, '#fb9569', 'and the orange sign on the chosen floor only');
+  assert.ok(a.syms.filter((s, i) => i !== 2).every((s) => s.c !== '#fb9569'));
+});
+
+// ── districts ──────────────────────────────────────────────────────────────
+
+test('a district is its own goal\'s tasks: shape from the craft, stage from the status, label the kind', () => {
+  const t = (id, status, discipline, kind = 'feature', goal_id = '7', extra = {}) => ({ id: String(id), title: `task ${id}`, status, discipline, kind, goal_id, est_minutes: 120, ...extra });
+  const tasks = [t(1, 'shipped', 'engineer'), t(2, 'ready', 'artist'), t(3, 'active', 'ui'), t(4, 'confirmed', 'ideator', 'spike'), t(5, 'backlog', null, 'bug'), t(6, 'blocked', 'engineer'), t(7, 'completed', 'artist'), t(8, 'cut', 'engineer'), t(9, 'shipped', 'ui', 'feature', '8')];
+  const d = I.districtInfo('7', goal(7), tasks);
+  assert.deepEqual(d.items.map((i) => [i[0], i[1], i[2], i[3], i[5]]), [
+    ['task 1', 'feature', 'engineer', 'shipped', 'shipped'],
+    ['task 4', 'spike', 'ideator', 'graded · landing', 'graded · landing'],
+    ['task 7', 'feature', 'artist', 'being graded', 'being graded'],
+    ['task 3', 'feature', 'ui', 'being built', 'being built'],
+    ['task 2', 'feature', 'artist', 'ready', 'ready'],
+    ['task 6', 'feature', 'engineer', 'backlog', 'blocked'],
+    ['task 5', 'bug', 'engineer', 'backlog', 'backlog'],
+  ], 'in the order work moves; a cut task and another goal\'s are not drawn; no craft is a tower');
+  assert.equal(d.items[0][4], 56, 'height from the estimate, never a random');
+  assert.equal(d.items[4][4], 0, 'a slab or a stake has no height');
+  assert.equal(d.items[0][6], '/builders/task/1', 'each one opens its task');
+  assert.equal(d.line, 'the goal’s work · 1 shipped · 1 being built · 2 waiting on a check · 3 not started');
+  const m = I.districtModel({ goalId: '7', goals: [goal(7)], tasks, mode: 'dark' });
+  assert.deepEqual(m.items.map((i) => i.stage), ['shipped', 'graded · landing', 'being graded', 'being built', 'ready', 'blocked', 'backlog']);
+  assert.ok(m.shapes.some((s) => s.f === S.theme('dark').line && /h11l-3 4l3 4h-11Z$/.test(s.d)), 'a flag on the work that waits on a check');
+});
+
+test('past ten pieces of work the road keeps the ones in flight and counts the rest', () => {
+  const tasks = Array.from({ length: 30 }, (_, i) => ({ id: String(i + 1), title: `t${i + 1}`, status: i < 3 ? 'active' : i < 25 ? 'shipped' : 'backlog', discipline: 'engineer', kind: 'feature', goal_id: '9', shipped_at: `2026-09-${String(1 + (i % 28)).padStart(2, '0')}T00:00:00Z` }));
+  const d = I.districtInfo('9', goal(9), tasks);
+  assert.equal(d.items.length, I.MAX_ITEMS);
+  assert.equal(d.more, 20);
+  assert.equal(d.items.filter((i) => i[3] === 'being built').length, 3, 'all the work in flight stands');
+  const m = I.districtModel({ goalId: '9', goals: [goal(9)], tasks, mode: 'light' });
+  assert.equal(m.goalHref, '/builders/goals#/goal/9');
+  assert.ok(m.items[0].x >= 32 && m.items[m.items.length - 1].x + 124 <= 1408, 'ten fit the road');
+});
+
+test('a district says when its work is still being read, or could not be', () => {
+  assert.equal(I.districtInfo('3', goal(3), null).line, 'reading the goal’s work');
+  assert.equal(I.districtInfo('3', goal(3), false).line, 'the goal’s work could not be read just now');
+  assert.equal(I.districtInfo('3', goal(3), []).line, 'no work in this goal yet');
+  assert.equal(I.districtModel({ goalId: '404', goals: [], tasks: [] }).name, 'Goal 404');
+});
+
+test('the models are deterministic and pure', () => {
+  const input = { key: 'people', docket: docket([matter({ building: 'people', source: 'access_requests' })]), goals: [goal(1)], mode: 'light', now: NOW, floor: 1, picks: 1 };
+  assert.deepEqual(j(I.buildingModel(input)), j(I.buildingModel(input)));
+  const src = read('street-inside.js').replace(/^\s*\/\/.*$/gm, '');
+  assert.doesNotMatch(src, /document\.|fetch\(|Date\.now|Math\.random|innerHTML/);
+});
+
+// ── the page ────────────────────────────────────────────────────────────────
+
+test('the stylesheet: the lift travels by CSS, dies under reduced motion, every [hidden] holds, tokens only', () => {
+  const css = read('street.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.match(css, /\.inside-lift \{[^}]*transition: transform 650ms/);
+  assert.match(css, /@media \(prefers-reduced-motion: reduce\) \{[^}]*animation: none !important; transition: none !important;/);
+  assert.match(css, /@keyframes street-zoom /);
+  assert.doesNotMatch(css, /#fb9569|#2a1305/i, 'the accent and its ink are tokens, never literals');
+  for (const sel of ['.inside[hidden]', '.inside-annex[hidden]', '.inside-open[hidden]', '.inside-note[hidden]', '.inside-lift[hidden]']) assert.ok(css.includes(sel), `${sel} is display: none`);
+  assert.match(css, /@media \(max-width: 899px\) \{[\s\S]*\.inside-board \{ position: static;/, 'narrow: the board is a column');
+});
+
+function fakeDom() {
+  const byId = new Map();
+  const focused = { el: null };
+  const mk = (tag) => {
+    const el = {
+      tagName: tag, attrs: {}, kids: [], className: '', listeners: {}, _text: '', hidden: false,
+      style: { setProperty(k, v) { this[k] = v; } },
+      clientWidth: 1440, clientHeight: 708, offsetLeft: 0, scrollLeft: 0, parentNode: null,
+      // like a real HTMLCollection, .children does NOT spread under concat
+      get children() { const a = this.kids.slice(); a[Symbol.isConcatSpreadable] = false; return a; },
+      get firstChild() { return this.kids[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.kids.push(c); c.parentNode = this; return c; },
+      removeChild(c) { this.kids = this.kids.filter((x) => x !== c); return c; },
+      addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+      fire(t, e = {}) { (this.listeners[t] || []).forEach((fn) => fn({ type: t, preventDefault() { e.prevented = true; }, ...e })); },
+      focus() { focused.el = this; },
+      set textContent(v) { this._text = String(v); this.kids = []; },
+      get textContent() { return this._text; },
+      get innerHTML() { throw new Error('street.js must not read innerHTML'); },
+      set innerHTML(v) { throw new Error('street.js must not write innerHTML'); },
+    };
+    return el;
+  };
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  const ids = [...html.matchAll(/id="([A-Za-z]+)"/g)].map((m) => m[1]);
+  for (const id of ids) {
+    const el = mk('x');
+    el.setAttribute('id', id);
+    const tag = new RegExp(`<[^>]*\\bid="${id}"[^>]*>`).exec(html);
+    if (tag && /\shidden(?=[\s>])/.test(tag[0])) el.hidden = true; // as the markup ships it
+  }
+  const document = { documentElement: mk('html'), getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_ns, t) => mk(t) };
+  return { document, byId, focused, ids };
+}
+
+async function bootPage({ hash = '', feeds = {}, innerWidth = 1440 } = {}) {
+  const { document, byId, focused, ids } = fakeDom();
+  const calls = [];
+  const listeners = {};
+  const history = [];
+  const location = { hash };
+  const window = {
+    innerWidth, innerHeight: 900, location,
+    localStorage: { getItem: () => null, setItem() {} },
+    matchMedia: () => ({ matches: true, addEventListener() {} }),
+    addEventListener(t, fn) { (listeners[t] = listeners[t] || []).push(fn); },
+    history: { pushState(_s, _t, url) { history.push(url); location.hash = ''; } },
+  };
+  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, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map });
+  ctx.globalThis = ctx;
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-inside.js', 'street.js']) vm.runInContext(read(f), ctx);
+  await window.GovStreetPage.ready;
+  await new Promise((r) => setTimeout(r, 0));
+  const fireWin = (t, e) => (listeners[t] || []).forEach((fn) => fn(e));
+  return { window, byId, focused, calls, history, fireWin, ids, location };
+}
+
+const FEEDS = (ms, extra = {}) => ({
+  '/api/bongos/government/docket': docket(ms),
+  '/api/bongos/goals': { goals: [goal(7), goal(8)] },
+  '/api/bongos/goals/rollups': { rollups: [] },
+  ...extra,
+});
+
+test('the markup carries the interior: one persistent lift, two flip blocks, the panel and the back link', () => {
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  for (const id of ['streetInside', 'insideBack', 'insideSvg', 'insideFloors', 'insideLift', 'insideAnnex', 'insidePanel', 'insideName', 'insideAmend', 'insideAmendNote', 'insideFill', 'insideTable', 'insideOpenA', 'insideOpenB', 'insideDrawers', 'insideDrawerItems', 'insideDName', 'insideLegend', 'insideItems']) assert.match(html, new RegExp(`id="${id}"`), id);
+  assert.equal((html.match(/<h1\b/g) || []).length, 1, 'the street keeps its one h1; the interior names are h2');
+  assert.match(html, /<section class="inside" id="streetInside"[^>]*hidden>/, 'hidden until an address names a building or a district');
+  assert.match(html, /<button type="button" class="inside-textbtn" id="insideAmend"/);
+});
+
+test('a building address draws the interior in place of the street, from the docket', async () => {
+  const ms = [matter({ id: 'access_requests:1', source: 'access_requests', building: 'people', state: 'needs', title: 'Admit Kai' })];
+  const p = await bootPage({ hash: '#building=people', feeds: FEEDS(ms) });
+  assert.equal(p.byId.get('streetInside').hidden, false);
+  assert.equal(p.byId.get('streetSizer').hidden, true, 'the street gives way');
+  assert.equal(p.byId.get('insideName').textContent, 'People');
+  assert.equal(p.byId.get('insideFloors').children.length, 7, 'a button per floor in use');
+  assert.equal(p.byId.get('insideFloors').children[4].attrs['aria-pressed'], 'true', 'the floor being decided is chosen');
+  assert.equal(p.byId.get('insideLift').style.transform, 'translateY(-208px)');
+  assert.equal(p.byId.get('insideTable').children.length, 1);
+  assert.equal(p.byId.get('insideTable').children[0].className, 'inside-row inside-row--needs');
+  assert.equal(p.byId.get('insideSeats').children[0].className, 'inside-seat inside-seat--open');
+  assert.equal(p.focused.el, null, 'a page opened at the address keeps the browser\'s own start');
+  p.location.hash = '#building=rules';
+  p.fireWin('hashchange', {});
+  assert.equal(p.byId.get('insideName').textContent, 'Rules');
+  assert.equal(p.focused.el, p.byId.get('insideName'), 'stepping in through a door puts focus on the building\'s name');
+  assert.equal(p.byId.get('streetSigns').children.find((a) => a.attrs['aria-current'] === 'location').attrs['data-reading'], 'rules', 'the reading for this building is marked');
+});
+
+test('picking a floor moves the SAME lift node and re-enters the chosen block; drawers and the amendment answer', async () => {
+  const ms = [matter({ id: 'access_requests:1', source: 'access_requests', building: 'people', state: 'needs', opened_at: '2026-09-30T00:00:00Z' }), matter({ id: 'access_requests:2', source: 'access_requests', building: 'people', state: 'moving', opened_at: '2026-08-30T00:00:00Z' })];
+  const p = await bootPage({ hash: '#building=people', feeds: FEEDS(ms) });
+  const lift = p.byId.get('insideLift');
+  assert.equal(p.byId.get('insideOpenA').hidden, false);
+  p.byId.get('insideFloors').children[0].fire('click');
+  assert.equal(p.byId.get('insideLift'), lift, 'one node, so the transform can transition');
+  assert.equal(lift.style.transform, 'translateY(0px)');
+  assert.deepEqual([p.byId.get('insideOpenA').hidden, p.byId.get('insideOpenB').hidden], [true, false], 'the block flips, so it re-enters');
+  assert.equal(p.focused.el.attrs['data-floor'], '0', 'focus stays on the floor picked');
+  p.byId.get('insideFloors').children[1].fire('click');
+  assert.deepEqual([p.byId.get('insideOpenA').hidden, p.byId.get('insideOpenB').hidden], [false, true]);
+  const words = p.byId.get('insideOpenA').children[0].children[1];
+  assert.equal(words.children[1].textContent, 'Testers');
+  assert.equal(p.byId.get('insideDrawers').children.length, 2);
+  p.byId.get('insideDrawers').children[1].fire('click');
+  assert.equal(p.byId.get('insideDrawers').children[1].attrs['aria-pressed'], 'true');
+  assert.equal(p.byId.get('insideAmendNote').hidden, true);
+  p.byId.get('insideAmend').fire('click');
+  assert.equal(p.byId.get('insideAmendNote').hidden, false, 'change how this works says it is not built yet, rather than nothing');
+  assert.match(p.byId.get('insideAmendNote').textContent, /not built yet/);
+});
+
+test('a table row opens the short card; Escape gives focus back to the row; back to the street returns to the door', async () => {
+  const ms = [matter({ id: 'board:1', source: 'board', building: 'charter', state: 'needs', title: '<b>x</b>' })];
+  const p = await bootPage({ hash: '#building=charter', feeds: FEEDS(ms) });
+  p.byId.get('insideTable').children[0].fire('click');
+  assert.equal(p.byId.get('streetCard').hidden, false);
+  assert.equal(p.byId.get('streetCardTitle').textContent, '<b>x</b>', 'docket text lands as text');
+  p.fireWin('keydown', { key: 'Escape', preventDefault() {} });
+  assert.equal(p.byId.get('streetCard').hidden, true);
+  assert.equal(p.focused.el.attrs['data-matter'], 'board:1', 'focus goes back to the row');
+  p.byId.get('insideBack').fire('click');
+  assert.deepEqual(p.history, ['/builders/street']);
+  assert.equal(p.byId.get('streetInside').hidden, true);
+  assert.equal(p.byId.get('streetSizer').hidden, false);
+  assert.equal(p.focused.el.attrs['data-door'], 'charter', 'focus returns to the door used');
+});
+
+test('a district address reads its goal\'s tasks once and draws them as buildings', async () => {
+  const tasks = [{ id: '1', title: 'checkout', status: 'shipped', discipline: 'engineer', kind: 'feature', goal_id: '7' }, { id: '2', title: 'tax forms', status: 'active', discipline: 'ui', kind: 'feature', goal_id: '7' }, { id: '3', title: 'other goal', status: 'ready', goal_id: '8' }];
+  const p = await bootPage({ hash: '#district=7', feeds: FEEDS([], { '/api/bongos/tasks?goal_id=7': { tasks } }) });
+  await new Promise((r) => setTimeout(r, 0));
+  assert.equal(p.calls.filter((c) => c === '/api/bongos/tasks?goal_id=7').length, 1);
+  assert.equal(p.byId.get('streetInside').attrs['data-kind'], 'district');
+  assert.equal(p.byId.get('insidePanel').hidden, true);
+  assert.equal(p.byId.get('insideDName').textContent, 'Goal 7');
+  const items = p.byId.get('insideItems').children;
+  assert.deepEqual(items.map((a) => [a.tagName, a.attrs.href, a.children[2].textContent]), [['a', '/builders/task/1', 'shipped'], ['a', '/builders/task/2', 'being built']]);
+  assert.equal(p.byId.get('insideLift').hidden, true, 'a district has no lift');
+  assert.equal(p.byId.get('insideLegend').children.length, 2);
+});
+
+test('narrow: the board is a column and the drawing scales in its own strip, never under 0.6', async () => {
+  const p = await bootPage({ hash: '#building=charter', feeds: FEEDS([]), innerWidth: 390 });
+  p.byId.get('streetWindow').clientWidth = 390;
+  p.window.GovStreetPage.fit();
+  assert.equal(p.byId.get('insideBoard').style['--inside-scale'], '1');
+  assert.equal(p.byId.get('insideArtBox').style['--inside-art-scale'], '0.6');
+  assert.equal(p.byId.get('insideArtSpan').style.width, '480px');
+});