@bongos/core 1.20.75 → 1.20.77

package/tests/profile_role_headline.mjs

@@ -0,0 +1,201 @@
+// tests/profile_role_headline.mjs — the profile's header and "By the numbers"
+// lead with each person's own craft (task 1004434 / WA6.RP04, goal 1000095,
+// criterion wa6-roles-read-true-in-public).
+//
+// The done-when: "engineer, artist and ideator fixtures each render their own
+// headline, matching the mock". Three layers, each run for real:
+//
+//   1. The words. profile-roles.js (pure) over the three harness fixtures the
+//      renders were taken from: each craft's tally, tiles and subtitle.
+//   2. The page. The REAL profile.js in a vm, with the REAL hall kit, over the
+//      same fixtures: what lands in the header, the numbers and the subtitle.
+//   3. The whole path. The REAL server reader (src/bongos/role-stats.js) with
+//      the three role ports stubbed, through JSON, into the REAL page, so a field
+//      the server renames or drops cannot leave this suite green on a fixture
+//      that still carries it.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const FIX = (n) => JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures', n + '.json'), 'utf8'));
+
+const { headline } = require('../modules/hall-ui/public/profile-roles.js');
+const OTBKit = require('../modules/hall-ui/public/hall-kit.js');
+const ROLES_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile-roles.js'), 'utf8');
+const PAGE_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile.js'), 'utf8');
+
+const ENGINEER = FIX('builders__profile');
+const ARTIST = FIX('builders__2001__profile');
+const IDEATOR = FIX('builders__2002__profile');
+const OPTS = { fmt: (n) => Number(n).toLocaleString('en-US'), currency: 'credits', rank: 'Contributor' };
+const words = (items) => items.map((t) => `${t.n} ${t.w}`);
+
+const { test, summary } = makeRunner();
+
+// ---- 1. the words --------------------------------------------------------
+
+await test('an engineer leads with works shipped, and keeps karma', () => {
+  const v = headline(ENGINEER, OPTS);
+  assert.deepEqual(words(v.tally), ['4,630 credits', '24 works shipped', '1 karma']);
+  assert.deepEqual(words(v.tiles).slice(0, 4), ['24 works shipped', '4,630 credits', '1 karma', '2 achievements']);
+  assert.equal(v.sub, 'Builder 4 — Contributor · 24 works shipped');
+  assert.deepEqual(v.surfaces, [], 'the per-surface rows are the artist\'s');
+});
+
+await test('an artist who never shipped a task leads with pages approved and the per-surface share', () => {
+  const v = headline(ARTIST, OPTS);
+  assert.deepEqual(words(v.tally), ['412 credits', '9 pages approved', '+38 this week']);
+  assert.deepEqual(words(v.tiles), ['9 pages approved', '270 credits from pages', '+38 this week', '4 thoughts filed', '6 karma']);
+  assert.equal(v.tiles[0].f, '3 surfaces');
+  assert.equal(v.sub, 'Builder 7 — Contributor · 9 pages approved');
+  assert.ok(!v.sub.includes('works shipped'), 'the subtitle no longer says works shipped for an artist');
+  assert.deepEqual(v.surfaces.map((s) => s.line), ['6 of 12 tweaked', '2 of 19 tweaked', '1 of 6 tweaked']);
+  assert.ok(!words(v.tiles).some((w) => /works shipped/.test(w)), 'no engineer figure on an artist\'s numbers');
+  assert.equal(words(v.tiles).at(-1), '6 karma', 'karma ends every non-engineer set (the owner, 2026-10-01)');
+});
+
+await test('an ideator leads with thoughts, size and what is still alive', () => {
+  const v = headline(IDEATOR, OPTS);
+  assert.deepEqual(words(v.tally), ['186 credits', '31 thoughts filed', '7 ignited']);
+  assert.deepEqual(words(v.tiles), ['31 thoughts filed', '7 ignited', '3 Full Ideas', '186~ total size', '72% still alive', '3 karma']);
+  assert.equal(v.tiles[2].f, '1 ratified by the board');
+  assert.match(v.tiles[3].title, /Includes 24 credits of historical estimate/, 'the ~ says what it means');
+  assert.equal(v.sub, 'Builder 9 — Contributor · 31 thoughts filed');
+});
+
+await test('several crafts each show, main first, in the server\'s order', () => {
+  assert.deepEqual(headline(ARTIST, OPTS).crafts.map((c) => c.label), ['Artist, main role', 'Ideator']);
+  assert.deepEqual(headline(ENGINEER, OPTS).crafts.map((c) => c.label), ['Engineer, main role', 'Ideator']);
+  // The other craft adds its one headline tile after the main craft's set.
+  assert.equal(words(headline(ENGINEER, OPTS).tiles).at(-1), '9 thoughts filed');
+  const reordered = { ...ARTIST, roles: { ...ARTIST.roles, main: 'ideator', shown: ['ideator', 'artist'] } };
+  const v = headline(reordered, OPTS);
+  assert.deepEqual(v.crafts.map((c) => c.label), ['Ideator, main role', 'Artist']);
+  assert.equal(words(v.tiles).at(-2), '9 pages approved', 'the other craft\'s tile, just before karma');
+  assert.deepEqual(v.surfaces, [], 'the per-surface rows follow the MAIN craft, not any craft');
+});
+
+await test('a number the instance could not read is a dash, never a zero', () => {
+  const noDesk = { ...ARTIST, roles: { ...ARTIST.roles, artist: { pages_approved: null, credits: null, this_week: null, surfaces_touched: null, surfaces: [], unavailable: true } } };
+  const v = headline(noDesk, OPTS);
+  assert.deepEqual(words(v.tally).slice(1), ['— pages approved', '— this week']);
+  assert.equal(v.tiles[0].f, '', 'no "0 surfaces" under an unknown count');
+  const noWork = { ...IDEATOR, roles: { ...IDEATOR.roles, ideator: { ...IDEATOR.roles.ideator, alive: { share: null, has_work: false, attributable: null } } } };
+  assert.deepEqual(headline(noWork, OPTS).tiles.at(-2), { n: '—', w: 'still alive', f: 'nothing has come of them yet' });
+  const untraced = { ...IDEATOR, roles: { ...IDEATOR.roles, ideator: { ...IDEATOR.roles.ideator, alive: { share: null, has_work: true, attributable: false } } } };
+  assert.equal(headline(untraced, OPTS).tiles.at(-2).f, 'not measurable yet');
+});
+
+await test('a response from before the roles block reads as the engineer it always was', () => {
+  const { roles, ...old } = ENGINEER;
+  const v = headline(old, OPTS);
+  assert.deepEqual(v.crafts.map((c) => c.label), ['Engineer, main role']);
+  assert.equal(v.sub, 'Builder 4 — Contributor · 24 works shipped');
+});
+
+// ---- 2. the page ---------------------------------------------------------
+
+async function boot(profileData) {
+  const els = new Map();
+  const makeEl = () => ({
+    hidden: false, textContent: '', _html: '', dataset: {}, style: {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+    insertAdjacentHTML() {}, addEventListener() {}, setAttribute() {}, querySelector: () => null, querySelectorAll: () => [],
+    classList: { add() {}, remove() {}, toggle() {} },
+  });
+  const $ = (sel) => { if (!els.has(sel)) els.set(sel, makeEl()); return els.get(sel); };
+  const escapeHtml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  const json = JSON.parse(JSON.stringify(profileData)); // what the wire carries
+  const api = {
+    async request(_m, url) {
+      if (url === '/api/bongos/me') return { status: 401, ok: false, data: null };
+      if (/\/builders\/[^/]+\/profile$/.test(url)) return { status: 200, ok: true, data: json };
+      return { status: 404, ok: false, data: null };
+    },
+  };
+  const windowObj = {
+    __BRANDING__: { currency: { label: 'credits' } },
+    __MODULES__: { responsibilities: { engineer: 'E.', artist: 'A.', ideator: 'I.' } },
+    BongosClient: { createClient: () => api },
+    // The real kit draws the surface bars; the section rail needs a real DOM and
+    // is not what this suite is about, so it is left out (profile.js skips it).
+    OTBKit: { ...OTBKit, makeSectionRail: undefined },
+    OTB: {
+      $, escapeHtml,
+      fmtNum: (n) => Number(n || 0).toLocaleString('en-US'),
+      fmtDate: (d) => String(d).slice(0, 10),
+      rankLabel: () => 'Contributor',
+      roleAxisLabel: () => 'Role', roleLabel: (d) => d, roleIsUnset: (d) => !d, toast() {},
+    },
+  };
+  const sandbox = {
+    window: windowObj, location: { search: '?id=' + profileData.builder.id, hash: '' }, URLSearchParams, console,
+    document: { querySelector: () => null, querySelectorAll: () => [], addEventListener() {} },
+    addEventListener() {}, history: { replaceState() {} },
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(ROLES_SRC, sandbox, { filename: 'profile-roles.js' });
+  vm.runInContext(PAGE_SRC, sandbox, { filename: 'profile.js' });
+  for (let i = 0; i < 6; i++) await new Promise((r) => setImmediate(r));
+  return { head: $('#profile-head').innerHTML, nums: $('#numbers-body').innerHTML, sub: $('#profile-sub').textContent };
+}
+const text = (html) => html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+
+await test('the real page draws the artist\'s tally, chips, tiles and surface rows', async () => {
+  const p = await boot(ARTIST);
+  assert.equal(p.sub, 'Builder 7 — Contributor · 9 pages approved');
+  assert.match(text(p.head), /Artist, main role Ideator/);
+  assert.match(text(p.head), /412 credits 9 pages approved \+38 this week/);
+  assert.match(p.head, /Answerable for:/, 'the responsibility line stays');
+  assert.match(text(p.nums), /^9 pages approved 3 surfaces 270 credits from pages \+38 this week 4 thoughts filed 1 ignited/);
+  assert.equal((p.nums.match(/kit-bars__row/g) || []).length, 3, 'one kit bar row per surface');
+  assert.match(text(p.nums), /Landing 6 of 12 tweaked/);
+  assert.ok(!/works shipped/i.test(p.sub + p.head + p.nums), 'nothing on an artist\'s header says works shipped');
+});
+
+await test('the real page draws the ideator\'s and the engineer\'s own headlines', async () => {
+  const i = await boot(IDEATOR);
+  assert.match(text(i.head), /186 credits 31 thoughts filed 7 ignited/);
+  assert.match(text(i.nums), /186~ total size/);
+  assert.match(text(i.nums), /72% still alive/);
+  assert.ok(!i.nums.includes('kit-bars'), 'no surface rows for an ideator');
+  const e = await boot({ ...ENGINEER, recent_ships: [] }); // the works ledger is not this suite's
+  assert.equal(e.sub, 'Builder 4 — Contributor · 24 works shipped');
+  assert.match(text(e.head), /4,630 credits 24 works shipped 1 karma/);
+});
+
+// ---- 3. the whole path ----------------------------------------------------
+
+await test('the server\'s roles block, through JSON, renders the artist\'s headline', async () => {
+  const seams = require('../src/module-seams.js');
+  const { readRoleStats } = require('../src/bongos/role-stats.js');
+  seams._reset();
+  seams.registerProvider('reward', {
+    craftForPreference: (d) => ({ engineer: 'engineer', artist: 'artist', ui: 'artist', ideator: 'ideator' }[d] || null),
+    async creditsByCraft(ids) { return new Map([[String(ids[0]), { engineer: 0, artist: 370, ideator: 42, other: 0, total: 412 }]]); },
+  });
+  seams.registerProvider('copy-desk.artistStats', async () => ARTIST.roles.artist);
+  seams.registerProvider('ideas.ideatorStats', async () => ARTIST.roles.ideator);
+  const roles = await readRoleStats('2001', {
+    shippedCount: 0,
+    getRoleChoice: async () => ({ main_discipline: 'artist', preferred_disciplines: ['artist', 'ideator'] }),
+  });
+  seams._reset();
+  const { roles: _fixture, ...rest } = ARTIST;
+  const p = await boot({ ...rest, roles });
+  assert.equal(p.sub, 'Builder 7 — Contributor · 9 pages approved');
+  assert.match(text(p.head), /Artist, main role Ideator/);
+  assert.match(text(p.head), /412 credits 9 pages approved \+38 this week/);
+  assert.equal((p.nums.match(/kit-bars__row/g) || []).length, 3);
+});
+
+summary();

package/tests/profile_ui_cross_project.mjs

@@ -29,6 +29,7 @@ import { fileURLToPath } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile.js'), 'utf8');
+const ROLES_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile-roles.js'), 'utf8');
 const HTML = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile.html'), 'utf8');
 
 // ---- fixtures -------------------------------------------------------------
@@ -98,6 +99,8 @@ async function boot({ search = '', me, profile } = {}) {
   };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
+  // The header is drawn from profile-roles.js (task 1004434), loaded first as the page does.
+  vm.runInContext(ROLES_SRC, sandbox, { filename: 'profile-roles.js' });
   vm.runInContext(SRC, sandbox, { filename: 'profile.js' });
   // load() is fire-and-forget; let its await chain settle.
   for (let i = 0; i < 4; i++) await new Promise((r) => setImmediate(r));

package/tests/projects_hub_app_step.mjs

@@ -114,7 +114,10 @@ function load({ draft = {}, answers = {} } = {}) {
   const watches = [];
   const ctx = { root, state, $, document, Object, API: '/api/bongos', fetch, JSON, String, Number, encodeURIComponent, Array, saveDraft: () => saves.push(JSON.stringify(state)),
     // the shared status watch (task 1004353) lives outside this block; record that it is started
-    watchApp: (id, box) => { watches.push({ id, box }); return () => {}; } };
+    watchApp: (id, box) => { watches.push({ id, box }); return () => {}; },
+    // the planet-physics step skip (task 1004419) lives outside this block too; the
+    // framing that skips this step is wizard_physics_more.mjs's to test
+    physStepSkipped: () => false };
   vm.createContext(ctx);
   vm.runInContext(ESC + '\n' + APPEL + '\n' + CONNECT + '\n' + BLOCK + '\nthis.api = { appPlatformChoice, syncAppStep, appRow, syncRenderSetup, validateRender, renderRequestBody, sendRenderSetup, planLabel };', ctx);
   const api = ctx.api;

package/tests/provisioning_planet_physics.mjs

@@ -24,7 +24,7 @@ import { createRequire } from 'node:module';
 import http from 'node:http';
 // ESM named imports off the CJS modules on purpose — knip cannot trace a
 // createRequire() import (the tests/provisioning_module_selection.mjs note).
-import { EU_COUNTRIES, COUNTRY_CODES, REGION_CODES, crossAnswerFault }
+import { EU_COUNTRIES, COUNTRY_CODES, REGION_CODES, crossAnswerFault, canonicalAnswer as physicsCanonical }
   from '../modules/provisioning/planet-physics.js';
 import { SOFT_LIMIT_RULES, EFFECTS, softLimitsFor } from '../modules/provisioning/soft-limits.js';
 import { SCREENING_RULES, STOP_MESSAGE, screenProject } from '../modules/provisioning/screening.js';
@@ -164,7 +164,11 @@ await t('every rule carries a reason, a known effect, and names only real questi
       const q = provisioning.PROJECT_DETAIL_QUESTIONS[key];
       assert.ok(q, `${rule.id}: ${key} is a question`);
       const named = test.in || [test.has ?? test.lacks];
-      for (const v of named) assert.ok(q.values.includes(v), `${rule.id}: ${key}=${v} is a real answer`);
+      // a count question has a range, not a list (task 1004419's solo rule)
+      for (const v of named) {
+        const real = q.kind === 'count' ? physicsCanonical(q, v) !== undefined : q.values.includes(v);
+        assert.ok(real, `${rule.id}: ${key}=${v} is a real answer`);
+      }
     }
   }
 });
@@ -221,6 +225,24 @@ await t('the table hides whole questions too: a new planet has no existing work,
   assert.ok(!opts({ framing: 'hybrid' }).includes('services'));
 });
 
+await t('rewards are hidden for a founder building alone with nobody expected, and only then (task 1004419)', () => {
+  const hidden = (answers) => softLimitsFor(answers).limits.some((l) => l.option === 'reward_intents' && l.effect === 'hide');
+  assert.equal(hidden({ builders_at_start: 1, builders_expected: 1 }), true, 'solo');
+  assert.equal(hidden({ builders_at_start: 1, builders_expected: 4 }), false, 'alone now, company expected');
+  assert.equal(hidden({ builders_at_start: 3, builders_expected: 8 }), false, 'a team');
+  assert.equal(hidden({ builders_at_start: 1 }), false, 'the growth guess never answered is not "nobody"');
+  const reason = softLimitsFor({ builders_at_start: 1, builders_expected: 1 }).limits.find((l) => l.option === 'reward_intents').reason;
+  assert.match(reason, /building solo/);
+});
+
+await t('the voice is a stored detail: planet or professional, null to un-answer, anything else refused (spec D5)', () => {
+  assert.deepEqual(provisioning.PROJECT_DETAIL_VOCAB.voice, ['planet', 'professional']);
+  assert.equal(badProjectDetail({ voice: 'professional' }), null);
+  assert.equal(badProjectDetail({ voice: null }), null);
+  assert.match(badProjectDetail({ voice: 'pirate' }).message, /"voice" must be one of: planet, professional/);
+  assert.deepEqual(provisioning.normalizeProjectDetail({ voice: 'planet', entity: 'for-profit' }), { entity: 'for-profit', voice: 'planet' });
+});
+
 await t('the soft limits read back on every owner read of the project, from the stored answers', () => {
   const view = provisioning.publicInstance({ id: 1, slug: 'kestrel', detail: provisioning.normalizeProjectDetail({ entity: 'nonprofit' }) });
   assert.equal(view.soft_limits.enforced, false);

package/tests/wizard_physics.mjs

@@ -93,7 +93,8 @@ test('a builder who loops the check is slowed down, and another builder is not',
 });
 
 // ── the page's vocabularies are the server's ─────────────────────────────────
-const SCRIPT = HUB.slice(HUB.indexOf('/* ── planet physics, questions 1 to 4 (task 1004418, BV2.PS07) ──'),
+// questions 5 to 7 joined the same region (task 1004419, tests/wizard_physics_more.mjs)
+const SCRIPT = HUB.slice(HUB.indexOf('/* ── planet physics, questions 1 to 7 (tasks 1004418 and 1004419, BV2.PS07 + PS11) ──'),
   HUB.indexOf('    /* per-panel validation on Next */'));
 
 test('the page carries the server\'s countries, regions and entity forms, exactly', () => {
@@ -115,7 +116,9 @@ test('every choice the questions offer is an answer the server accepts', () => {
   const seen = [...panel.matchAll(/data-phys="([a-z_]+)" data-val="([^"]+)"/g)];
   assert.ok(seen.length >= 20, 'the four questions\' choices');
   for (const [, key, raw] of seen) {
-    const value = raw === 'true' ? true : raw === 'false' ? false : raw;
+    const one = raw === 'true' ? true : raw === 'false' ? false : raw;
+    // a list question's choice is one member of the list it sends (task 1004419)
+    const value = physics.PLANET_PHYSICS_QUESTIONS[key] && physics.PLANET_PHYSICS_QUESTIONS[key].kind === 'many' ? [one] : one;
     assert.notEqual(physics.canonicalAnswer(physics.PLANET_PHYSICS_QUESTIONS[key], value), undefined, `${key}=${raw}`);
   }
   for (const [, work] of panel.matchAll(/data-work="([^"]+)"/g)) {
@@ -196,7 +199,11 @@ test('Continue walks the questions and moves the wizard on only after the last',
   assert.deepEqual(w.shown, [], 'no entity: still here');
   a().entity = 'for-profit';
   w.run('physAdvance()');
-  assert.deepEqual(w.shown, [4], 'and only now on to the name step');
+  await tick(); await tick();
+  // task 1004419: questions 5 to 7 and the summary follow inside the same step
+  // (walked to the name step in tests/wizard_physics_more.mjs)
+  assert.equal(w.state.physics.q, 5, 'on to question 5');
+  assert.deepEqual(w.shown, [], 'and the wizard has not moved on');
 });
 
 test('a stopped description lands on the stop screen with the server\'s words', async () => {
@@ -216,7 +223,7 @@ test('the create sends the answers as detail: existing work only for an existing
   Object.assign(w.state.physics.answers, { project_state: 'new', existing_work: ['code'], main_work: 'code', home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'intent-solo' });
   w.state.teamShape = 'solo';
   assert.deepEqual(JSON.parse(JSON.stringify(w.run('createDetail()'))), {
-    project_state: 'new', home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'intent-solo', team_shape: 'solo',
+    project_state: 'new', home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'intent-solo', voice: 'planet', team_shape: 'solo',
   });
   w.state.physics.answers = {}; w.state.teamShape = null;
   assert.equal(w.run('createDetail()'), undefined, 'nothing answered: the detail is omitted, as before');