@bongos/core 1.21.112 → 1.21.114

package/tests/hall_gov_counts.mjs

@@ -0,0 +1,336 @@
+// tests/hall_gov_counts.mjs — ONE SOURCE OF COUNTS for the living city (task
+// 1004685, the integration pass of the living-city prototype).
+//
+// Before this pass the same fixtures printed five different numbers: the city's
+// plaque "24 on you", the street's header "needs you 37 · moving 0", its readings
+// "5 agents working" (but the city said "5 agents at work"), the deck "38 to decide · 23 on your seats" and the shell's
+// tally "needs you 9 · moving 6". Each surface counted for itself, over its own
+// reads. Now every number is gov-living.js countsOf over the reads gov-feeds.js
+// makes once per page, and each has one label (COUNT_WORDS after a number, "24
+// to do"; COUNT_LABELS as a heading, "to do 24": the owner's word for the main
+// count, task 1004701).
+//
+// What it pins, over the REAL harness fixtures:
+//   1. countsOf's numbers, and that moving can never read under agents at work;
+//   2. COUNT_FEEDS alone (what the shell's tally reads) give the same counts as
+//      every feed (what the city and the street read), with and without answers;
+//   3. each surface, rendered from the same fixture, prints those numbers: the
+//      city's plaque, door and line; the street's header and its flow reading;
+//      the deck's headline and its scope chips; the shell's tally (the REAL
+//      craft-mode.js + gov-feeds.js in a vm, over a fetch serving the fixtures);
+//   4. an answer moves every surface by the same one;
+//   5. the labels are COUNT_WORDS, verbatim, and the retired ones are gone.
+//
+// Run:  node --test --test-reporter=tap tests/hall_gov_counts.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 FX = path.join(ROOT, 'scripts/hall-preview/fixtures');
+const require = createRequire(import.meta.url);
+const L = require(path.join(PUB, 'gov-living.js'));
+const routing = require(path.join(ROOT, 'modules', 'government', 'routing.js'));
+const serverCounts = require(path.join(ROOT, 'modules', 'government', 'counts.js'));
+const F = require(path.join(PUB, 'gov-feeds.js'));
+const City = require(path.join(PUB, 'city-draw.js'));
+const S = require(path.join(PUB, 'street-draw.js'));
+require(path.join(PUB, 'street-inside.js'));
+const depthFile = path.join(PUB, 'street-depth.js');
+require(depthFile);
+require(path.join(PUB, 'street-card.js'));
+require(path.join(PUB, 'street-desk.js'));
+const K = require(path.join(PUB, 'street-deck.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const fx = (n) => JSON.parse(fs.readFileSync(path.join(FX, n + '.json'), 'utf8'));
+const NOW = Date.parse('2026-10-09T15:00:00.000Z');
+
+// the route each feed key is served from, and its fixture (the harness's own names)
+const FIXTURE = {
+  docket: 'government__docket', counts: 'government__counts', constitution: 'government__constitution', laws: 'government__laws', leads: 'government__leads', goals: 'goals', rollups: 'goals__rollups',
+  claims: 'tasks__claimable', tasks: 'tasks__status-active', cost: 'public__cost-summary', roster: 'builders__roster',
+  me: 'me', blockers: 'blockers', fence: 'autonomy__fence', moving: 'moving',
+  // the pots, the reserve, the spend cap (task 1004712)
+  treasury: 'government__treasury',
+  presets: 'government__presets',
+};
+// The hub has seated no Lead yet (GET /government/leads, task 1004709), so every
+// ask there falls to the owner seat — every Archon, the viewer among them — and
+// nothing would wait on others. These counts are about one source, not about who
+// leads, so the read here seats five Leads, as if appointed by People votes: asks
+// on the viewer's seats and asks on other people's, both present.
+const SEATED = [
+  { building: 'planning', lead: '1000025', since: '2026-09-12', charter: { scope: 'Planning floors: goals, priorities, the order of work.' } },
+  { building: 'release', lead: '1000027', since: '2026-09-05', charter: { scope: 'Release floors and the path to going live.' } },
+  { building: 'review', lead: '1000095', since: '2026-09-20', charter: { scope: 'Who checks finished work, and how.' } },
+  { building: 'treasury', lead: '1000094', since: '2026-09-28', charter: { scope: 'Pots and the reserve. A new spending arm needs a board vote.' } },
+  { building: 'people', lead: '1000070', since: '2026-10-02', charter: { scope: 'Who joins, and the ranks they hold.' } },
+];
+function seatedLeads() {
+  const read = fx('government__leads');
+  const roster = fx('builders__roster').builders;
+  for (const l of SEATED) {
+    const b = read.buildings.find((x) => x.building === l.building);
+    const p = roster.find((r) => String(r.id) === String(l.lead)) || { id: l.lead };
+    b.lead = { id: 'L' + l.building, building: l.building, builder: { id: String(p.id), login: p.github_login || null, name: p.display_name || null }, charter: l.charter.scope, since: l.since, appointed_by: { item_id: '1' } };
+    b.answers = { seat: 'lead:' + l.building, builder_ids: [String(p.id)], fell_to_owner: false };
+  }
+  return read;
+}
+// The dry pot's borrow (task 1004712) waits on the Treasury's Lead. Seated above
+// (not the viewer), it is routed to them by the server's own rule:
+// the ask on others these counts need.
+function seatedDocket() {
+  const d = fx('government__docket');
+  const read = seatedLeads();
+  const seats = { leads: read.buildings.filter((b) => b.lead).map((b) => ({ building: b.building, builder_id: b.lead.builder.id })), owner: read.owner, holders: {} };
+  d.matters.filter((m) => m.source === 'treasury_spending').forEach((m) => {
+    const { route, ...bare } = m;
+    m.route = routing.routeMatter(bare, d.viewer.id, seats, Date.parse(d.generated_at));
+  });
+  return d;
+}
+// GET /government/counts over that same seated docket, by the server's own rule
+// (modules/government/counts.js, task 1004716)
+function seatedCounts() {
+  const d = seatedDocket();
+  return Object.assign({ viewer: d.viewer, generated_at: d.generated_at }, serverCounts.countsOf(d, { moving: fx('moving').moving, agents_at_work: fx('tasks__claimable').active_claims.length }));
+}
+function fxFor(name) { return name === FIXTURE.leads ? seatedLeads() : name === FIXTURE.docket ? seatedDocket() : name === FIXTURE.counts ? seatedCounts() : fx(name); }
+function raw(keys = Object.keys(F.FEEDS)) {
+  const out = {};
+  keys.forEach((k) => { out[k] = fxFor(FIXTURE[k]); });
+  return out;
+}
+const full = () => L.livingModel(F.inputOf(raw(), NOW));
+const strip = (c) => { const o = { ...c }; delete o._sources; return o; };
+
+// ── 1. the numbers ───────────────────────────────────────────────────────────
+
+test('countsOf: on you, on others, to decide, agents at work and moving, from one model', () => {
+  const m = full();
+  const c = L.countsOf(m);
+  assert.deepEqual(strip(c), strip(m.city.counts), 'the model carries the same counts it would be asked for');
+  assert.ok(c.on_you > 0 && c.on_others > 0, 'the fixture has asks on you and on others');
+  assert.equal(c.open, c.on_you + c.on_others);
+  assert.equal(c.on_you, m.city.asks.filter(L.isOnYou).length);
+  assert.equal(c.on_others, m.city.asks.filter(L.isOnOthers).length);
+  assert.equal(c.agents_at_work, fx('tasks__claimable').active_claims.length, 'one agent per active claim');
+  assert.equal(c.moving, fx('moving').moving, 'moving is GET /moving, the owner\'s definition');
+  assert.ok(c.moving >= c.agents_at_work, 'moving (active + confirmed tasks) can never read under agents at work');
+  assert.deepEqual(Object.keys(c._sources).sort(), ['agents_at_work', 'moving', 'on_others', 'on_you', 'open']);
+});
+
+test('a figure that could not be read is null, never zero', () => {
+  const none = L.countsOf(L.livingModel({ now: NOW }));
+  assert.equal(none.on_you, null, 'no docket: nothing honest to say about what is on you');
+  assert.equal(none.agents_at_work, null, 'no claims read: unknown, not "no agent"');
+  assert.equal(none.moving, null);
+  const quiet = L.countsOf(L.livingModel({ docket: { matters: [] }, claims: { active_claims: [] }, moving: { moving: 0 }, now: NOW }));
+  assert.deepEqual([quiet.on_you, quiet.agents_at_work, quiet.moving], [0, 0, 0], 'read and empty is a real zero');
+});
+
+test('with no Lead read a docket matter waits where the docket says: on you', () => {
+  const r = raw();
+  delete r.leads;
+  const m = L.livingModel(F.inputOf(r, NOW));
+  const docketNeeds = r.docket.matters.filter((x) => x.state === 'needs' && x.route && x.route.yours).length;
+  assert.equal(L.countsOf(m).on_you, docketNeeds, 'a real site with no Leads prints the docket\'s own count');
+});
+
+// ── 2. the shell reads less, and counts the same ────────────────────────────
+
+test('on a real site COUNT_FEEDS alone (one server read) give the same counts as every feed', () => {
+  // the counts are GET /government/counts, and nothing else
+  const m = L.livingModel(F.inputOf(raw(), NOW));
+  const small = L.livingModel(F.inputOf(raw(F.COUNT_FEEDS), NOW));
+  assert.deepEqual(strip(L.countsOf(small)), strip(L.countsOf(m)));
+  assert.deepEqual(L.countsOf(small)._sources, { on_you: 'real', on_others: 'real', open: 'real', agents_at_work: 'real', moving: 'real' });
+  const ids = m.city.asks.filter(L.isOnYou).slice(0, 2).map((a) => a.id).concat(m.city.asks.filter(L.isOnOthers).slice(0, 1).map((a) => a.id));
+  assert.deepEqual(strip(L.countsOf(small, { answered: ids })), strip(L.countsOf(m, { answered: ids })));
+  assert.equal(L.countsOf(small, { answered: ids }).on_you, L.countsOf(small).on_you - 2);
+  // the tally reads the server's count, not the lists it used to count over
+  for (const k of ['counts']) assert.ok(F.COUNT_FEEDS.includes(k), k);
+  for (const k of ['docket', 'blockers', 'leads', 'claims', 'moving']) assert.ok(!F.COUNT_FEEDS.includes(k), `the tally no longer reads ${k}`);
+});
+
+test('in the harness COUNT_FEEDS, with the docket the page already read, give the same counts as every feed, with and without answers', () => {
+  // the city and the street (the tally's only pages) always read the docket
+  const m = full();
+  const small = L.livingModel(F.inputOf(raw(F.COUNT_FEEDS.concat(['docket'])), NOW));
+  assert.deepEqual(strip(L.countsOf(small)), strip(L.countsOf(m)));
+  const ids = m.city.asks.filter(L.isOnYou).slice(0, 3).map((a) => a.id).concat(m.city.asks.filter(L.isOnOthers).slice(0, 1).map((a) => a.id));
+  const s = { answered: ids };
+  assert.deepEqual(strip(L.countsOf(small, s)), strip(L.countsOf(m, s)));
+  assert.equal(L.countsOf(m, s).on_you, L.countsOf(m).on_you - 3);
+  assert.equal(L.countsOf(m, s).on_others, L.countsOf(m).on_others - 1);
+  // and nothing the shell reads is a task list
+  assert.ok(!F.COUNT_FEEDS.includes('tasks') && !F.COUNT_FEEDS.includes('goals'), 'the tally reads no task or goal list');
+  assert.match(F.FEEDS.claims, /limit=1\b/, 'the claims ride the claimable feed at one row');
+});
+
+// ── 3. every surface prints the same numbers ────────────────────────────────
+
+function cityOf(answered = []) {
+  const r = raw();
+  const m = full();
+  return City.cityModel({
+    docket: r.docket, goals: r.goals.goals, rollups: r.rollups.rollups, mode: 'dark', now: NOW,
+    living: m, constitution: r.constitution, answered, counts: L.countsOf(m, { answered }),
+  });
+}
+function streetOf(answered = []) {
+  const r = raw();
+  const m = full();
+  return S.streetModel({
+    docket: r.docket, goals: r.goals.goals, rollups: r.rollups.rollups, mode: 'dark', now: NOW, here: null,
+    depth: true, living: m, roster: r.roster, counts: L.countsOf(m, { answered }),
+  });
+}
+function deckOf(done = {}) {
+  const r = raw();
+  const m = full();
+  return K.deckModel({
+    living: m, docket: r.docket, goals: r.goals.goals.filter((g) => g.status === 'open'), now: NOW, viewerId: String(r.docket.viewer.id),
+    scope: null, session: { done, delegated: {}, skipped: [], extra: [], batch: null, noBatch: {} },
+  });
+}
+
+test('the city prints them: the plaque, the door and the line', () => {
+  const c = L.countsOf(full());
+  const cm = cityOf();
+  const you = cm.plaque.find((t) => t.key === 'you');
+  assert.equal(you.figure, String(c.on_you));
+  assert.equal(you.words, L.countWords('on_you', c.on_you));
+  assert.equal(cm.cta.label, 'decide ' + c.on_you + ' in a row');
+  assert.equal(cm.line, `${c.on_you} to do · ${c.on_others} ${L.countWords('on_others', c.on_others)} · ${c.agents_at_work} agents working`);
+  assert.deepEqual([cm.counts.on_you, cm.counts.on_others, cm.counts.agents_at_work, cm.counts.moving], [c.on_you, c.on_others, c.agents_at_work, c.moving]);
+  // the buildings' own windows and cards add up to the plaque
+  assert.equal(cm.civic.reduce((n, b) => n + b.on_you, 0), c.on_you, 'the nine buildings hold every ask on you');
+  assert.equal(cm.civic.reduce((n, b) => n + b.on_others, 0), c.on_others);
+});
+
+test('the street prints them: the header, the deck door and the flow reading', () => {
+  const c = L.countsOf(full());
+  const sm = streetOf();
+  assert.equal(sm.hud.needs, String(c.on_you), 'on you');
+  assert.equal(sm.hud.moving, String(c.moving), 'moving, never the docket\'s own moving-state count');
+  assert.equal(sm.hud.hot, c.on_you > 0);
+  assert.match(sm.hud.deck.aria, new RegExp('^' + c.on_you + ' to do\\.'));
+  assert.equal(sm.depth.tiles.flow.n, String(c.agents_at_work), 'the flow reading is agents at work');
+  assert.equal(sm.depth.tiles.flow.words, L.countWords('agents_at_work', c.agents_at_work));
+  // while the living model is still reading, the header says so rather than flash the docket's number
+  const pending = S.streetModel({ docket: fx('government__docket'), goals: [], rollups: [], mode: 'dark', now: NOW, depth: true, living: null, counts: null });
+  assert.deepEqual([pending.hud.needs, pending.hud.moving], ['—', '—']);
+});
+
+test('the deck prints them: the headline, the line under it and the scope chips', () => {
+  const c = L.countsOf(full());
+  const dm = deckOf();
+  assert.equal(dm.lead.n, c.on_you);
+  assert.equal(dm.lead.words, L.countWords('on_you', c.on_you));
+  assert.equal(dm.title, `${c.on_you} to do`);
+  assert.equal(dm.sub, `${c.on_others} ${L.countWords('on_others', c.on_others)} after these`);
+  assert.equal(dm.remaining, c.open, 'the deck holds every ask that needs a person');
+  assert.equal(dm.scopes.reduce((n, s) => n + s.n, 0), c.open, 'the "all" chip is the sum of the buildings');
+  assert.deepEqual(strip(dm.counts), strip(c));
+});
+
+test('the shell\'s tally prints them, through the real craft-mode.js and gov-feeds.js', async () => {
+  const c = L.countsOf(full());
+  const t = await shellTally();
+  assert.equal(t.text, `to do ${c.on_you} · moving ${c.moving}`);
+  for (const k of F.COUNT_FEEDS) assert.ok(t.asked.some((u) => u === F.API + F.FEEDS[k]), `the tally reads ${k}`);
+  assert.equal(t.asked.length, F.COUNT_FEEDS.length + 1, 'one read per feed: the COUNT_FEEDS, and the docket the page read');
+  assert.ok(!t.asked.some((u) => /\/goals|status=active/.test(u)), 'never a task or goal list');
+});
+
+// ── 4. an answer moves every surface by the same one ─────────────────────────
+
+test('answering one ask on you moves the city, the street, the deck and the tally by one', async () => {
+  const m = full();
+  const c = L.countsOf(m);
+  const first = m.city.asks.find(L.isOnYou).id;
+  const cm = cityOf([first]);
+  const sm = streetOf([first]);
+  const dm = deckOf({ [first]: true });
+  const t = await shellTally([first]);
+  assert.equal(cm.counts.on_you, c.on_you - 1);
+  assert.equal(cm.cta.label, 'decide ' + (c.on_you - 1) + ' in a row');
+  assert.equal(sm.hud.needs, String(c.on_you - 1));
+  assert.equal(dm.lead.n, c.on_you - 1);
+  assert.equal(t.text, `to do ${c.on_you - 1} · moving ${c.moving}`);
+});
+
+// ── 5. the labels ────────────────────────────────────────────────────────────
+
+test('every surface spells the counts in COUNT_WORDS, and the retired labels are gone', () => {
+  assert.deepEqual(Object.keys(L.COUNT_WORDS), ['on_you', 'on_others', 'open', 'agents_at_work', 'moving']);
+  const street = read('street.html');
+  assert.match(street, /<span class="street-label">to do<\/span>/, 'the header names the count as the tally does');
+  assert.equal(L.countLabel('on_you'), 'to do', 'the main count is "to do" (owner, 2026-10-09)');
+  assert.deepEqual([L.countWords('on_you', 1), L.countWords('on_you', 24)], ['to do', 'to do']);
+  assert.equal(cityOf().plaque.find((t) => t.key === 'you').words, 'to do');
+  const code = ['city-draw.js', 'city.js', 'street-draw.js', 'street-deck.js', 'street-office.js', 'craft-mode.js']
+    .concat(['street-depth.js'])
+    .map((f) => read(f).split('\n').filter((l) => !/^\s*(\/\/|\*)/.test(l)).join('\n')).join('\n');
+  for (const gone of ["' at work'", "' with others'", "' on your seats'", "' wait on you'", "words: 'on you'"]) {
+    assert.ok(!code.includes(gone), `${gone} is no longer printed anywhere`);
+  }
+});
+
+// ── the shell, in a vm: craft-mode.js + gov-living.js + gov-feeds.js ─────────
+
+function node(tag, id, cls) {
+  const attrs = {};
+  return {
+    tagName: tag, id: id || '', className: cls || '', dataset: {}, children: [], parentNode: null, textContent: '', innerHTML: '',
+    setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; }, removeAttribute(k) { delete attrs[k]; },
+    get nextSibling() { const sib = this.parentNode && this.parentNode.children; return sib ? sib[sib.indexOf(this) + 1] || null : null; },
+    appendChild(c) { c.parentNode = this; this.children.push(c); return c; },
+    insertBefore(c, ref) { c.parentNode = this; const at = ref ? this.children.indexOf(ref) : -1; if (at === -1) this.children.push(c); else this.children.splice(at, 0, c); return c; },
+    removeChild(c) { this.children.splice(this.children.indexOf(c), 1); c.parentNode = null; return c; },
+    querySelector(sel) { return all(this).find((n) => sel === '.' + n.className) || null; },
+    querySelectorAll() { return []; }, addEventListener() {}, classList: { toggle() {} },
+  };
+}
+function all(root) { return root.children.flatMap((c) => [c, ...all(c)]); }
+async function shellTally(answered = []) {
+  const sidebar = node('NAV', 'app-sidebar');
+  sidebar.appendChild(node('DIV', '', 'app-sidebar__brand'));
+  const topbar = node('DIV', 'app-topbar');
+  topbar.appendChild(node('H2', 'topbar-title'));
+  const document = {
+    documentElement: node('HTML'), body: (() => { const b = node('BODY'); b.setAttribute('data-page', 'street'); return b; })(), readyState: 'complete',
+    getElementById: (id) => [sidebar, topbar, ...all(sidebar), ...all(topbar)].find((n) => n.id === id) || null,
+    querySelectorAll: () => [], createElement: (t) => node(t.toUpperCase()), addEventListener() {}, removeEventListener() {}, dispatchEvent() { return true; },
+  };
+  const asked = [];
+  const byUrl = {};
+  Object.keys(F.FEEDS).forEach((k) => { byUrl[F.API + F.FEEDS[k]] = FIXTURE[k]; });
+  const fetch = (url) => {
+    asked.push(url);
+    const name = byUrl[url];
+    return Promise.resolve(name ? { ok: true, status: 200, json: () => Promise.resolve(fxFor(name)) } : { ok: false, status: 404, json: () => Promise.resolve({}) });
+  };
+  const mk = (obj) => ({ getItem: (k) => (k in obj ? obj[k] : null), setItem: (k, v) => { obj[k] = String(v); }, removeItem: (k) => { delete obj[k]; } });
+  const window = { localStorage: mk({}), sessionStorage: mk({ 'hall-craft': 'governing' }), matchMedia: () => ({ matches: false }), fetch };
+  const sandbox = { window, document, fetch, Date, Promise, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
+  vm.createContext(sandbox);
+  vm.runInContext(read('gov-living.js'), sandbox, { filename: 'gov-living.js' });
+  vm.runInContext(read('gov-feeds.js'), sandbox, { filename: 'gov-feeds.js' });
+  window.GovFeeds.useSession(() => ({ answered }));
+  // the street page has read its docket before the shell asks (street.js load)
+  await window.GovFeeds.read(['docket']);
+  vm.runInContext(read('craft-mode.js'), sandbox, { filename: 'craft-mode.js' });
+  window.OTBCraftMode.mount();
+  for (let i = 0; i < 20; i++) await new Promise((r) => setImmediate(r));
+  const box = all(topbar).find((n) => n.id === 'craft-tallies');
+  return { text: box ? box.innerHTML.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim() : '', asked };
+}