@bongos/core 1.20.47 → 1.20.49

package/tests/founding_mode.mjs

@@ -0,0 +1,294 @@
+// tests/founding_mode.mjs — PROJECT FOUNDING MODE is a mode the existing hall wears,
+// never a second hall (task 1004422 / BV2.PS03, goal 1000121; the blend rule in
+// docs/design/project-startup-direction.md).
+//
+// The owner's no-hijack condition is the headline: a hall that is NOT founding must be
+// the hall it was. So the client half is RUN, not grepped. The real applyFounding is
+// sliced out of shell.js and driven over a small fake DOM, fed by the REAL server
+// shaper, so the path from the stored stage to the dimmed nav item is exercised
+// whole. Then OFF is proven to leave, and to restore, the DOM exactly.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8').replace(/\r\n/g, '\n');
+const fm = require(path.join(ROOT, 'modules', 'onboarding', 'founding-mode.js'));
+
+const SHELL = read('modules', 'hall-ui', 'public', 'shell.js');
+const HALL_RENDER = read('modules', 'hall-ui', 'public', 'hall-render.js');
+const ME = read('src', 'bongos', 'routes', 'me.js');
+const PORT = read('modules', 'onboarding', 'port.js');
+
+// ── the server shaper (pure) ────────────────────────────────────────────────
+
+test('not founding in any form is null (OFF)', () => {
+  assert.equal(fm.shapeFoundingMode(null), null);
+  assert.equal(fm.shapeFoundingMode({ active: null }), null);
+  assert.equal(fm.shapeFoundingMode({ active: 'false', stage: 'scope' }), null);
+  assert.equal(fm.shapeFoundingMode({ active: 'maybe', stage: 'scope' }), null);
+});
+
+test('an unknown stage fails CLOSED — OFF, never a hall stuck half-asleep', () => {
+  assert.equal(fm.shapeFoundingMode({ active: 'true', stage: 'launch' }), null);
+});
+
+test('active with no stage yet is the decide pre-stage, and every room sleeps', () => {
+  const f = fm.shapeFoundingMode({ active: 'true' });
+  assert.equal(f.stage, 'decide');
+  assert.equal(f.stage_number, 0);
+  assert.equal(f.stage_count, 5);
+  for (const id of ['roadmap', 'goals', 'goal-map', 'work', 'board-room', 'economy', 'ranks', 'collab', 'roster']) {
+    assert.ok(id in f.asleep, `${id} sleeps while deciding`);
+  }
+});
+
+test('a room wakes once the stage that wakes it is behind', () => {
+  const f = fm.shapeFoundingMode({ active: 'true', stage: 'charter' });
+  for (const id of ['roadmap', 'goals', 'goal-map', 'work']) assert.ok(!(id in f.asleep), `${id} woke`);
+  assert.equal(f.asleep['board-room'], 'charter');
+  assert.equal(f.asleep.economy, 'legalize');
+  assert.equal(f.asleep.ranks, 'legislation');
+  assert.equal(f.asleep.collab, 'alive', 'community wakes only when the planet is alive');
+});
+
+test('the day counts from the founding day; an unreadable timestamp drops it', () => {
+  const now = new Date('2026-10-09T12:00:00Z');
+  assert.equal(fm.dayOf('2026-10-01T09:00:00Z', now), 9);
+  assert.equal(fm.dayOf('not a date', now), null);
+  assert.equal(fm.dayOf(null, now), null);
+});
+
+test('foundingModeFor fails closed when the settings read throws', async () => {
+  const got = await fm.foundingModeFor({ getSetting: async () => { throw new Error('db down'); } });
+  assert.equal(got, null);
+});
+
+test('setFoundingMode refuses an unknown stage and stamps started_at once', async () => {
+  const store = new Map();
+  const deps = {
+    getSetting: async (k) => (store.has(k) ? { key: k, value: store.get(k) } : null),
+    setSetting: async (k, v) => { store.set(k, String(v)); return { key: k, value: String(v) }; },
+    now: new Date('2026-10-01T00:00:00Z'),
+  };
+  await assert.rejects(fm.setFoundingMode({ stage: 'launch' }, 1, deps), /unknown founding stage/);
+  const first = await fm.setFoundingMode({ active: true, stage: 'decide' }, 1, deps);
+  assert.equal(first.stage, 'decide');
+  const stamp = store.get(fm.KEYS.STARTED_AT);
+  deps.now = new Date('2026-10-05T00:00:00Z');
+  await fm.setFoundingMode({ active: true, stage: 'scope' }, 1, deps);
+  assert.equal(store.get(fm.KEYS.STARTED_AT), stamp, 'started_at is not re-stamped');
+  assert.equal(await fm.setFoundingMode({ active: false }, 1, deps), null, 'switching off reads back as OFF');
+});
+
+test('every room the server can put to sleep is a real NAV item', () => {
+  // The map is keyed by NAV id so the client never re-derives it; a renamed NAV id
+  // would silently leave a room awake. Hold the two together.
+  const nav = SHELL.slice(SHELL.indexOf('var NAV = ['), SHELL.indexOf('var NAV_COLLAPSE_KEY'));
+  const ids = new Set([...nav.matchAll(/id: '([a-z-]+)'/g)].map((m) => m[1]));
+  const all = [...Object.values(fm.WAKES).flat(), ...fm.WAKES_WHEN_ALIVE];
+  for (const id of all) assert.ok(ids.has(id), `NAV has no item '${id}'`);
+});
+
+// ── the client, RUN over a fake DOM ─────────────────────────────────────────
+
+class El {
+  constructor(tag) {
+    this.tag = tag; this.id = ''; this.className = ''; this.dataset = {}; this.attrs = {};
+    this.children = []; this.parent = null; this.textContent = ''; this.innerHTML = '';
+    const self = this;
+    this.classList = {
+      add(c) { const s = new Set(self.className.split(' ').filter(Boolean)); s.add(c); self.className = [...s].join(' '); },
+      remove(c) { self.className = self.className.split(' ').filter((x) => x && x !== c).join(' '); },
+      contains(c) { return self.className.split(' ').includes(c); },
+    };
+  }
+  appendChild(c) { c.parent = this; this.children.push(c); return c; }
+  insertBefore(c, ref) { c.parent = this; const i = this.children.indexOf(ref); this.children.splice(i < 0 ? 0 : i, 0, c); return c; }
+  get parentNode() { return this.parent; }
+  removeChild(c) { this.children = this.children.filter((x) => x !== c); c.parent = null; return c; }
+  setAttribute(k, v) { this.attrs[k] = v; }
+  querySelector(sel) { return sel === '[data-wakes-tag]' ? (this.children.find((c) => 'data-wakes-tag' in c.attrs) || null) : null; }
+  get firstChild() { return this.children[0] || null; }
+}
+
+function makeHall() {
+  const navIds = ['home', 'roadmap', 'goals', 'goal-map', 'work', 'board-room', 'economy', 'ranks', 'collab', 'roster', 'profile'];
+  const nav = navIds.map((id) => { const a = new El('a'); a.id = 'nav-' + id; a.className = 'nav-item'; return a; });
+  const appBody = new El('div');
+  const topbar = new El('header'); topbar.id = 'app-topbar';
+  appBody.appendChild(topbar);
+  const root = { dataset: {} };
+  const document = {
+    documentElement: root,
+    createElement: (t) => new El(t),
+    querySelector: (sel) => (sel === '.app-body' ? appBody : null),
+    querySelectorAll: (sel) => (sel === '#app-sidebar .nav-item--asleep' ? nav.filter((a) => a.classList.contains('nav-item--asleep')) : []),
+    getElementById: (id) => nav.find((a) => a.id === id) || appBody.children.find((c) => c.id === id) || null,
+  };
+  return { document, nav, appBody, root };
+}
+
+// The REAL escaper and the real wake map are sliced out of shell.js with the function,
+// so the band's escaping is the shell's own, not a stand-in that agrees with the test.
+function sliceFn(name) {
+  const start = SHELL.indexOf('  function ' + name + '(');
+  const end = SHELL.indexOf('\n  }\n', start);
+  assert.ok(start > -1 && end > start, name + ' was located in shell.js');
+  return SHELL.slice(start, end + 4);
+}
+function loadApplyFounding(document, access, brand = { identity: { productName: 'Kestrel' } }) {
+  const wakeStart = SHELL.indexOf('  var WAKE_TEXT = {');
+  const wakeEnd = SHELL.indexOf('};', wakeStart) + 2;
+  assert.ok(wakeStart > -1, 'WAKE_TEXT was located in shell.js');
+  const src = [SHELL.slice(wakeStart, wakeEnd), sliceFn('esc'), sliceFn('applyFounding')].join('\n');
+  return new Function('document', 'brand', 'access', `${src}\nreturn applyFounding;`)(document, brand, access);
+}
+
+const snapshot = (h) => JSON.stringify({
+  root: h.root.dataset,
+  body: h.appBody.children.map((c) => c.id),
+  nav: h.nav.map((a) => ({ id: a.id, cls: a.className, data: a.dataset, kids: a.children.length })),
+});
+
+test('THE NO-HIJACK CONDITION: a hall that is not founding is untouched', () => {
+  const h = makeHall();
+  const before = snapshot(h);
+  const access = { founding: null };
+  loadApplyFounding(h.document, access)();
+  assert.equal(snapshot(h), before, 'null founding changes nothing at all');
+});
+
+test('not founding touches NO node — the document is never even queried', () => {
+  // Stronger than "ends up the same": a page that never wore the mode is not read.
+  const h = makeHall();
+  const touched = [];
+  const spy = new Proxy(h.document, {
+    get(t, k) { if (k !== 'documentElement') touched.push(String(k)); return t[k]; },
+  });
+  loadApplyFounding(spy, { founding: null })();
+  loadApplyFounding(spy, { founding: { active: false } })();
+  assert.deepEqual(touched, [], 'no DOM method was called');
+});
+
+test('founding ON: the band above the topbar, and the rooms the server named asleep', () => {
+  const h = makeHall();
+  const now = new Date('2026-10-09T12:00:00Z');
+  const access = { founding: fm.shapeFoundingMode({ active: 'true', stage: 'strategize', startedAt: '2026-10-01T09:00:00Z' }, now) };
+  loadApplyFounding(h.document, access)();
+  assert.equal(h.root.dataset.founding, 'on');
+  const band = h.appBody.children[0];
+  assert.equal(band.id, 'founding-band', 'the band is the first child of .app-body, above the topbar');
+  assert.equal(h.appBody.children[1].id, 'app-topbar', 'the topbar itself is kept, not replaced');
+  assert.match(band.innerHTML, /Project founding mode/);
+  assert.match(band.innerHTML, /Kestrel is still being founded/);
+  assert.match(band.innerHTML, /stage 2 of 5 · strategize · day 9/);
+  const byId = (id) => h.nav.find((a) => a.id === 'nav-' + id);
+  assert.ok(!byId('goals').classList.contains('nav-item--asleep'), 'scope is behind: goals is awake');
+  assert.ok(byId('work').classList.contains('nav-item--asleep'), 'strategize is current: tasks still sleeps');
+  assert.equal(byId('work').children[0].textContent, 'opens after strategy', 'a sentence, never a raw slug');
+  assert.equal(byId('collab').children[0].textContent, 'opens when alive');
+  assert.ok(!byId('home').classList.contains('nav-item--asleep'), 'home is never put to sleep');
+});
+
+test('founding OFF after ON restores the hall exactly — OFF removes, it does not hide', () => {
+  const h = makeHall();
+  const before = snapshot(h);
+  const access = { founding: fm.shapeFoundingMode({ active: 'true', stage: 'decide' }) };
+  const apply = loadApplyFounding(h.document, access);
+  apply();
+  assert.notEqual(snapshot(h), before);
+  access.founding = null;
+  apply();
+  assert.equal(snapshot(h), before, 'band, asleep classes, wake tags and the root attribute are all gone');
+});
+
+test('the band escapes what it prints — a project name cannot inject markup', () => {
+  const h = makeHall();
+  const access = { founding: Object.assign(fm.shapeFoundingMode({ active: 'true', stage: 'scope' }), { waiting_on: ['<img src=x onerror=1>'] }) };
+  loadApplyFounding(h.document, access, { identity: { productName: '<script>alert(1)</script>' } })();
+  const html = h.appBody.children[0].innerHTML;
+  assert.ok(!html.includes('<script>'), 'the name is escaped');
+  assert.ok(!html.includes('<img'), 'the waiting-on names are escaped');
+  assert.match(html, /&lt;script&gt;/);
+});
+
+test('who the stage close is waiting on shows in the band when the server sends it', async () => {
+  const f = await fm.foundingModeFor({
+    getSetting: async (k) => ({ [fm.KEYS.ACTIVE]: { value: 'true' }, [fm.KEYS.STAGE]: { value: 'charter' } }[k] || null),
+    waitingOnFor: async (stage) => (stage === 'charter' ? ['Avery', 'Jordan'] : []),
+  });
+  assert.deepEqual(f.waiting_on, ['Avery', 'Jordan']);
+  const h = makeHall();
+  loadApplyFounding(h.document, { founding: f })();
+  assert.match(h.appBody.children[0].innerHTML, /waiting on Avery, Jordan/);
+});
+
+test('waiting-on reads the government port\'s genesis-stage status, sitting stages only', async () => {
+  const gov = {
+    genesisStageStatus: async () => ({ stages: [
+      { key: 'scope', state: 'passed', waiting_on: [] },
+      { key: 'charter', state: 'sitting', waiting_on: [{ display_name: 'Avery' }, { github_login: 'jordan' }] },
+      { key: 'legalize', state: 'not_put', waiting_on: [] },
+    ] }),
+  };
+  const read = (stage) => fm.foundingModeFor({
+    getSetting: async (k) => ({ [fm.KEYS.ACTIVE]: { value: 'true' }, [fm.KEYS.STAGE]: { value: stage } }[k] || null),
+    government: gov,
+  });
+  assert.deepEqual((await read('charter')).waiting_on, ['Avery', 'jordan']);
+  assert.equal((await read('scope')).waiting_on, null, 'a passed stage waits on nobody');
+  assert.equal(fm.waitingOnFromGovernment({}), null, 'a port without the read offers none');
+  assert.equal((await fm.foundingModeFor({
+    getSetting: async (k) => ({ [fm.KEYS.ACTIVE]: { value: 'true' } }[k] || null), government: null,
+  })).waiting_on, null, 'no government module: the mode still reads, without names');
+});
+
+test('a failing waiting-on source never turns the mode off', async () => {
+  const f = await fm.foundingModeFor({
+    getSetting: async (k) => ({ [fm.KEYS.ACTIVE]: { value: 'true' }, [fm.KEYS.STAGE]: { value: 'scope' } }[k] || null),
+    waitingOnFor: async () => { throw new Error('government down'); },
+  });
+  assert.equal(f.active, true);
+  assert.equal(f.waiting_on, null);
+});
+
+test('re-applying ON does not stack a second band or duplicate wake tags', () => {
+  const h = makeHall();
+  const access = { founding: fm.shapeFoundingMode({ active: 'true', stage: 'decide' }) };
+  const apply = loadApplyFounding(h.document, access);
+  apply(); apply();
+  assert.equal(h.appBody.children.filter((c) => c.id === 'founding-band').length, 1);
+  assert.equal(h.nav.find((a) => a.id === 'nav-work').children.length, 1);
+});
+
+// ── the wiring ──────────────────────────────────────────────────────────────
+
+test('only an explicit active:true turns the mode on', () => {
+  const fn = SHELL.slice(SHELL.indexOf('  function applyFounding()'));
+  assert.match(fn.slice(0, 400), /f && f\.active === true/);
+});
+
+test('/me carries founding_mode from the onboarding port, fail-open to null', () => {
+  assert.match(ME, /founding_mode: foundingMode/);
+  assert.match(ME, /onboarding\.foundingModeFor\(\)/);
+  const at = ME.indexOf('onboarding.foundingModeFor()');
+  assert.match(ME.slice(at, at + 200), /catch \(_\) \{ return null; \}/);
+  assert.match(PORT, /foundingModeFor: \(\.\.\.a\) => foundingMode\.foundingModeFor\(\.\.\.a\)/);
+});
+
+test('BOTH applyAccess callers pass it, or the index would never show the band', () => {
+  assert.match(SHELL, /founding: me\.founding_mode \|\| null/);
+  assert.match(HALL_RENDER, /founding: \(ctx\.lastMeState && ctx\.lastMeState\.founding_mode\) \|\| null/);
+});
+
+test('founding mode adds no page, no route and no nav item — it is a mode', () => {
+  const nav = SHELL.slice(SHELL.indexOf('var NAV = ['), SHELL.indexOf('var NAV_COLLAPSE_KEY'));
+  assert.ok(!/founding|genesis/i.test(nav), 'the NAV model must not grow a founding entry');
+  const hall = fs.readdirSync(path.join(ROOT, 'modules', 'hall-ui', 'public'));
+  assert.ok(!hall.some((f) => /^founding\./.test(f)), 'no founding page file');
+});