@bongos/core 1.19.528 → 1.19.529

package/tests/projects_hub_module_picker.mjs

@@ -25,6 +25,17 @@ import path from 'node:path';
 import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
 
+// ESM named imports off the CJS module on purpose (the knip learning): the
+// cross-check test at the bottom runs the REAL declaration the route serves, so a
+// rule change cannot pass this file while breaking the panel.
+import {
+  ALWAYS_ON_CORE,
+  RULED_TEAM_SHAPES,
+  starterBundleAnswerTable,
+  optionalModules,
+  effectiveModules,
+} from '../modules/provisioning/starter-bundles.js';
+
 const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
 const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8');
@@ -59,6 +70,39 @@ const PAYLOAD = {
   ],
 };
 
+// The `byTeamShape` half of the same payload (BV1.R22, task 1002341): the bundle
+// re-resolved for each About-step answer, with the adjustments that got it there.
+//
+// Deliberately only TWO types carry it. The rest are left without so the
+// degradation path is exercised by the same fixture — a payload from a server that
+// predates R22, or a team shape no rule fires on, must fall through to the
+// unadjusted bundle rather than preselecting nothing. The real table for every
+// type is pinned against the real module further down ("the picker and the server
+// resolve the same set").
+const TAILORED = {
+  ...PAYLOAD,
+  bundles: PAYLOAD.bundles.map((b) => {
+    if (b.type === 'game') {
+      return { ...b, byTeamShape: {
+        // solo: the shared environment comes off
+        solo: { bundle: ['discord'], adjustments: [{ rule: 'building-alone-needs-no-shared-environment', effect: 'remove', module: 'dev-box', reason: 'You are building this alone, so the shared cloud environment is off.' }] },
+        // small-team: the rule wants dev-box, the bundle already has it — a rule
+        // that changed nothing claims nothing
+        'small-team': { bundle: ['dev-box', 'discord'], adjustments: [] },
+        community: { bundle: ['dev-box', 'discord'], adjustments: [] },
+      } };
+    }
+    if (b.type === 'research') {
+      return { ...b, byTeamShape: {
+        solo: { bundle: ['agents'], adjustments: [] },
+        'small-team': { bundle: ['agents', 'dev-box'], adjustments: [{ rule: 'a-team-shares-one-environment', effect: 'add', module: 'dev-box', reason: 'A small team gets one shared environment to build in.' }] },
+        community: { bundle: ['agents', 'discord'], adjustments: [{ rule: 'a-community-needs-somewhere-to-gather', effect: 'add', module: 'discord', reason: 'You said an open community is building this, so somewhere for it to gather is switched on.' }] },
+      } };
+    }
+    return b;
+  }),
+};
+
 function makeEl(id) {
   const classes = new Set();
   const attrs = new Map();
@@ -88,13 +132,26 @@ function rowsOf(html) {
   return out;
 }
 
+// The reason lines the panel painted, in order (task 1002341). Parsed out of the
+// markup for the same reason rowsOf is: a selector that resolves against markup
+// nobody wrote proves nothing.
+function whyOf(html) {
+  const out = [];
+  const re = /<span>([^<]*)<\/span>/g;
+  let m;
+  while ((m = re.exec(html))) out.push(m[1]);
+  return out;
+}
+
 // Boot the picker with a given draft state. `fetchOk: false` drives the
-// couldn't-load branch. Returns the handles the assertions drive it through.
-function boot({ state: seed = {}, fetchOk = true } = {}) {
+// couldn't-load branch; `payload` swaps in a different server answer (TAILORED
+// carries the R22 byTeamShape half). Returns the handles the assertions drive it
+// through.
+function boot({ state: seed = {}, fetchOk = true, payload = PAYLOAD } = {}) {
   const els = new Map();
   const $ = (id) => { if (!els.has(id)) els.set(id, makeEl(id)); return els.get(id); };
   const form = makeEl('panel-modules-form');
-  const state = { step: 4, projType: null, modules: null, ...seed };
+  const state = { step: 4, projType: null, teamShape: null, modules: null, ...seed };
   const shown = [];
   let saves = 0;
   let fetches = 0;
@@ -112,7 +169,7 @@ function boot({ state: seed = {}, fetchOk = true } = {}) {
     renderReview: () => { reviews++; },
     API: '/api/bongos',
     fetch: () => { fetches++; return Promise.resolve(fetchOk
-      ? { ok: true, json: () => Promise.resolve(PAYLOAD) }
+      ? { ok: true, json: () => Promise.resolve(payload) }
       : { ok: false, json: () => Promise.resolve(null) }); },
     Promise, JSON, Math, Object, Array, String, Number, console,
   };
@@ -134,6 +191,8 @@ function boot({ state: seed = {}, fetchOk = true } = {}) {
     render: () => sandbox.renderModules(),
     open: async function () { sandbox.renderModules(); for (let i = 0; i < 20; i++) await Promise.resolve(); },
     rows: () => rowsOf(band.innerHTML),
+    why: () => whyOf($('modWhy').innerHTML),
+    whyShown: () => $('modWhy').classList.contains('on'),
     coreNote: () => $('modCoreNote').textContent,
     coreShown: () => $('modCoreNote').classList.contains('on'),
     click: (key) => {
@@ -367,3 +426,157 @@ test('the review reads an answered picker back, empty included', async () => {
   await none.settle();
   assert.equal(none.extrasRow(), 'None — just the core', 'a deliberate "none" is stated as one');
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// BV1.R22 (task 1002341) — the About step's answer reaches the preselect, and
+// the panel says why. ADR 0243.
+// ─────────────────────────────────────────────────────────────────────────────
+
+test('the team shape adjusts the type bundle, and the panel says why in the owner\'s words', async () => {
+  // Arrange — "a game", then "just me" one panel later
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+
+  // Act
+  await h.open();
+
+  // Assert — the shared environment came off, and the reason is on screen
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['discord'],
+    'solo drops the dev box the game bundle would have preselected');
+  assert.equal(h.whyShown(), true);
+  assert.deepEqual(h.why(), ['You are building this alone, so the shared cloud environment is off.']);
+});
+
+test('a rule that changed nothing claims nothing', async () => {
+  // small-team ADDS dev-box, and the game bundle already carries it. A reason
+  // shown for a change that did not happen is a claim the owner cannot check.
+  const h = boot({ state: { projType: 'game', teamShape: 'small-team' }, payload: TAILORED });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['dev-box', 'discord']);
+  assert.deepEqual(h.why(), [], 'no adjustment, no sentence');
+  assert.equal(h.whyShown(), false, 'and no empty block sitting on the panel');
+});
+
+test('an added module is preselected and explained', async () => {
+  const h = boot({ state: { projType: 'research', teamShape: 'community' }, payload: TAILORED });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['agents', 'discord']);
+  assert.deepEqual(h.why(), ['You said an open community is building this, so somewhere for it to gather is switched on.']);
+});
+
+test('answering the About step later re-preselects, with no second read', async () => {
+  // The two questions live on two earlier panels and are both changeable. The
+  // whole table arrived in one read precisely so going back costs nothing.
+  const h = boot({ state: { projType: 'research' }, payload: TAILORED });
+  await h.open();
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['agents'], 'unanswered: the raw bundle');
+
+  h.state.teamShape = 'small-team';
+  h.render();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['agents', 'dev-box']);
+  assert.equal(h.fetches(), 1, 'and the answer cost no round trip');
+});
+
+test('Skip after an answered About step still yields the set the panel showed', async () => {
+  // ADR 0240 §2's property, extended to the interview's answer (ADR 0243): the
+  // preselect and the server's fallback are the same declaration, so skipping
+  // must still answer NOTHING and still land the tailored set.
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+
+  h.skip();
+
+  assert.deepEqual(h.shown, [5]);
+  assert.equal(h.state.modules, null, 'skipping answers nothing, tailored or not');
+  assert.equal(h.forCreate(), undefined, 'so the create request still carries no modules key');
+  assert.deepEqual(h.picked(), ['discord'], 'while the set they were shown is still the set they get');
+});
+
+test('once the owner has answered, the reasons go — the panel stops arguing', async () => {
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+  assert.equal(h.why().length, 1);
+
+  h.click('dev-box');
+
+  assert.deepEqual(h.state.modules, ['dev-box', 'discord'], 'their toggle stands over the rule');
+  assert.deepEqual(h.why(), [], 'and the rule stops explaining a set that is no longer its own');
+  assert.equal(h.whyShown(), false);
+});
+
+test('a payload with no byTeamShape degrades to the untailored bundle, never to nothing', async () => {
+  // A server that predates R22 still serves `bundles[].bundle`. The panel must
+  // preselect that rather than empty out — untailored is never wrong, only less.
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: PAYLOAD });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['dev-box', 'discord']);
+  assert.deepEqual(h.why(), []);
+});
+
+test('an off-vocabulary team shape adjusts nothing', async () => {
+  // A value that was valid when the draft was stored and has since left the
+  // vocabulary reads as no answer, exactly as normalizeProjectDetail drops one.
+  const h = boot({ state: { projType: 'game', teamShape: 'a-huge-corporation' }, payload: TAILORED });
+  await h.open();
+
+  assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['dev-box', 'discord']);
+  assert.deepEqual(h.why(), []);
+});
+
+test('a couldn\'t-load read clears any reasons it had already painted', async () => {
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+  assert.equal(h.why().length, 1);
+
+  h.sandbox.starterBundles = null;
+  h.render();
+
+  assert.deepEqual(h.why(), [], 'a stale reason for a set no longer on screen is a lie');
+  assert.equal(h.whyShown(), false);
+});
+
+test('a reason goes through the page escaper like every other rendered value', async () => {
+  const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
+  await h.open();
+  h.sandbox.starterBundles = {
+    core: [], optional: [],
+    bundles: [{ type: 'game', bundle: [], byTeamShape: { solo: { bundle: [], adjustments: [{ reason: '<img src=x onerror=alert(1)>' }] } } }],
+  };
+  h.render();
+
+  const html = h.sandbox.$('modWhy').innerHTML;
+  assert.ok(!html.includes('<img'), 'a hostile reason cannot inject markup');
+  assert.ok(html.includes('&lt;img src=x onerror=alert(1)&gt;'), 'it is shown escaped');
+});
+
+// The pin that makes the two ends of ADR 0243 unable to drift. Everything above
+// runs the picker against a FIXTURE; this one runs it against the REAL payload the
+// route serves, and asserts the panel's preselect is the same set the server would
+// resolve for a row with those answers and a skipped picker. If a rule is ever
+// added, changed or moved, one of these twenty combinations fails here rather than
+// silently handing an owner a project that is not the one they were shown.
+test('the picker and the server resolve the same set for every answer an owner can give', async () => {
+  const LIVE = { core: [...ALWAYS_ON_CORE], bundles: starterBundleAnswerTable(), optional: optionalModules() };
+  const shapes = [null, ...RULED_TEAM_SHAPES];
+
+  for (const preset of LIVE.bundles) {
+    for (const teamShape of shapes) {
+      const h = boot({ state: { projType: preset.type, teamShape }, payload: LIVE });
+      await h.open();
+
+      // what the server gives a project that answered the interview and then
+      // skipped the picker — `modules: null`, resolved at read time
+      const server = effectiveModules({ type: preset.type, modules: null, detail: teamShape ? { team_shape: teamShape } : {} });
+
+      assert.deepEqual(h.picked(), server.selected,
+        `type=${preset.type} team_shape=${teamShape}: the panel preselects what the server resolves`);
+      assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), server.selected,
+        `type=${preset.type} team_shape=${teamShape}: and the toggles show it`);
+      assert.deepEqual(h.why().length, server.adjustments.length,
+        `type=${preset.type} team_shape=${teamShape}: one sentence per adjustment the server made`);
+    }
+  }
+});

package/tests/provisioning_starter_bundles.mjs

@@ -37,8 +37,11 @@ import {
   OPTIONAL_MODULES,
   STARTER_BUNDLES,
   HUB_ONLY_MODULES,
+  RULED_TEAM_SHAPES,
   bundleForProjectType,
   allStarterBundles,
+  adjustBundle,
+  starterBundleAnswerTable,
   normalizeModuleSelection,
   effectiveModules,
 } from '../modules/provisioning/starter-bundles.js';
@@ -259,8 +262,60 @@ test('GET /provisioning/starter-bundles is public and serves the resolved bundle
   // Assert
   assert.equal(res.status, 200, `readable with no session (got ${res.status} ${res.raw})`);
   assert.deepEqual(res.body.core, [...ALWAYS_ON_CORE]);
-  assert.deepEqual(res.body.bundles, allStarterBundles());
+  // `starterBundleAnswerTable` since R22 (task 1002341): every bundle, plus the
+  // same bundle re-resolved for each About-step answer. It is a superset of
+  // `allStarterBundles()` — the untailored keys are byte-for-byte what they were.
+  assert.deepEqual(res.body.bundles, starterBundleAnswerTable());
   assert.equal(res.body.bundles.length, provisioning.PROJECT_TYPES.length);
+  for (const [i, plain] of allStarterBundles().entries()) {
+    const { byTeamShape, ...rest } = res.body.bundles[i];
+    assert.deepEqual(rest, plain, `bundle ${plain.type} kept its pre-R22 shape`);
+    assert.ok(byTeamShape, `bundle ${plain.type} carries the tailored table`);
+  }
+});
+
+test('every bundle carries a resolution for every team shape a rule can fire on', async () => {
+  // The picker preselects straight out of this table with no second read (ADR
+  // 0243), so a missing row is a panel that silently preselects the untailored
+  // set for an answer the owner did give.
+  const res = await get('/api/bongos/provisioning/starter-bundles');
+
+  for (const row of res.body.bundles) {
+    assert.deepEqual(Object.keys(row.byTeamShape).sort(), [...RULED_TEAM_SHAPES].sort(),
+      `${row.type} answers every team shape`);
+    for (const [shape, tailored] of Object.entries(row.byTeamShape)) {
+      assert.ok(Array.isArray(tailored.bundle), `${row.type}/${shape} names a module list`);
+      assert.ok(Array.isArray(tailored.adjustments), `${row.type}/${shape} names its adjustments`);
+      // never the always-on core, never a key off the catalog
+      for (const key of tailored.bundle) {
+        assert.ok(OPTIONAL_MODULES.some((m) => m.key === key),
+          `${row.type}/${shape} preselects "${key}", which is not a choice the picker offers`);
+      }
+      // an adjustment is a DELTA: it only claims what it actually changed
+      for (const adj of tailored.adjustments) {
+        const inBase = row.bundle.includes(adj.module);
+        const inNow = tailored.bundle.includes(adj.module);
+        assert.notEqual(inBase, inNow, `${row.type}/${shape}: "${adj.rule}" claims a change it did not make`);
+        assert.ok(adj.reason && adj.reason.length > 20, `${row.type}/${shape}: "${adj.rule}" needs an owner-facing reason`);
+      }
+    }
+  }
+});
+
+test('an adjusted bundle is in CATALOG order, like every other module list', () => {
+  // normalizeModuleSelection stores a chosen set in catalog order and the picker
+  // re-derives its toggles that way, so an appended adjustment would make one set
+  // of modules read as two different lists depending on whether the owner
+  // answered the picker or skipped it.
+  const order = OPTIONAL_MODULES.map((m) => m.key);
+  const sorted = (list) => [...list].sort((a, b) => order.indexOf(a) - order.indexOf(b));
+
+  for (const preset of allStarterBundles()) {
+    for (const shape of RULED_TEAM_SHAPES) {
+      const { modules } = adjustBundle(preset.bundle, shape);
+      assert.deepEqual(modules, sorted(modules), `${preset.type}/${shape} is in catalog order`);
+    }
+  }
 });
 
 test('the route never reaches the database — the bundles are a declaration, not a query', async () => {
@@ -355,6 +410,40 @@ test('effectiveModules: an answered picker wins over the bundle, including "none
   assert.equal(none.source, 'chosen');
 });
 
+test('effectiveModules: a skipped picker after an ANSWERED interview yields the TAILORED bundle', () => {
+  // BV1.R22 / ADR 0243 — the property ADR 0240 §2 leans the skip on ("the
+  // preselect and the fallback are the same declaration"), now that the panel
+  // preselects the team-shape-adjusted set. Without this the picker would show a
+  // solo owner one thing and the project would quietly get another.
+  const eff = effectiveModules({ type: 'game', modules: null, detail: { team_shape: 'solo' } });
+
+  assert.deepEqual(eff.selected, ['discord'], 'the shared environment the rule removes is not silently restored');
+  assert.equal(eff.source, 'bundle', 'and it is still an UNANSWERED set, not a stored one');
+  assert.deepEqual(eff.adjustments.map((a) => a.module), ['dev-box']);
+  assert.match(eff.adjustments[0].reason, /building this alone/, 'carrying the reason the panel showed');
+});
+
+test("effectiveModules: the owner's own answer is never re-adjusted by a rule", () => {
+  // A rule corrects a PRESELECT the owner did not make. Once they have toggled,
+  // re-applying it would overrule them with an answer they had already refused.
+  const eff = effectiveModules({ type: 'game', modules: ['dev-box'], detail: { team_shape: 'solo' } });
+
+  assert.deepEqual(eff.selected, ['dev-box'], 'solo removes dev-box, and the owner put it back');
+  assert.equal(eff.source, 'chosen');
+  assert.deepEqual(eff.adjustments, [], 'and no reason is handed back for a choice they made themselves');
+});
+
+test('effectiveModules: a detail that says nothing usable adjusts nothing', () => {
+  // {} (skipped), a shape that has left the vocabulary, and a non-object column
+  // value all read as NO ANSWER — normalizeProjectDetail's rule, reached without
+  // importing it.
+  for (const detail of [undefined, null, {}, { team_shape: null }, { team_shape: 'a-huge-corporation' }, 'not-an-object', []]) {
+    const eff = effectiveModules({ type: 'game', modules: null, detail });
+    assert.deepEqual(eff.selected, ['dev-box', 'discord'], `detail=${JSON.stringify(detail)} falls back to the type's bundle`);
+    assert.deepEqual(eff.adjustments, []);
+  }
+});
+
 test('effectiveModules: an undeclared type resolves to the core, never a guess', () => {
   for (const row of [{ type: null, modules: null }, { type: 'not-sure', modules: null }, {}]) {
     const eff = effectiveModules(row);