@bongos/core 1.21.113 → 1.21.114

package/tests/hall_buildouts.mjs

@@ -0,0 +1,208 @@
+// tests/hall_buildouts.mjs — A LEAD'S BUILD-OUTS IN THE HALL (task 1004711, goal
+// 1000111; ADR 0378). GET /government/leads carries each building's `structure`
+// (tests/government_buildouts.mjs pins the server); this file pins what the hall
+// draws from it:
+//   1. THE MODEL (gov-living.js): a build-out going up is a live site at its real
+//      progress; one waiting on a vote is a ghost whose tally is its sitting's on
+//      the docket; a committee room is a real room; a floor that stands built is a
+//      real floor, and every one of these fields is labelled real or derived (an
+//      `overlay` handed in changes nothing: task 1004717 deleted it).
+//   2. THE CITY (city-draw.js): the live site (scaffold, crane, rising floor) and
+//      the ghost (parked crane, dashed glass, tally arc) are drawn from it; the
+//      real rooms and floors plug into the core.
+//   3. THE OFFICE (street-office.js): it stands where the real Leads are read; its works are the real build-outs; a tap goes to POST
+//      /government/buildouts; and THE PROPOSAL PICTURE RENDERS FROM THE REAL
+//      BUILDING — what stands is drawn solid, the change dashed on top of it.
+//
+// Run:  node --test tests/hall_buildouts.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+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'));
+require(path.join(PUB, 'street-desk.js'));
+require(path.join(PUB, 'street-deck.js'));
+const L = require(path.join(PUB, 'gov-living.js'));
+const O = require(path.join(PUB, 'street-office.js'));
+const fx = (n) => JSON.parse(fs.readFileSync(path.join(FX, n + '.json'), 'utf8'));
+const j = (v) => JSON.parse(JSON.stringify(v));
+const NOW = Date.parse('2026-10-10T06:00:00.000Z');
+
+// the hub's leads read with a Lead at Release and the structure the server serves
+const DOCKET_ID = 'board:91';
+function leadsWith() {
+  const r = j(fx('government__leads'));
+  const at = (k) => r.buildings.find((b) => b.building === k);
+  const rel = at('release');
+  rel.lead = { id: '5', building: 'release', builder: { id: '777', login: 'quill', name: 'Quill' }, charter: 'Releases.', since: '2026-10-09T12:00:00.000Z', appointed_by: { item_id: '40' } };
+  rel.answers = { seat: 'lead:release', builder_ids: ['777'], fell_to_owner: false };
+  rel.structure = {
+    standing: [
+      { id: '1', building: 'release', capsule: 'floor', name: 'Staging Deck', line: 'Try each release first.', state: 'building', progress: 0.4, started_at: '2026-10-10T00:00:00.000Z', builder: null, allowed: { path: 'at_once', ground: 'form', why: 'The founder decides alone.' } },
+      { id: '2', building: 'release', capsule: 'committee', name: 'Gate Room', line: 'Who checks a release.', state: 'built', progress: 1, started_at: '2026-10-01T00:00:00.000Z', builder: null, allowed: { path: 'vote', item_id: '44' } },
+      { id: '3', building: 'release', capsule: 'floor', name: 'Canary Floor', line: '', state: 'built', progress: 1, started_at: '2026-09-30T00:00:00.000Z', builder: null, allowed: { path: 'vote', item_id: '43' } },
+    ],
+    proposed: [],
+  };
+  at('treasury').structure = {
+    standing: [],
+    proposed: [{ item_id: '91', matter_id: '9', docket_id: DOCKET_ID, building: 'treasury', capsule: 'annex', name: 'Reserve Wing', line: 'Where the reserve is kept.', opened_at: '2026-10-09T10:00:00.000Z', closes_at: null, href: '/board-room?item=91' }],
+  };
+  return r;
+}
+// the docket with the build-out's sitting open, 2 for and 1 against of 5 seats
+function docketWith() {
+  const d = j(fx('government__docket'));
+  d.matters.push({ id: DOCKET_ID, source: 'board', building: 'treasury', rule: 'majority', state: 'needs', title: 'Add an annex to Treasury: Reserve Wing', short: 'matter', opened_at: '2026-10-09T10:00:00.000Z', tally: { for: 2, against: 1, open: 2, needs: 'x' }, ref: { type: 'board_item', id: '91' }, acts: [] });
+  return d;
+}
+function inputs(over = {}) {
+  return {
+    docket: docketWith(), constitution: fx('government__constitution'), goals: fx('goals'), rollups: fx('goals__rollups'), blockers: fx('blockers'),
+    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: leadsWith(), now: NOW, ...over,
+  };
+}
+const bOf = (lv, k) => lv.buildings.find((b) => b.key === k);
+
+// ── 1. the model ────────────────────────────────────────────────────────────
+
+test('the model: a build-out going up is a live site at its real progress; a vote is a ghost tied to its sitting', () => {
+  const lv = L.livingModel(inputs());
+  const rel = bOf(lv, 'release');
+  const site = rel.construction.find((c) => c.authorised);
+  assert.deepEqual(j([site.kind, site.capsule, site.id, site.label, site.progress, site.authorised_by]), ['buildout', 'floor', 'buildout:1', 'Staging Deck', 0.4, 'The founder decides alone.']);
+  assert.equal(rel.construction.indexOf(site), 0, 'drawn ahead of any other sitting there');
+  const tre = bOf(lv, 'treasury');
+  const ghost = tre.construction[0];
+  assert.deepEqual(j([ghost.kind, ghost.capsule, ghost.authorised, ghost.ask_id, ghost.sitting_id, ghost.needs]), ['scaffold', 'annex', false, DOCKET_ID, '91', 'a vote']);
+  assert.equal(tre.construction.filter((c) => c.id === DOCKET_ID).length, 1, 'its sitting is drawn once, as its ghost');
+  for (const c of [site, ghost]) for (const [k, v] of Object.entries(c._sources)) assert.ok(v === 'real' || v === 'derived', `${c.id}.${k}`);
+  assert.equal(rel._sources['counts.building'], 'derived');
+});
+
+test('the model: a committee room is a real room, a floor that stands built a real floor; no deputies are invented', () => {
+  const lv = L.livingModel(inputs());
+  const rel = bOf(lv, 'release');
+  assert.deepEqual(j(rel.structure.committees), [{ key: 'b2', name: 'Gate Room', line: 'Who checks a release.', members: [], real: true, state: 'built' }]);
+  assert.deepEqual(j(rel.structure.built), [{ id: 'buildout:3', capsule: 'floor', name: 'Canary Floor', line: '' }]);
+  assert.deepEqual(Object.keys(rel.structure).sort(), ['built', 'committees'], 'no table holds deputies: none is drawn');
+  assert.equal(rel._sources.structure, 'real');
+  assert.equal(bOf(lv, 'treasury')._sources.structure, 'real', 'an unseated building\'s structure is real too');
+});
+
+test('the model: an overlay handed in changes nothing (the prototype overlay is gone)', () => {
+  const a = L.livingModel(inputs());
+  const overlay = { buildouts: [{ id: 'x', building: 'release', authorised: true, label: 'Scrambled', progress: 0.9 }, { id: 'y', building: 'treasury', authorised: false, label: 'Other', ask_id: 'proto:x' }] };
+  const b = L.livingModel(inputs({ overlay }));
+  for (const k of ['release', 'treasury']) assert.deepEqual(j(bOf(a, k).construction), j(bOf(b, k).construction), k);
+});
+
+// ── 2. the city ─────────────────────────────────────────────────────────────
+
+function cityOf(over = {}) {
+  const inp = inputs(over);
+  const living = L.livingModel(inp);
+  return City.cityModel({ docket: inp.docket, goals: inp.goals.goals || inp.goals, rollups: inp.rollups.rollups || inp.rollups, mode: 'dark', now: NOW, living, constitution: inp.constitution });
+}
+
+test('the city: a live site with scaffold, crane and a rising floor at the real progress, unmarked', () => {
+  const m = cityOf();
+  const rel = m.civic.find((c) => c.key === 'release');
+  assert.deepEqual(j([rel.site.kind, rel.site.progress, rel.site.built]), ['live', 0.4, 1]);
+  const parts = m.blds.find((b) => b.key === 'release').parts;
+  for (const cls of ['city-scaffold', 'city-crane', 'city-jib', 'city-rise', 'city-climb']) {
+    const p = parts.find((x) => x.cls === cls);
+    assert.ok(p, cls);
+    assert.equal('proto' in p, false, cls + ' carries no prototype mark');
+  }
+  // the structure plugs into the core: the real Lead, the real room and the real floor
+  assert.deepEqual(j(rel.floors.map((f) => [f.kind, f.name])), [['lead', 'Quill'], ['committee', 'Gate Room'], ['floor', 'Canary Floor']]);
+  const plugs = parts.filter((p) => /city-plug/.test(p.cls || '') && ['lead', 'committee', 'floor'].includes(p.floor));
+  assert.equal(plugs.length, 6, 'a shell and its windows for each of the three');
+});
+
+test('the city: a build-out on a vote is a parked crane, a dashed ghost and its sitting\'s own tally', () => {
+  const m = cityOf();
+  const tre = m.civic.find((c) => c.key === 'treasury');
+  assert.deepEqual(j([tre.site.kind, tre.site.label, tre.site.ask_id]), ['pending', 'Reserve Wing', DOCKET_ID]);
+  assert.deepEqual(j(tre.tally), { seats: 5, yes: 2, no: 1 }, 'one dot a seat, filled as the docket counts them');
+  const parts = m.blds.find((b) => b.key === 'treasury').parts;
+  const ghost = parts.find((p) => p.cls === 'city-ghost');
+  assert.ok(ghost);
+  assert.ok(ghost.polys.filter((p) => p.f !== 'none').every((p) => p.dash === '4 3'), 'every face dashed');
+  assert.ok(parts.some((p) => p.cls === 'city-crane city-crane--parked'));
+  assert.ok(tre.shaft, 'its open sitting is a light shaft');
+});
+
+// ── 3. the office and the picture ───────────────────────────────────────────
+
+test('the office stands from the real Leads; its works are the real build-outs', () => {
+  const lv = L.livingModel(inputs());
+  const off = O.officeOf(lv, 'release');
+  assert.ok(off, 'the Leads were read: the office stands');
+  assert.deepEqual(j([off.seated, off.holders]), [true, ['777']]);
+  assert.deepEqual(j(off.rooms.map((r) => [r.name, r.proposed])), [['Gate Room', false]]);
+  assert.deepEqual(j(O.worksOf(lv, 'release').map((w) => [w.kind, w.state, w.label, w.progress])), [['floor', 'site', 'Staging Deck', 0.4]]);
+  assert.deepEqual(j(O.worksOf(lv, 'treasury').map((w) => [w.kind, w.state, w.label, w.ask])), [['annex', 'proposed', 'Reserve Wing', DOCKET_ID]]);
+  assert.equal(O.officeOf(L.livingModel(inputs({ leads: null })), 'release'), null, 'the Leads not read: no office is invented');
+});
+
+test('THE PROPOSAL PICTURE RENDERS FROM THE REAL BUILDING: what stands is solid, the change dashed on top of it', () => {
+  const lv = L.livingModel(inputs());
+  const struct = bOf(lv, 'release').structure;
+  const bare = O.isoPicture('release', 'floor', 'dark', null);
+  const real = O.isoPicture('release', 'floor', 'dark', struct);
+  assert.deepEqual(j(real.stands), { floors: 1, rooms: 1, annex: false, district: false }, 'the real floor and room are drawn');
+  assert.deepEqual(j(bare.stands), { floors: 0, rooms: 0, annex: false, district: false });
+  const solid = (p) => p.paths.filter((x) => x.dash !== '4 3' && x.f !== 'none').length;
+  const dashed = (p) => p.paths.filter((x) => x.dash === '4 3');
+  assert.ok(solid(real) > solid(bare), 'more of the building stands solid');
+  assert.ok(dashed(real).length > 0 && dashed(bare).length > 0, 'the change, dashed, on both');
+  // the ghost floor sits on top of what stands: higher on the page than on the bare building
+  const topOf = (paths) => Math.min(...paths.flatMap((p) => [...p.d.matchAll(/[ML]\s*(-?[\d.]+)\s+(-?[\d.]+)/g)].map((m) => Number(m[2]))));
+  assert.ok(topOf(dashed(real)) < topOf(dashed(bare)), 'the change is drawn above the floors that stand');
+  // an annex beside a built annex stands further out
+  const withAnnex = O.isoPicture('release', 'annex', 'dark', { built: [{ capsule: 'annex' }], committees: [] });
+  const rightOf = (paths) => Math.max(...paths.flatMap((p) => [...p.d.matchAll(/[ML]\s*(-?[\d.]+)\s+(-?[\d.]+)/g)].map((m) => Number(m[1]))));
+  assert.ok(rightOf(dashed(withAnnex)) > rightOf(dashed(O.isoPicture('release', 'annex', 'dark', null))), 'the second annex is drawn beyond the first');
+});
+
+test('a real build-out tap goes to the server: POST /government/buildouts, then the Leads and the docket are read again', async () => {
+  const sent = [];
+  const said = [];
+  let loads = 0;
+  const refreshed = [];
+  const saved = globalThis.GovFeeds;
+  globalThis.GovFeeds = { refresh: (k) => refreshed.push(k) };
+  const lv = L.livingModel(inputs());
+  const env = {
+    data: () => ({ docket: { viewer: { id: '777' } }, living: lv }), mode: () => 'dark', say: (t) => said.push(t), draw() {}, decided() {}, load: () => { loads += 1; },
+    send: async (req) => { sent.push(req); return { ok: true, status: 201, body: { ok: true, path: 'at_once', rights: { why: 'The founder decides alone.' } } }; },
+  };
+  try {
+    globalThis.GovDeck.page.living = () => lv;
+    O.page.mount(env);
+    const out = await O.page.buildOut('release', 'committee');
+    assert.deepEqual(j(sent), [{ method: 'POST', url: '/api/bongos/government/buildouts', body: { building: 'release', capsule: 'committee' } }]);
+    assert.equal(out.built, true);
+    assert.equal(out.path, 'at_once');
+    assert.match(said[0], /^Building a committee room now\. The founder decides alone\./);
+    assert.deepEqual(refreshed, [['leads', 'docket']]);
+    assert.equal(loads, 1);
+    assert.deepEqual(j(O.page.state), { presetFiled: {} }, 'nothing drawn for this visit only: the server\'s read draws it');
+    // a refusal is said, and nothing is drawn
+    env.send = async () => ({ ok: false, status: 403, body: { error: { code: 'not_the_holder', what_this_means: 'Release is led by Quill; only they grow its structure.' } } });
+    const no = await O.page.buildOut('release', 'floor');
+    assert.equal(no.refused, true);
+    assert.equal(said[said.length - 1], 'Release is led by Quill; only they grow its structure.');
+  } finally { globalThis.GovFeeds = saved; }
+});

package/tests/hall_city.mjs

@@ -120,12 +120,15 @@ test('a pin per open matter, in its state, over its building', () => {
   ];
   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'],
+    // back to front: the Charter stands in the back corner since task 1004718
+    ['board:1', 'charter', 'needs'], ['blockers:2', 'planning', 'moving'], ['removal_proposals:3', 'disputes', 'settled'],
   ]);
-  // the prototype's own pin position for a matter at the Charter: P(8, 8, 158 + 8)
+  // the prototype's own pin position for a matter at the Charter: P(slot + 1, slot + 1, 158 + 8)
+  // (task 1004718 moved the Charter to the back corner, so Planning is not behind it)
   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);
+  const cs = City.CIVIC_SLOTS.find((s) => s[0] === 'charter');
+  const top = k.P(cs[1] + 1, cs[2] + 1, 166);
   assert.equal(charter.x, Math.round((top[0] - 15) * 10) / 10);
   assert.equal(charter.y, Math.round((top[1] - 52) * 10) / 10);
 });
@@ -154,7 +157,8 @@ test('one pin per building, in the tier of its most important matter, with the c
   assert.deepEqual([m.pins[0].key, m.pins[0].state, m.pins[0].count], ['blockers:9', 'urgent', 4], 'urgent (needs you, due within a day); four open');
   assert.deepEqual(m.pins[0].matters, ['blockers:9', 'blockers:1', 'blockers:0', 'blockers:2', 'blockers:3']);
   const k = City.isoKit(60, 30, 720, 176, 30 / 28, City.isoTheme('dark'), false);
-  const top = k.P(6, 6, City.ROOF.planning + 8);
+  const ps = City.CIVIC_SLOTS.find((s) => s[0] === 'planning');
+  const top = k.P(ps[1] + 1, ps[2] + 1, City.ROOF.planning + 8);
   assert.equal(m.pins[0].x, Math.round((top[0] - 15) * 10) / 10, 'where the prototype stands a single pin');
   const tier = (list) => City.cityModel({ docket: docket(list), mode: 'dark', now: NOW }).pins[0].state;
   assert.equal(tier([matter({ state: 'needs', deadline: '2026-10-05T12:00:00.000Z' })]), 'needs', 'due after a day');
@@ -280,13 +284,17 @@ test('the city sits in the hall chrome, behind the shell\'s full-screen switch',
   for (const id of ['app-sidebar', 'app-scrim', 'app-topbar']) assert.match(html, new RegExp(`id="${id}"`), id);
   assert.match(html, /<main id="hall-main" class="city-main">\s*<div class="city-top">/, 'the stage is the one <main>, the strip inside it');
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts, ['shell-trail', 'craft-mode', 'shell', 'palette', 'city-draw', 'city'], 'the shell first, as on every hall page');
+  // task 1004685 (the living city): gov-living.js, the model under the drawing, and
+  // gov-feeds.js, its one reader per page (shared with the shell's tally), load before it
+  // task 1004702: the card answers its first ask in place, so the deck's card and sender (and the desk rows under them) load before the page
+  assert.deepEqual(scripts, ['shell-trail', 'craft-mode', 'shell', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city'], 'the shell first, as on every hall page');
   const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
   assert.match(css, /\.city-main \{ position: fixed; top: var\(--topbar-h, 56px\); left: var\(--sidebar-w-rail, 64px\);[^}]*contain: layout paint;/);
   assert.match(css, /html\[data-fullscreen="on"\] \.city-main \{ top: 0; left: 0; \}/);
   assert.match(css, /html\[data-fullscreen="on"\] \.city-top \{ right: 184px; \}/, 'the strip steps clear of the corner exit');
   const shell = read('shell.js');
-  assert.match(shell, /\{ id: 'city', label: 'City', icon: 'city', href: '\/city', gate: 'perm:board\.vote\.cast' \}/, 'the city is a tab, gated on its page\'s atom');
+  // (task 1004685's governing-as-a-seat pass marks the tab `position: true`; the gate is unchanged)
+  assert.match(shell, /\{ id: 'city', label: 'City', icon: 'city', href: '\/city', gate: 'perm:board\.vote\.cast'(, [^}]*)? \}/, 'the city is a tab, gated on its page\'s atom');
   assert.doesNotMatch(shell, /href:\s*'(\/builders)?\/street'/, 'the street has no sidebar link: the way in is the city');
 });