@bongos/core 1.19.486 → 1.19.488

package/tests/modules.mjs

@@ -140,6 +140,21 @@ test('disciplines: vanilla offers engineer + ideator (core); art-pipeline adds a
   assert.deepEqual(enabledDisciplines(m), ['engineer', 'ideator', 'artist']);
 });
 
+test('disciplines: ui-design contributes `ui` — the manifest key IS the unlock (task 1003487)', () => {
+  // enabledDisciplines() already merged contributes.disciplines; ui-design simply
+  // never declared any, so the craft existed in the DB CHECK, in discipline-modes
+  // and on tasks while staying unreachable from every surface a builder chooses with.
+  if (!EFFECTIVE['ui-design']) return; // only meaningful where the module is installed
+  assert.deepEqual(EFFECTIVE['ui-design'].contributes.disciplines, ['ui'],
+    'the module declares the craft it owns');
+  const on = resolveModules({ instance: { modules: { 'ui-design': true } }, registry: EFFECTIVE });
+  assert.ok(enabledDisciplines(on).includes('ui'),
+    'a builder can save it, because updateBuilderDisciplines validates against this very list');
+  // and it withdraws with the module, exactly as artist does with art-pipeline
+  const off = resolveModules({ instance: { modules: { 'ui-design': false } }, registry: EFFECTIVE });
+  assert.ok(!enabledDisciplines(off).includes('ui'), 'module off => craft withdrawn');
+});
+
 test('clientModules is a safe boolean projection covering every known module + disciplines', () => {
   const c = clientModules(resolveModules({ instance: OTB, registry: SAMPLE_REG }));
   for (const k of KNOWN_MODULES) assert.equal(typeof c.enabled[k], 'boolean');
@@ -180,5 +195,8 @@ test('a branded sibling (GDS_BRANDING_FILE set, no GDS_MODULES_FILE) defaults to
   // A non-default brand must fall through to the neutral (all-off) module set.
   const m = loadModules({ env: { GDS_BRANDING_FILE: 'config/branding.cloudbongos.json' } });
   for (const k of KNOWN_MODULES) assert.equal(m[k], false, `${k} must be off for a branded sibling`);
-  assert.deepEqual(enabledDisciplines(m), ['engineer', 'ideator']);
+  // The two core crafts, plus 'ui' from ui-design — which is default-on for EVERY
+  // instance ("every instance has a face") and is not one of KNOWN_MODULES, so the
+  // all-off assertion above never reaches it (task 1003487).
+  assert.deepEqual(enabledDisciplines(m), ['engineer', 'ideator', 'ui']);
 });

package/tests/newcomer_restock.mjs

@@ -68,6 +68,82 @@ t('loadFloors: real config keeps floor >= 2 per discipline (a spare on every cla
   }
 });
 
+// ---- the ui craft is stocked, so a ui-only newcomer is never starved (task 1003487) ----
+t('ui: the craft is offered, has chores, and none of them needs a browser', () => {
+  assert.ok(r.validDisciplines().has('ui'),
+    'ui-design is default-on, so enabledDisciplines() offers ui and restockAll will stamp it');
+  assert.ok(r.templateDisciplines().has('ui'), 'ui has chores defined, so restockDiscipline accepts it');
+  const chores = r.loadTemplates().ui;
+  assert.ok(Array.isArray(chores) && chores.length >= 1, 'at least one ui chore exists');
+  for (const c of chores) {
+    assert.ok(c.template_id && c.version_id && c.title, `${c.template_id || '?'} has id/version/title`);
+    assert.equal(c.discipline, 'ui');
+    assert.ok(c.est_minutes <= 60, `${c.template_id} is inside the newcomer scope ceiling`);
+    // Xenos-safe: a design chore necessarily READS the branding pack, so the
+    // property that matters is that every one of them says, in its done_when,
+    // that the world and the pipeline core are not what gets edited.
+    const dw = (c.done_when || []).join(' ');
+    assert.ok(/NOT modified|were untouched|untouched/i.test(dw),
+      `${c.template_id} states what must stay untouched`);
+    assert.ok(/permission|infra|migration/i.test(dw),
+      `${c.template_id} names the protected core as off-limits`);
+  }
+  // The kit needs Chrome/Edge, which a newcomer's machine may not have — so at
+  // least one ui chore must be verifiable without a browser, or the craft starves
+  // exactly the people it was opened for.
+  assert.ok(chores.some((c) => !/kit\/render\.js/.test((c.done_when || []).join(' '))),
+    'a ui newcomer with no browser still has a chore they can finish');
+});
+
+t('ui: the floor config stocks the craft', () => {
+  assert.ok(r.loadFloors().ui >= 1, 'ui declares a standing pool, so the shelf refills');
+});
+
+// ---- one file read per operation (task 1003487 re-grade: the efficiency finding) ----
+// The templates file was being re-read and re-parsed by every helper on the path —
+// templateDisciplines() and loadTemplates() back to back per call, and once per
+// craft inside restockAll. These pin the single-read contract so it cannot regress.
+{
+  const nodefs = require('node:fs');
+  const realRead = nodefs.readFileSync;
+  let reads = 0;
+  nodefs.readFileSync = (p, ...rest) => {
+    if (String(p).includes('newcomer-floor.templates.json')) reads += 1;
+    return realRead(p, ...rest);
+  };
+  try {
+    reads = 0;
+    await r.restockForClaim({ source: 'not-a-chore', discipline: 'ui' });
+    assert.equal(reads, 0, 'a non-chore task is rejected before any file read');
+
+    reads = 0;
+    const byDisc = r.loadTemplates();
+    assert.equal(reads, 1, 'loadTemplates reads once');
+    r.templateDisciplines(byDisc);
+    assert.equal(reads, 1, 'templateDisciplines re-uses an already-loaded map');
+    await r.restockDiscipline('bogus-craft', byDisc);
+    assert.equal(reads, 1, 'restockDiscipline re-uses it too');
+  } finally {
+    nodefs.readFileSync = realRead;
+  }
+  passed += 1;
+  console.log('  PASS  restock reads newcomer-floor.templates.json once per operation');
+}
+
+t('restockForClaim threads its loaded map into the no-match fallback', () => {
+  // The read-counting block above drives the helpers directly; this pins the real
+  // call chain it cannot reach without a database — the fallback branch taken when
+  // a chore's source_ref does not resolve to a known template.
+  const src = require('node:fs').readFileSync(
+    new URL('../modules/onboarding/newcomer-restock.js', import.meta.url), 'utf8');
+  const body = src.slice(src.indexOf('async function restockForClaim'),
+                         src.indexOf('async function restockAll'));
+  assert.ok(/const byDiscipline = loadTemplates\(\);/.test(body), 'it loads the templates once');
+  assert.ok(!/loadTemplates\(\)\[/.test(body), 'and never re-indexes a second fresh load');
+  assert.ok(/restockDiscipline\(task\.discipline, byDiscipline\)/.test(body),
+    'the fallback re-uses that map rather than letting the default param re-read the file');
+});
+
 // ---- restockForClaim: skip path is DB-free (awaited) ----
 // (returns an array of per-template results; the skip path is a 1-element array.)
 assert.deepEqual(await r.restockForClaim(null), [{ skipped: true }]);