@bongos/core 1.21.18 → 1.21.20

package/tests/hall_street_inside.mjs

@@ -68,6 +68,8 @@ function docket(matters = [], over = {}) {
   };
 }
 const goal = (id, status = 'open', title = `Goal ${id}`) => ({ id: String(id), title, status });
+// a docket floor row in the route's shape (docket.js buildDocket `floors`)
+const floorRow = (key, over = {}) => ({ key, building: key.split('.')[0], status: 'live', count: '3', line: 'three things', lines: [['One thing.', 'today']], hot: false, reason: null, ...over });
 
 // ── the drawing is the prototype's ───────────────────────────────────────────
 
@@ -176,10 +178,12 @@ test('each building keeps the prototype\'s capacity, words and floor order', ()
 
 // ── 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 });
+test('a floor whose engine is coming stands as not recorded yet: faint, no number, and says so', () => {
+  const coming = docket([], { floors: I.PLAN.charter.floors.map((f) => floorRow(f[2].floor, { status: 'coming', count: '', lines: [], reason: 'Not yet.' })) });
+  const b = I.civicInfo('charter', { docket: coming, 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 });
+  assert.deepEqual(b.floors[1].lines, [['Not yet.', 'coming']], 'it says why, in the docket\'s words');
+  const bv = I.buildingModel({ key: 'charter', docket: coming, 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');
@@ -265,6 +269,96 @@ test('who holds it: the docket\'s holders when it names them, else an empty seat
   assert.deepEqual([held.seats, held.who, held.how], [['M'], 'Mira, treasurer', 'more than half must say yes']);
 });
 
+// ── real data on every floor (task 1004527) ─────────────────────────────────
+
+test('every floor of every building is bound to a docket feed: none is left unwired', () => {
+  for (const key of S.CIVIC_KEYS) {
+    for (const [name, , bind] of I.PLAN[key].floors) {
+      assert.ok(bind && (bind.floor || bind.source || bind.reading || bind.goals), `${key} · ${name} reads something`);
+    }
+  }
+});
+
+test('a live floor shows exactly what the docket says: its count, line and lines; hot is being decided', () => {
+  const d = docket([], { floors: [
+    floorRow('treasury.rewards', { count: '$2,400', line: '$2,400 this month · 6 builders', lines: [['Paid to builders for shipped work.', 'each ship']] }),
+    floorRow('automation.allowed_goals', { count: '2', line: '2 goals it may build', lines: [['goal 7', 'first in line'], ['goal 99', 'since sep 2']] }),
+    floorRow('charter.founding', { count: '', line: '1 of 2 founding steps passed', lines: [['The charter.', 'passed']], hot: true }),
+  ] });
+  const t = I.civicInfo('treasury', { docket: d, now: NOW }).floors.find((f) => f.name === 'Builder rewards');
+  assert.deepEqual([t.count, t.line, t.status, t.lines], ['$2,400', '$2,400 this month · 6 builders', 'ok', [['Paid to builders for shipped work.', 'each ship']]]);
+  const a = I.civicInfo('automation', { docket: d, goals: [goal(7, 'open', 'Onboarding')], now: NOW }).floors.find((f) => f.name === 'Allowed goals');
+  assert.deepEqual(a.lines, [['Onboarding', 'first in line'], ['goal 99', 'since sep 2']], 'a goal it knows is lettered by title; one it does not keeps its id');
+  const c = I.buildingModel({ key: 'charter', docket: d, mode: 'dark', now: NOW });
+  assert.equal(c.selFloor, 0, 'a founding step being decided is the floor chosen first');
+  assert.equal(c.openKicker, 'floor 1 · being decided');
+});
+
+test('Rules in force: each rule and what it settled, from its floor; the reading when the floor is absent', () => {
+  const d = docket([], { floors: [floorRow('rules.in_force', { count: '1', line: '1 rule · settled 18 this month', lines: [['Every filing lands in its goal without a vote.', 'settled 18']] })] });
+  const f = I.civicInfo('rules', { docket: d, now: NOW }).floors[0];
+  assert.deepEqual([f.count, f.line, f.lines[0]], ['1', '1 rule · settled 18 this month', ['Every filing lands in its goal without a vote.', 'settled 18']]);
+  const old = docket();
+  Object.assign(old.readings.find((r) => r.key === 'rules'), { status: 'live', figure: '1 rule', line: 'the landing rule settled 4 filings this month' });
+  assert.deepEqual(I.civicInfo('rules', { docket: old, now: NOW }).floors[0].count, '1', 'an older docket still reads the reading');
+  const h = I.holderOf('people', { decision: { who: 'metic', rule: 'consent' }, holders: [], holder_count: 3 }, []);
+  assert.equal(h.who, 'metic', 'a count with no names never letters undefined');
+});
+
+test('a floor the docket cannot answer never shows a number; Goals falls back to the open goals', () => {
+  const d = docket([], { floors: [floorRow('people.ranks', { status: 'not_yours', count: '9' }), floorRow('people.council', { status: 'off', count: '5', reason: 'Off here.' }), floorRow('people.newcomers', { status: 'unavailable', count: '2' })] });
+  const by = Object.fromEntries(I.civicInfo('people', { docket: d, now: NOW }).floors.map((f) => [f.name, f]));
+  for (const [n, st] of [['Ranks', 'not_yours'], ['The council', 'off'], ['Newcomers', 'unavailable'], ['Testers', 'unavailable']]) {
+    assert.deepEqual([by[n].status, by[n].count], [st, ''], `${n} says ${st} and no number`);
+  }
+  const g = I.civicInfo('planning', { docket: docket(), goals: [goal(1), goal(2)], now: NOW }).floors[0];
+  assert.deepEqual([g.count, g.line], ['2', '2 goals open'], 'an older docket without floors still counts the open goals');
+  const live = I.civicInfo('planning', { docket: docket([], { floors: [floorRow('planning.goals', { count: '1', line: '1 goal open', lines: [['Hall', '5 of 5 kept']] })] }), goals: [goal(1), goal(2)], now: NOW }).floors[0];
+  assert.deepEqual([live.count, live.lines], ['1', [['Hall', '5 of 5 kept']]], 'with the floor, its promises kept of total');
+});
+
+test('no made-up number: every count on every wall is one the docket sent', () => {
+  const ms = [matter({ id: 'access_requests:1', source: 'access_requests', building: 'people' })];
+  const floors = [floorRow('people.ranks', { count: '4' }), floorRow('treasury.hosting', { count: '$120' }), floorRow('release.live_month', { count: '7' })];
+  const d = docket(ms, { floors });
+  Object.assign(d.readings.find((r) => r.key === 'money'), { status: 'live', figure: '$1,100 left', line: 'left' });
+  const sent = new Set(['', ...floors.map((f) => f.count), '1', '0', '$1,100']);
+  for (const key of S.CIVIC_KEYS) {
+    for (const f of I.civicInfo(key, { docket: d, goals: [], now: NOW }).floors) assert.ok(sent.has(f.count), `${key} · ${f.name} shows ${f.count}`);
+  }
+});
+
+test('who holds it reads the decision table: the people it seats, its rule, you, and a vacant seat', () => {
+  const info = { key: 'release', decision: { who: 'whoever may put a release live', rule: 'decide', rule_words: 'decides alone', as_today: true }, holders: [{ id: '95', name: 'Ana' }, { id: '7', login: 'theo' }], holder_count: 2 };
+  const h = I.holderOf('release', info, [], '95');
+  assert.deepEqual([h.seats, h.who, h.rule, h.how], [['you', 'T'], 'Ana and theo · whoever may put a release live', 'decide', 'one person decides']);
+  const many = I.holderOf('people', { decision: { who: 'metic and above', rule: 'consent' }, holders: [{ name: 'A' }, { name: 'B' }, { name: 'C' }], holder_count: 7 }, []);
+  assert.equal(many.who, 'A, B, C and 4 more · metic and above');
+  const vacant = I.holderOf('review', { decision: { who: 'no one yet', rule: 'vacant' }, holders: [] }, []);
+  assert.deepEqual([vacant.seats, vacant.who, vacant.how], [['—'], 'no one holds it yet', 'its matters wait until a seat is filled']);
+  const d = docket();
+  d.buildings.find((b) => b.key === 'review').decision = { who: 'no one yet', rule: 'vacant' };
+  assert.equal(I.civicInfo('review', { docket: d, now: NOW }).vacant, true, 'a vacant row is an unheld Review');
+  const held = I.civicInfo('review', { docket: docket(), now: NOW });
+  assert.deepEqual(held.floors.map((f) => f.name), ['Testers', 'Being tested', 'Signed off'], 'held, its queue is the prototype\'s Being tested');
+});
+
+test('the record drawers read the real history by month, file a sitting once, and cap a full drawer', () => {
+  const history = [
+    { id: 'government:amendment:12', source: 'government', building: 'charter', title: '§6 Review: testers hold the seat', at: '2026-10-01T09:00:00.000Z', outcome: 'passed' },
+    { id: 'government:founding:3', source: 'government', building: 'charter', title: 'Founding: the charter', at: '2026-07-04T09:00:00.000Z', outcome: 'passed' },
+    { id: 'releases:9', source: 'releases', building: 'release', title: 'Invite flow', at: '2026-09-26T09:00:00.000Z', outcome: 'live' },
+  ];
+  const ms = [matter({ id: 'board:12', source: 'board', building: 'charter', state: 'settled', title: '§6 Review: testers hold the seat', ref: { type: 'board_item', id: '12' }, opened_at: '2026-09-28T00:00:00.000Z' })];
+  const m = I.buildingModel({ key: 'charter', docket: docket(ms, { history }), mode: 'dark', now: NOW });
+  assert.deepEqual(m.drawers.map((x) => [x.label, x.count]), [['oct', 1], ['jul', 1]], 'the settled sitting is filed once, by when it closed');
+  assert.deepEqual(m.drawerItems.map((x) => [x.text, x.meta]), [['§6 Review: testers hold the seat', 'passed']]);
+  assert.equal(m.onFile, '1 matter on the docket · 2 on the record');
+  const lots = Array.from({ length: 15 }, (_, i) => ({ id: `releases:${i}`, building: 'release', title: `R${i}`, at: '2026-09-02T00:00:00.000Z', outcome: 'live' }));
+  const r = I.recordOf([], NOW, lots);
+  assert.deepEqual([r[0].count, r[0].items.length, r[0].items[12]], [15, 13, ['and 3 more', '']]);
+});
+
 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;
@@ -475,8 +569,10 @@ test('picking a floor moves the SAME lift node and re-enters the chosen block; d
   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/);
+  await new Promise((r) => setTimeout(r, 0));
+  // the draft itself is tests/hall_street_amend.mjs (task 1004530); with no constitution to read it says so, never nothing
+  assert.equal(p.byId.get('insideAmendNote').hidden, false, 'change how this works answers, rather than nothing');
+  assert.match(p.byId.get('insideAmendNote').textContent, /could not be read/);
 });
 
 test('a table row opens the short card; Escape gives focus back to the row; back to the street returns to the door', async () => {

package/tests/rank_tier_single_source.mjs

@@ -124,6 +124,11 @@ const STATIC_LADDER_FILES = [
   // match the canonical order or the example teaches a ladder that does not
   // exist.
   'modules/hall-ui/public/government.js',
+  // task 1004530: the street's drafted amendment offers the rank ladder as the
+  // seats a building can be handed to (rank:<key>+). Browser code, so a mirror;
+  // tests/hall_street_amend.mjs pins GovAmend.RANKS equal to the server's
+  // membership-predicate RANK_ORDER.
+  'modules/hall-ui/public/street-amend.js',
   // task 1002487: the pure agent-definition validator applies the ADR 0043
   // sub-Metic floor to an agent's declared scope, so it needs the ladder to
   // compare against. It is one of the "dependency-free" cases this array exists