@bongos/core 1.21.112 → 1.21.114

package/tests/hall_city_living.mjs

@@ -0,0 +1,617 @@
+// tests/hall_city_living.mjs — THE LIVING CITY (task 1004685, the living-city
+// prototype): the home city drawn from GovLiving.livingModel() over the real
+// hall-preview fixtures and nothing else (task 1004717 deleted the prototype
+// overlay). Five Leads are seated here as People votes would seat them, with a
+// committee room and two build-outs, in the shape GET /government/leads answers,
+// and the docket is routed to them by the server's own rule.
+//
+// WHAT IT GUARDS. The mapping from the model to the drawing, signal by signal:
+//   * sky: one pod per active claim, on a lane from the building its work
+//     answers to to its goal's district, at fixed spacing and one period;
+//   * civic: a capsule floor per Lead, committee room and built floor (structure is
+//     height); salmon windows only where an ask waits on the viewer's seat;
+//     the authorised build-out a live site, the proposal a ghost with a tally
+//     and a light shaft; quiet buildings darker;
+//   * ground: districts hazed by depth band; the spend conduit as wide as the
+//     real spend rate, a dry pot starved with a borrow beacon;
+//   * the plaque, the card (two doors: every answer is the deck's), the door
+//     and the line;
+//   * nothing in the drawing carries a prototype mark;
+//   * motion is CSS, 20s and longer, inside the moving-node budget, with a
+//     still frame set on every moving part; city-draw.js stays pure;
+//   * the page boots the living city from the feeds and acts in place.
+//
+// Run:  node --test --test-reporter=tap tests/hall_city_living.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';
+// five Leads seated, a room and two build-outs, the docket routed to them (test data)
+import { leadsRead, docketRouted } from './fixtures/gov-seated.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const FX = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const City = require(path.join(PUB, 'city-draw.js'));
+const G = require(path.join(PUB, 'gov-living.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const fx = (name) => JSON.parse(fs.readFileSync(path.join(FX, name + '.json'), 'utf8'));
+const clone = (v) => JSON.parse(JSON.stringify(v));
+
+const NOW = Date.parse('2026-10-09T14:00:00.000Z');
+function livingInputs(over = {}) {
+  return {
+    docket: docketRouted(), constitution: fx('government__constitution'), goals: fx('goals'), rollups: fx('goals__rollups'),
+    blockers: fx('blockers'), fence: fx('autonomy__fence'), claims: fx('tasks__claimable'), tasks: fx('tasks__status-active'),
+    moving: fx('moving'), cost: fx('public__cost-summary'), roster: fx('builders__roster'), me: fx('me'),
+    leads: leadsRead(), treasury: fx('government__treasury'), now: NOW, ...over,
+  };
+}
+function city(over = {}, extra = {}) {
+  const inp = livingInputs(over);
+  const living = G.livingModel(inp);
+  const docket = inp.docket;
+  return City.cityModel({
+    docket, goals: inp.goals.goals || inp.goals, rollups: inp.rollups.rollups || inp.rollups, mode: 'dark', now: NOW,
+    living, constitution: inp.constitution, ...extra,
+  });
+}
+const civicOf = (m, key) => m.civic.find((c) => c.key === key);
+const bldOf = (m, key) => m.blds.find((b) => b.key === key);
+const allPolys = (m) => {
+  const out = [];
+  m.flat.forEach((p) => out.push({ where: 'flat', p }));
+  m.blds.forEach((b) => {
+    b.polys.forEach((p) => out.push({ where: b.key, p }));
+    (b.parts || []).forEach((part) => part.polys.forEach((p) => out.push({ where: b.key, p, part })));
+  });
+  (m.sky || []).forEach((p) => out.push({ where: 'sky', p }));
+  return out;
+};
+const STRANGER = { builder: { id: '424242', github_login: 'builder-9999', display_name: 'Builder 9999', rank: 'xenos' } };
+
+// ── the sky: one pod per agent ─────────────────────────────────────────────
+
+test('one pod per active claim, on a lane from its building to its goal\'s district', () => {
+  const m = city();
+  const living = G.livingModel(livingInputs());
+  const claims = fx('tasks__claimable').active_claims;
+  assert.equal(m.counts.agents_at_work, claims.length);
+  assert.equal(m.lanes.reduce((n, L) => n + L.pods.length, 0), claims.length, 'every agent is a pod, no more, no less');
+  const k = City.isoKit(60, 30, 720, 176, 30 / 28, City.isoTheme('dark'), false);
+  const slot = Object.fromEntries(City.CIVIC_SLOTS.map((s) => [s[0], s]));
+  for (const c of living.city.traffic.claims) {
+    const L = m.lanes.find((x) => x.claims.some((y) => y.claim_id === c.claim_id));
+    assert.ok(L, `${c.task_id} rides a lane`);
+    assert.equal(L.building, c.building, 'the lane leaves the building its work answers to');
+    const s = slot[c.building];
+    const start = k.P(s[1] + 1, s[2] + 1, civicOf(m, c.building).top && 0);
+    assert.ok(L.d.startsWith('M' + Math.round(start[0] * 10) / 10 + ' ') || L.orbit, 'from that building');
+    const D = m.districts.find((d) => d.goal_id === c.goal_id);
+    if (D) {
+      const end = k.P((D.lot.x0 + D.lot.x1 + 1) / 2, (D.lot.y0 + D.lot.y1 + 1) / 2, 96).map((n) => Math.round(n * 10) / 10);
+      assert.ok(L.d.endsWith(end[0] + ' ' + end[1]), `${c.task_id}: to its goal's district`);
+      assert.equal(L.orbit, false);
+    } else {
+      assert.equal(L.orbit, true, `${c.task_id} has no district, so it circles its own building`);
+    }
+  }
+  assert.ok(m.sky.filter((p) => p.cls === 'city-lane').every((p) => !('proto' in p)), 'a lane carries no prototype mark');
+});
+
+test('pods keep a fixed spacing and one period on every lane: speed carries no data', () => {
+  const claims = clone(fx('tasks__claimable'));
+  const base = claims.active_claims[0];
+  claims.active_claims = [0, 1, 2].map((i) => ({ ...base, claim_id: 'c' + i, task_id: base.task_id }));
+  const m = city({ claims });
+  const L = m.lanes[0];
+  assert.equal(m.lanes.length, 1, 'three agents on one route share one lane');
+  assert.equal(L.pods.length, 3);
+  for (let i = 1; i < 3; i++) {
+    assert.equal(Math.round((L.pods[i].at - L.pods[i - 1].at) * 10) / 10, Math.round(City.POD_GAP * 1000) / 10, 'the still frame spaces them evenly');
+    assert.equal(Math.round((L.pods[i - 1].delay - L.pods[i].delay) * 10) / 10, Math.round(City.LANE_PERIOD * City.POD_GAP * 10) / 10, 'and so does the motion');
+  }
+  assert.ok(m.lanes.every((x) => x.pods.every((p) => p.dur === City.LANE_PERIOD)), 'one period everywhere');
+  assert.ok(City.LANE_PERIOD >= 20, 'an ambient loop is 20s or longer');
+});
+
+test('past the moving-node budget the sky keeps its pods and says how many more ride', () => {
+  const claims = clone(fx('tasks__claimable'));
+  const base = claims.active_claims[0];
+  claims.active_claims = Array.from({ length: 90 }, (_, i) => ({ ...base, claim_id: 'c' + i }));
+  const m = city({ claims });
+  const pods = m.lanes.reduce((n, L) => n + L.pods.length, 0);
+  assert.ok(pods <= City.MAX_PODS);
+  assert.equal(pods + m.lanes.reduce((n, L) => n + L.extra, 0), 90, 'every agent is a pod or in a lane\'s "+N"');
+  assert.equal(m.counts.agents_at_work, 90, 'the line still counts all of them');
+  const moving = Object.values(m.motion).reduce((n, x) => n + x, 0);
+  assert.ok(moving < 100, `${moving} moving nodes`);
+});
+
+// ── civic: structure is height ─────────────────────────────────────────────
+
+test('a capsule floor per Lead, committee room and built floor: the building rises with its structure', () => {
+  const m = city();
+  const living = G.livingModel(livingInputs());
+  for (const b of living.buildings) {
+    const c = civicOf(m, b.key);
+    const n = (b.lead ? 1 : 0) + b.structure.committees.length + b.structure.built.length;
+    assert.equal(c.floors.length, n, `${b.key}: ${n} floors`);
+    if (b.lead) assert.equal(c.floors[0].kind, 'lead', `${b.key}: the Lead's floor is the first`);
+    const plugs = bldOf(m, b.key).parts.filter((p) => p.cls === 'city-plug' && p.floor);
+    assert.equal(plugs.length, n, `${b.key}: one capsule shell per floor`);
+    assert.ok(plugs.every((p) => !('proto' in p)), 'no prototype mark');
+  }
+  assert.deepEqual(civicOf(m, 'review').floors.map((f) => [f.kind, f.name]), [['lead', 'Builder 2014'], ['committee', 'Testers']]);
+  // a committee room put up at Planning: one more floor, FLOOR_H taller
+  const before = civicOf(m, 'planning');
+  const leads = leadsRead();
+  leads.buildings.find((b) => b.building === 'planning').structure = { standing: [{ id: 9, capsule: 'committee', name: 'Roadmap', line: 'x', state: 'built', progress: 1 }], proposed: [] };
+  const after = civicOf(city({ leads }), 'planning');
+  assert.equal(after.floors.length, before.floors.length + 1);
+  const k = City.isoKit(60, 30, 720, 176, 30 / 28, City.isoTheme('dark'), false);
+  assert.ok(Math.abs(before.top[1] - after.top[1] - City.FLOOR_H * k.S) <= 0.15, 'taller by exactly one floor (to the tenth of a pixel the drawing rounds to)');
+  // the Leads not read: no Leads, no capsules, every building at its recipe's roof
+  const bare = city({ leads: null });
+  for (const c of bare.civic) assert.equal(c.floors.length, 0, `${c.key}: no structure is invented`);
+});
+
+test('salmon only for what waits on the viewer: on the floor whose seat it waits on', () => {
+  const m = city();
+  const salmon = allPolys(m).filter((x) => /city-win--you/.test(x.p.cls || ''));
+  assert.ok(salmon.length > 0, 'the viewer has asks waiting');
+  for (const s of salmon) assert.ok(civicOf(m, s.where).on_you > 0, `${s.where}: salmon only where something waits on you`);
+  // the viewer leads Planning: what waits on that seat lights the Lead's own floor
+  const planning = civicOf(m, 'planning');
+  const leadFloor = planning.floors.find((f) => f.kind === 'lead');
+  assert.ok(leadFloor.on_you > 0, 'the Lead\'s floor holds what waits on its Lead');
+  const leadPane = bldOf(m, 'planning').parts.find((p) => p.floor === 'lead' && /city-plug--detail/.test(p.cls));
+  assert.match(leadPane.polys[0].cls, /city-win--you/);
+  // Review's 21 criteria wait on Review's own Lead: ink, never salmon
+  const review = civicOf(m, 'review');
+  assert.equal(review.on_you, 0);
+  assert.equal(review.on_others, 21);
+  assert.equal(allPolys(m).filter((x) => x.where === 'review' && /city-win--you/.test(x.p.cls || '')).length, 0);
+  assert.equal(civicOf(m, 'treasury').on_you, 0, 'the dry pot\'s borrow waits on the Treasury\'s Lead');
+  // a stranger: nothing waits on them, so nothing is salmon and the door is plain
+  const s = city({ me: STRANGER });
+  assert.equal(allPolys(s).filter((x) => /city-win--you/.test(x.p.cls || '')).length, 0);
+  assert.ok(s.pins.every((p) => p.state === 'moving' || p.state === 'settled'), 'no salmon pin');
+  assert.deepEqual(s.cta, City.ctaFor(0));
+  assert.equal(s.cta.label, 'start governing');
+});
+
+test('pins read the living asks: salmon with an age ring only when an ask waits on you', () => {
+  const m = city();
+  const planning = m.pins.find((p) => p.building === 'planning');
+  assert.equal(planning.state, 'needs');
+  assert.equal(planning.count, civicOf(m, 'planning').on_you);
+  assert.ok(planning.oldest_days >= 14 && planning.age === 1, 'over two weeks old: the ring is full');
+  const review = m.pins.find((p) => p.building === 'review');
+  assert.equal(review.state, 'moving', 'twenty-one criteria wait on Review\'s Lead, not on this viewer: ink');
+  assert.equal(review.age, null);
+  assert.equal(review.count, 21);
+  for (const p of m.pins) assert.equal(p.state === 'needs' || p.state === 'urgent', civicOf(m, p.building).on_you > 0, p.building);
+  assert.ok(m.pins.every((p) => !('proto' in p)), 'every pin is a real matter, routed by the server');
+});
+
+test('the authorised build-out is a live site; the proposal on a vote is a ghost, a tally and a shaft', () => {
+  const m = city();
+  const rel = civicOf(m, 'release');
+  assert.equal(rel.site.kind, 'live');
+  assert.equal(rel.site.progress, 0.55);
+  assert.equal(rel.site.built, 1, '55% of three floors: one built');
+  const parts = bldOf(m, 'release').parts;
+  const rise = parts.find((p) => p.cls === 'city-rise');
+  assert.equal(Number(rise.style['--rise']), 0.65, 'the next floor stands at its share in the still frame');
+  const climb = parts.find((p) => p.cls === 'city-climb');
+  assert.equal(parseFloat(climb.style['--climb-at']), Math.round(0.55 * parseFloat(climb.style['--climb']) * 10) / 10, 'the climber stands at the share built');
+  const jib = parts.find((p) => p.cls === 'city-jib');
+  assert.match(jib.style['--pivot'], /^\d+(\.\d)?px \d+(\.\d)?px$/, 'the jib swings about its mast head');
+  assert.ok(parts.every((p) => !('proto' in p)), 'the build-out is GET /government/leads\' own');
+  assert.equal(rel.shaft, null, 'a build-out the form of government allows needs no sitting');
+  const tre = civicOf(m, 'treasury');
+  assert.equal(tre.site.kind, 'pending');
+  const tparts = bldOf(m, 'treasury').parts;
+  assert.ok(tparts.some((p) => p.cls === 'city-ghost'), 'a dashed-glass ghost annex');
+  assert.ok(tparts.find((p) => p.cls === 'city-ghost').polys.filter((p) => p.f !== 'none').every((p) => p.dash === '4 3'), 'every face dashed');
+  assert.ok(!tparts.some((p) => /city-jib|city-rise|city-climb/.test(p.cls || '')), 'the crane is parked: nothing moves');
+  const holders = fx('government__docket').buildings.find((b) => b.key === 'charter').holders.length;
+  assert.deepEqual([tre.tally.seats, tre.tally.yes, tre.tally.no], [holders, 0, 0], 'one dot per board seat, none cast');
+  assert.ok(tre.shaft, 'the vote\'s sitting is a light shaft');
+  assert.deepEqual(m.shafts.map((s) => s.building), ['treasury']);
+});
+
+test('an open sitting in the real docket raises a shaft with its real tally; a settled one raises none', () => {
+  const docket = clone(fx('government__docket'));
+  docket.matters.push({ id: 'board:99', source: 'board', building: 'rules', rule: 'unanimous', state: 'needs', title: 'Adopt a rule', short: 'a rule', opened_at: '2026-10-08T10:00:00.000Z', tally: { for: 2, against: 1, open: 2, needs: 'x' }, ref: { type: 'board_item', id: '99' }, acts: [] });
+  const m = city({ docket });
+  const rules = civicOf(m, 'rules');
+  assert.equal(rules.site.kind, 'pending');
+  assert.deepEqual([rules.tally.seats, rules.tally.yes, rules.tally.no], [5, 2, 1]);
+  assert.ok(rules.shaft);
+  assert.equal(civicOf(m, 'planning').shaft, null, 'board:16 is settled: no shaft');
+});
+
+test('quiet buildings sit darker; busy ones keep the prototype\'s recipe exactly', () => {
+  const m = city();
+  const k = City.isoKit(60, 30, 720, 176, 30 / 28, City.isoTheme('dark'), false);
+  for (const s of City.CIVIC_SLOTS) {
+    const ref = [];
+    City.isoInstitution(ref, k, s[0], s[1], s[2], { fixes: City.rulesAtWork(fx('government__docket')) });
+    const b = bldOf(m, s[0]);
+    const recipe = b.polys.slice(0, ref.length).map((p) => p.f);
+    if (b.quiet) assert.notDeepEqual(recipe, ref.map((p) => p.f), `${s[0]} is quiet: its faces are mixed toward the void`);
+    else assert.deepEqual(recipe, ref.map((p) => p.f), `${s[0]} is busy: the recipe is untouched`);
+  }
+  assert.deepEqual(m.civic.filter((c) => c.quiet).map((c) => c.key).sort(), ['people', 'rules'], 'no agent and no ask: Rules and People');
+  assert.equal(City.mixToward('#808080', '#000000', 0.5), '#404040');
+  assert.equal(City.mixToward('rgba(255,255,255,0.4)', '#000000', 0.5), 'rgba(255,255,255,0.2)', 'a line thins out');
+});
+
+// ── ground: haze and the spend conduit ─────────────────────────────────────
+
+test('districts haze by depth band; a district with an agent at work keeps less; the civic quarter never', () => {
+  const m = city();
+  const living = G.livingModel(livingInputs());
+  const agents = Object.fromEntries(living.districts.map((d) => [d.goal_id, d.agents]));
+  for (const D of m.districts) {
+    const band = City.HAZE[City.hazeBand(D.lot)];
+    assert.equal(D.haze, Math.round(band * (agents[D.goal_id] > 0 ? City.ACTIVE_HAZE : 1) * 100) / 100, D.goal_id);
+  }
+  assert.ok(City.HAZE[0] > City.HAZE[1] && City.HAZE[1] > City.HAZE[2], 'the far band is the haziest');
+  assert.equal(City.hazeBand({ x0: 0, x1: 3, y0: 0, y1: 3 }), 0, 'the back corner is far');
+  assert.equal(City.hazeBand({ x0: 12, x1: 15, y0: 12, y1: 15 }), 2, 'the front corner is near');
+  // without the living model nothing is hazed: the old city is the old city
+  const old = City.cityModel({ docket: fx('government__docket'), goals: fx('goals').goals, rollups: fx('goals__rollups').rollups, mode: 'dark', now: NOW });
+  assert.ok(old.districts.every((D) => D.haze === 0));
+});
+
+test('the spend conduit: the trunk is as wide as the real spend rate; a dry pot is starved and raises a beacon', () => {
+  const m = city();
+  const cost = fx('public__cost-summary');
+  const month = cost.by_month.find((x) => x.month === '2026-10').total_usd;
+  const rate = Math.round(Math.round(month * 100) / 100 / 9 * 100) / 100;
+  assert.equal(m.spend.rate_usd_per_day, rate, 'this month\'s real spend over the nine days so far');
+  const trunk = m.flat.find((p) => p.key === 'trunk');
+  assert.equal(trunk.w, City.trunkWidth(rate));
+  assert.equal('proto' in trunk, false, 'the spend is real');
+  assert.ok(City.trunkWidth(rate * 4) > City.trunkWidth(rate), 'more spend, a wider trunk');
+  assert.ok(m.flat.filter((p) => /^spur:/.test(p.key || '')).length > 0, 'the pots split it (task 1004712)');
+  const dry = m.flat.find((p) => p.key === 'spur:1000106');
+  assert.match(dry.cls, /city-conduit--dry/);
+  assert.equal(dry.dash, '2 3', 'starved');
+  assert.deepEqual(m.beacons.map((b) => [b.goal_id, b.ask_id]), [['1000106', 'treasury_spending:1']], 'the dry pot asks the reserve');
+  const wide = m.spend.spurs.reduce((a, b) => (b.share > a.share ? b : a));
+  assert.equal(wide.goal_id, '1000095', 'the busiest pot has the widest spur');
+  // no treasury read: the trunk alone, no split, no beacon
+  const bare = city({ treasury: null });
+  assert.ok(bare.flat.some((p) => p.key === 'trunk'));
+  assert.equal(bare.flat.filter((p) => /^spur:/.test(p.key || '')).length, 0);
+  assert.equal(bare.beacons.length, 0);
+  // no spend read: no conduit at all
+  assert.equal(city({ cost: null }).flat.filter((p) => /city-conduit/.test(p.cls || '')).length, 0);
+});
+
+// ── the plaque, the card, the door ─────────────────────────────────────────
+
+test('the plaque: the form of government, laws, what is on you, this month\'s spend', () => {
+  const m = city();
+  const con = fx('government__constitution');
+  assert.deepEqual(m.plaque.map((t) => [t.key, t.figure, t.words]), [
+    ['form', con.charter.reads_as.name, 'government'], ['laws', '1', 'law'], ['you', String(m.counts.on_you), 'to do'], ['spend', '$6,319', 'this month'],
+  ]);
+  assert.ok(m.counts.on_you > 0);
+  assert.ok(m.plaque.every((t) => !('proto' in t)), 'every tile is a real read');
+  const s = city({ me: STRANGER });
+  assert.ok(!s.plaque.some((t) => t.key === 'you'), 'a tile is hidden at zero');
+  assert.ok(!city({ constitution: null }, { constitution: null }).plaque.some((t) => t.key === 'form'));
+});
+
+test('the card: who holds it, one fact, its count, two doors (its first ask is the deck\'s own card, task 1004702)', () => {
+  const m = city();
+  const p = civicOf(m, 'planning').card;
+  assert.equal(p.plate, 'Builder 2012');
+  assert.equal(p.fact.text, '16 of 55 kept', 'the docket\'s own reading');
+  assert.equal(p.on_you, civicOf(m, 'planning').on_you);
+  assert.equal(p.deck_href, '/builders/street#deck=planning');
+  assert.equal(p.enter_href, '/builders/street#building=planning');
+  for (const c of m.civic) assert.deepEqual(Object.keys(c.card).sort(), ['agents', 'deck_href', 'enter_href', 'fact', 'key', 'lead', 'name', 'on_others', 'on_you', 'open', 'plate'], c.key + ': every answer is the deck\'s');
+  assert.equal(civicOf(m, 'charter').card.plate, 'owner', 'an unseated building is the owner\'s');
+  assert.equal(civicOf(m, 'automation').card.fact.text, 'unattended off', 'the real fence');
+  assert.equal(civicOf(m, 'release').card.fact.text, '2 agents working');
+});
+
+test('an ask answered this visit (on the deck) leaves the counts, the card and the pin', () => {
+  const m = city();
+  const first = G.livingModel(livingInputs()).city.asks.find((a) => a.building === 'planning' && a.needs_you).id;
+  const a = city({}, { answered: [first] });
+  assert.equal(a.counts.on_you, m.counts.on_you - 1);
+  assert.equal(a.cta.label, 'decide ' + (m.counts.on_you - 1) + ' in a row');
+  assert.equal(civicOf(a, 'planning').card.on_you, civicOf(m, 'planning').card.on_you - 1);
+  assert.equal(a.pins.find((p) => p.building === 'planning').count, civicOf(m, 'planning').on_you - 1);
+});
+
+test('the door is "decide N in a row" to the deck; the line counts you, others and the agents', () => {
+  const m = city();
+  const c = m.counts;
+  assert.ok(c.on_you > 0 && c.on_others > 0);
+  assert.deepEqual([m.cta.label, m.cta.href], ['decide ' + c.on_you + ' in a row', '/builders/street#deck']);
+  assert.equal(m.line, c.on_you + ' to do · ' + c.on_others + ' wait on others · 5 agents working');
+  assert.equal(City.livingLine(1, 0, 1), '1 to do · 1 agent working');
+  assert.equal(City.livingLine(0, 3, 0), 'nothing to do · 3 wait on others');
+  assert.equal(city({ docket: null }).line, City.FALLBACK_LINE, 'an unread docket says so');
+});
+
+// ── all of it real ─────────────────────────────────────────────────────────
+
+test('nothing in the drawing carries a prototype mark, and an overlay handed in changes nothing', () => {
+  const m = city();
+  const marked = allPolys(m).filter((x) => 'proto' in x.p || (x.part && 'proto' in x.part));
+  assert.deepEqual(marked.map((x) => x.where + ':' + (x.p.cls || x.part.cls)), [], 'no part carries a proto flag');
+  assert.ok(m.civic.every((c) => !('proto' in c.plate) && !('proto' in c.card)));
+  assert.equal('proto_note' in m, false, 'and there is no prototype key to show');
+  const inp = livingInputs({ overlay: { leads: [{ building: 'rules', lead: '3' }], laws: [{ id: 'x', text: 'An invented law' }], buildouts: [{ id: 'y', building: 'rules', authorised: true }] } });
+  const withOverlay = City.cityModel({ docket: inp.docket, goals: inp.goals.goals, rollups: inp.rollups.rollups, mode: 'dark', now: NOW, living: G.livingModel(inp), constitution: inp.constitution });
+  assert.deepEqual(withOverlay, m, 'the overlay is not read');
+});
+
+// ── motion, budget, purity ─────────────────────────────────────────────────
+
+test('motion is CSS, long, inside the budget, with a still frame on every moving part', () => {
+  const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  for (const k of ['city-fly', 'city-rise', 'city-climb', 'city-swing', 'city-shaft']) assert.match(css, new RegExp(`@keyframes ${k} `), k);
+  const loops = [...css.matchAll(/animation:\s*city-(fly|rise|climb|swing|shaft)\s+(\d+)s/g)];
+  assert.equal(loops.length, 5);
+  for (const l of loops) assert.ok(Number(l[2]) >= 20, `${l[1]} runs ${l[2]}s: an ambient loop is 20s or longer`);
+  // the new keyframes move transform or offset-distance only
+  for (const k of ['city-fly', 'city-rise', 'city-climb', 'city-swing', 'city-shaft', 'city-plug', 'city-plug-in']) {
+    const body = css.match(new RegExp(`@keyframes ${k} \\{([\\s\\S]*?)\\}\\s*\\}`))[1];
+    const props = [...body.matchAll(/([a-z-]+)\s*:/g)].map((x) => x[1]);
+    assert.ok(props.every((p) => p === 'transform' || p === 'offset-distance'), `${k}: ${props}`);
+  }
+  assert.doesNotMatch(css, /stroke-dashoffset/);
+  assert.doesNotMatch(css, /blur\(/, 'no per-particle blur');
+  // the still frame of each moving part is the part's own value
+  assert.match(css, /\.city-pod \{[^}]*offset-distance: var\(--pod-at/);
+  assert.match(css, /\.city-rise \{[^}]*transform: scaleY\(var\(--rise/);
+  assert.match(css, /\.city-climb \{[^}]*transform: translateY\(var\(--climb-at/);
+  assert.match(css, /\.city-shaft__ring \{[^}]*transform: translateY\(-\d+px\)/);
+  assert.match(css, /@media \(prefers-reduced-motion: reduce\) \{[^}]*animation: none !important; transition: none !important;/);
+  const m = city();
+  const moving = Object.values(m.motion).reduce((n, x) => n + x, 0);
+  assert.ok(moving < 100, `${moving} moving nodes`);
+});
+
+test('salmon is spent only on what waits on you (and the door, the focus ring)', () => {
+  const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  const ALLOWED = /city-win--you|city-pin--(urgent|needs)|city-pin__ring|city-pin__age|city-start|city-card__go--you|city-ask--you|city-plaque__tile\[data-key="you"\]|city-card__count--you|focus-visible|body\[data-page="city"\]\s*$/;
+  let checked = 0;
+  for (const r of css.matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
+    if (!/var\(--accent(-deep|-lift)?\)/.test(r[2])) continue;
+    const sel = r[1].trim();
+    checked += 1;
+    assert.match(sel, ALLOWED, `"${sel}" spends the accent`);
+  }
+  assert.ok(checked >= 10, `${checked} accent rules were read, not a vacuous scan`);
+  assert.doesNotMatch(css, /\.city-parcel--out \{[^}]*var\(--accent\)/, 'work leaving through Release is ink');
+});
+
+test('city-draw.js is pure: no DOM, no fetch, no clock', () => {
+  const src = read('city-draw.js');
+  const code = src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:'"`\\])\/\/.*$/gm, '$1');
+  const tail = "typeof window !== 'undefined' ? window : globalThis";
+  assert.ok(code.includes(tail));
+  const body = code.replace(tail, '');
+  for (const [name, re] of Object.entries({ window: /\bwindow\b/, document: /\bdocument\b/, fetch: /\bfetch\b/, 'Date.now': /Date\.now/, 'new Date()': /new Date\(\s*\)/, setTimeout: /setTimeout|setInterval/, localStorage: /localStorage/ })) {
+    assert.doesNotMatch(body, re, `${name} must not appear in city-draw.js`);
+  }
+  const inp = livingInputs();
+  const before = JSON.stringify(inp);
+  const one = city();
+  assert.deepEqual(city(), one, 'the same reads give the same city');
+  assert.equal(JSON.stringify(inp), before);
+});
+
+// ── the page ────────────────────────────────────────────────────────────────
+
+const IDS = ['cityMode', 'cityModeIcon', 'cityStage', 'cityFrame', 'cityFlat', 'cityBlds', 'citySkyLanes', 'cityParcels', 'citySky', 'cityPins', 'cityHits', 'cityLine', 'cityStart', 'cityPlaque', 'cityCard', 'hall-main'];
+function fakeDom() {
+  const byId = new Map();
+  const all = [];
+  const mk = (tag) => {
+    const el = {
+      tagName: tag, attrs: {}, children: [], style: { setProperty(k, v) { this[k] = v; } }, className: '', listeners: {}, _text: '', parentNode: null,
+      get firstChild() { return this.children[0] || null; },
+      setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'id') byId.set(String(v), this); },
+      removeAttribute(k) { delete this.attrs[k]; },
+      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, e) { (this.listeners[t] || []).forEach((fn) => fn({ type: t, target: this, ...e })); },
+      focus() { focused = this; },
+      // enough of querySelector for city.js: '.a, .b' and '[attr="v"]'
+      querySelector(sel) {
+        const want = sel.split(',').map((s) => s.trim());
+        const ok = (c) => want.some((w) => {
+          const a = /^\[([\w-]+)="([^"]*)"\]$/.exec(w);
+          return a ? c.attrs[a[1]] === a[2] : String(c.className).split(' ').includes(w.replace(/^\./, ''));
+        });
+        const walk = (n) => { for (const c of n.children) { if (ok(c)) return c; const f = walk(c); if (f) return f; } return null; };
+        return walk(this);
+      },
+      set textContent(v) { this._text = String(v); this.children = []; },
+      get textContent() { return this._text + this.children.map((c) => c.textContent).join(''); },
+      get innerHTML() { throw new Error('city.js must not read innerHTML'); },
+      set innerHTML(v) { throw new Error('city.js must not write innerHTML'); },
+    };
+    all.push(el);
+    return el;
+  };
+  let focused = null;
+  const html = mk('html');
+  for (const id of IDS) 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, focused: () => focused };
+}
+const find = (el, pred) => { if (pred(el)) return el; for (const c of el.children) { const f = find(c, pred); if (f) return f; } return null; };
+const findAll = (el, pred, out = []) => { if (pred(el)) out.push(el); el.children.forEach((c) => findAll(c, pred, out)); return out; };
+
+// real past asks as stored asks: the server attaches a matter's stored ask as `ask`
+const CARDS = JSON.parse(fs.readFileSync(path.join(ROOT, 'tests', 'fixtures', 'government-ask-cards.json'), 'utf8')).cards;
+function withAsks(d) {
+  d.matters.forEach((m) => {
+    const c = CARDS.find((x) => x.id === m.id);
+    if (c) m.ask = { question: c.question, options: c.options, recommend: c.recommend, waits_on: c.waits_on, if_nobody_answers: c.if_nobody_answers };
+  });
+  return d;
+}
+async function bootLiving({ asks = false, answer = null } = {}) {
+  const { document, byId, html, focused } = fakeDom();
+  const timers = [];
+  const window = {
+    innerWidth: 1440, innerHeight: 900, localStorage: { getItem: () => 'dark', setItem() {} },
+    matchMedia: () => ({ matches: true, addEventListener() {} }), addEventListener() {},
+    setTimeout: (fn) => { timers.push(fn); return timers.length; }, clearTimeout() {},
+  };
+  const feeds = {
+    '/api/bongos/government/docket': asks ? withAsks(docketRouted()) : docketRouted(), '/api/bongos/goals': fx('goals'), '/api/bongos/goals/rollups': fx('goals__rollups'),
+    '/api/bongos/government/leads': leadsRead(), '/api/bongos/government/treasury': fx('government__treasury'),
+    '/api/bongos/government/constitution': fx('government__constitution'), '/api/bongos/tasks/claimable?limit=1': fx('tasks__claimable'),
+    '/api/bongos/tasks?status=active&limit=200': fx('tasks__status-active'), '/api/bongos/public/cost-summary': fx('public__cost-summary'),
+    '/api/bongos/builders/roster': fx('builders__roster'), '/api/bongos/me': fx('me'), '/api/bongos/blockers?limit=100': fx('blockers'),
+    '/api/bongos/autonomy/fence': fx('autonomy__fence'), '/api/bongos/moving': fx('moving'),
+  };
+  const calls = [];
+  const sent = [];
+  const fetch = (url, init) => {
+    if (init && init.method && init.method !== 'GET') {
+      const body = JSON.parse(init.body || '{}');
+      sent.push({ method: init.method, url, body });
+      const out = (answer && answer(url, body)) || { status: 501, body: { error: { code: 'preview_readonly' } } };
+      return Promise.resolve({ ok: out.status < 300, status: out.status, json: async () => out.body || {} });
+    }
+    calls.push(url); const b = feeds[url]; return Promise.resolve(b === undefined ? { ok: false, json: async () => ({}) } : { ok: true, json: async () => clone(b) }); };
+  class FixedDate extends Date { constructor(...a) { super(...(a.length ? a : [NOW])); } static now() { return NOW; } }
+  class MutationObserver { observe() {} }
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, console, MutationObserver, Date: FixedDate, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map, Set, setTimeout, clearTimeout });
+  ctx.globalThis = ctx;
+  // both hang themselves on `window` (it exists in this context), as in the browser
+  vm.runInContext(read('gov-living.js'), ctx);
+  vm.runInContext(read('city-draw.js'), ctx);
+  assert.ok(window.GovLiving && window.GovCity);
+  // the deck's card and sender, as city.html loads them (task 1004702)
+  for (const f of ['street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street-deck.js']) vm.runInContext(read(f), ctx);
+  assert.ok(window.GovDeck && window.GovDesk, 'the deck\'s scripts are on the page');
+  vm.runInContext(read('city.js'), ctx);
+  await window.GovCityPage.ready;
+  return { window, byId, html, calls, sent, timers, focused };
+}
+
+test('the page reads the living feeds and draws the sky, the plates, the plaque and the door', async () => {
+  const p = await bootLiving();
+  for (const url of Object.values(p.window.GovCityPage.LIVING_FEEDS)) assert.ok(p.calls.includes(url), url);
+  const pods = p.byId.get('citySky').children.filter((c) => /city-pod/.test(c.className));
+  assert.equal(pods.length, fx('tasks__claimable').active_claims.length, 'one pod per agent');
+  assert.ok(pods.every((s) => /^path\('M/.test(s.style.offsetPath) && /%$/.test(s.style['--pod-at'])), 'each on its lane, its still frame set');
+  assert.equal(p.byId.get('cityHits').children.length, 9, 'one button per civic building');
+  assert.ok(p.byId.get('cityHits').children.every((b) => b.tagName === 'button' && /, (led by|held by)/.test(b.attrs['aria-label'])));
+  assert.equal(p.byId.get('citySky').children.filter((c) => /city-shaft/.test(c.className)).length, 1);
+  const plaque = p.byId.get('cityPlaque');
+  assert.equal(plaque.children.length, 4);
+  assert.equal(plaque.attrs.hidden, undefined, 'the plaque shows');
+  const m = city();
+  const start = p.byId.get('cityStart');
+  assert.equal(start.textContent, m.cta.label);
+  assert.equal(start.attrs.href, '/builders/street#deck');
+  assert.equal(p.byId.get('cityLine').textContent, m.line);
+  for (const id of ['cityBlds', 'citySky', 'cityPins', 'cityPlaque']) assert.equal(findAll(p.byId.get(id), (n) => 'data-proto' in n.attrs).length, 0, id + ': nothing marked prototype');
+  assert.doesNotMatch(read('city.html'), /cityKey|cityToast|data-proto/, 'the page has no prototype key and no in-place answer toast');
+});
+
+test('a building opens its card in place: who holds it, one fact, what waits, its first ask and two doors to the deck and the street', async () => {
+  const p = await bootLiving();
+  const hit = p.byId.get('cityHits').children.find((b) => b.attrs['data-building'] === 'planning');
+  hit.fire('click');
+  const card = p.byId.get('cityCard');
+  assert.equal(card.attrs.hidden, undefined);
+  assert.equal(card.attrs['data-building'], 'planning');
+  assert.match(card.textContent, /Planning/);
+  // the viewer (builder 2012) leads Planning: "Your seat." (task 1004702: the card speaks to you)
+  assert.match(card.textContent, /Your seat\./);
+  const n = civicOf(city(), 'planning').on_you;
+  assert.match(card.textContent, new RegExp(n + ' wait on you\\.'));
+  assert.ok(/\bgov-glass\b/.test(card.className), 'the card is glass');
+  const doors = findAll(card, (x) => x.tagName === 'a' && /city-card__(go|enter)/.test(String(x.className)));
+  assert.deepEqual(doors.map((a) => [a.textContent, a.attrs.href]), [['decide all ' + n + ' in a row', '/builders/street#deck=planning'], ['go inside', '/builders/street#building=planning']], 'two doors');
+  // the building's first ask stands in place, as the deck draws it
+  const ask = findAll(card, (x) => /\bcity-ask\b/.test(String(x.className)));
+  assert.equal(ask.length, 1, 'its first ask, in place');
+  assert.ok(/\bask--here\b/.test(ask[0].className));
+  card.fire('keydown', { key: 'Escape', preventDefault() {} });
+  assert.equal(card.attrs.hidden, '', 'Escape closes it');
+  const again = p.byId.get('cityHits').children.find((b) => b.attrs['data-building'] === 'planning');
+  assert.ok(p.focused() === again, 'and focus goes back to the building (its button, redrawn)');
+});
+
+test('the city card answers its building\'s first ask in place, through the same route the deck takes (task 1004702)', async () => {
+  const p = await bootLiving({ asks: true, answer: (url) => (/\/resolve$/.test(url) ? { status: 200, body: { ok: true } } : null) });
+  p.byId.get('cityHits').children.find((b) => b.attrs['data-building'] === 'planning').fire('click');
+  const card = p.byId.get('cityCard');
+  const ask = findAll(card, (x) => /\bcity-ask\b/.test(String(x.className)))[0];
+  const id = ask.attrs['data-ask'];
+  assert.match(id, /^blockers:\d+$/, 'Planning\'s first ask is a blocker with its stored ask');
+  const opts = findAll(ask, (x) => x.tagName === 'button' && /\bask__opt\b/.test(String(x.className)));
+  assert.ok(opts.length >= 2 && opts.some((o) => findAll(o, (k) => /\bask__pick\b/.test(String(k.className)) && k.textContent === 'my pick').length), 'tap answers, the pick marked "my pick"');
+  assert.match(findAll(ask, (x) => /\bask__said\b/.test(String(x.className)))[0].textContent, /^I(?:'|\s)/, 'the said line is in the asker\'s voice');
+  // the same request the deck sends for the same answer
+  const Kd = p.window.GovDeck;
+  const op = opts[1];
+  const key = op.attrs['data-key'];
+  card.fire('keydown', { key: op.attrs['data-n'], preventDefault() {} });
+  await new Promise((r) => setTimeout(r, 20));
+  assert.equal(p.sent.length, 1, 'one request');
+  assert.equal(p.sent[0].method, 'POST');
+  assert.equal(p.sent[0].url, '/api/bongos/blockers/' + id.split(':')[1] + '/resolve', 'the blocker\'s own route, the one its desk row and the deck use');
+  assert.match(p.sent[0].body.resolution_note, /^Decided on the floor desk: /, 'the desk row words');
+  assert.ok(Kd && typeof Kd.sendAnswer === 'function' && !/fetch\(/.test(read('street-deck.js').split('function sendAnswer')[1].split('\n  }\n')[0]), 'the card sends through the deck\'s sender, not a route of its own');
+  assert.equal(findAll(p.byId.get('cityCard'), (x) => x.attrs && x.attrs['data-ask'] === id).length, 0, 'the answered ask leaves the card');
+});
+
+test('a pointer finds a building by its own faces, its pin or its plate (the one in front wins)', async () => {
+  const p = await bootLiving();
+  const groups = p.byId.get('cityBlds').children.filter((g) => g.attrs['data-civic']);
+  assert.deepEqual(groups.map((g) => g.attrs['data-civic']).sort(), City.CIVIC_SLOTS.map((s) => s[0]).sort(), 'every civic building\'s faces answer a pointer');
+  assert.ok(p.byId.get('cityBlds').children.filter((g) => !g.attrs['data-civic']).every((g) => !(g.listeners.click || []).length), 'a district tower does not');
+  groups.find((g) => g.attrs['data-civic'] === 'charter').fire('click');
+  assert.equal(p.byId.get('cityCard').attrs['data-building'], 'charter');
+  const pin = p.byId.get('cityPins').children.find((s) => s.attrs['data-building'] === 'review');
+  pin.children[0].fire('click');
+  assert.equal(p.byId.get('cityCard').attrs['data-building'], 'review', 'a pin opens its own building, wherever it stands');
+  const plate = p.byId.get('citySky').children.find((s) => /city-plate/.test(s.className) && s.attrs['data-building'] === 'people');
+  plate.fire('click');
+  assert.equal(p.byId.get('cityCard').attrs['data-building'], 'people');
+  // the keyboard's buttons take no pointer events, so overlapping rectangles never steal a click
+  const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.match(css, /\.city-hit \{[^}]*pointer-events: none;/);
+  assert.match(css, /\.city-blds g\[data-civic\] \{ pointer-events: visiblePainted;/);
+});
+
+// task 1004718: the back corner, the centre and the front corner stand in one
+// screen column, so a building directly behind a taller one never shows its
+// lit floor. Planning held the back corner behind the Charter (158 high) and
+// its salmon windows were hidden; now nothing taller stands in front of it in
+// its column, and the Charter (the tallest) rises from the back corner.
+test('Planning stands behind nothing taller, so its lit floor shows', () => {
+  const at = City.CIVIC_SLOTS.map(([key, x, y]) => ({ key, col: x - y, depth: x + y, roof: City.ROOF[key] }));
+  const planning = at.find((b) => b.key === 'planning');
+  const front = at.filter((o) => o.col === planning.col && o.depth > planning.depth);
+  for (const o of front) assert.ok(o.roof < planning.roof, 'planning stands behind the taller ' + o.key);
+  assert.deepEqual(City.CIVIC_SLOTS.find((s) => s[0] === 'charter').slice(1), [5, 5], 'the Charter rises from the back corner');
+});