@bongos/core 1.24.79 → 1.24.80

package/tests/hall_sitemap.mjs

@@ -21,9 +21,10 @@ const model = gen.build();
 test('the parse found the hall, so nothing below passes against an empty map', () => {
   const files = fs.readdirSync(path.join(ROOT, 'modules/hall-ui/public')).filter((f) => f.endsWith('.html'));
   assert.equal(model.pages.length, files.length, 'one row per page file');
-  // 24 since task 1005051 folded the Roadmap into Goals.
-  assert.ok(model.nav.length >= 24, `expected the shell's nav, found ${model.nav.length} items`);
-  for (const c of ['building', 'artistry', 'ideating', 'governing']) {
+  // 20 since task 1005144 moved four settings pages into the options menu.
+  assert.ok(model.nav.length >= 20, `expected the shell's nav, found ${model.nav.length} items`);
+  // task 1005141: three crafts — Artisan, Artist (Artistry + Ideating), Patron
+  for (const c of ['artisan', 'artist', 'patron']) {
     assert.ok(model.crafts.tabs[c].length > model.crafts.always.length, `${c} lists tabs of its own`);
   }
   assert.ok(model.chrome.includes('shell.js') && model.chrome.includes('craft-mode.js'), 'the chrome is the shell');
@@ -87,10 +88,10 @@ test('the Primer links to Repo Atlas and Commands, and in the hall they open tho
   assert.equal(gen.classify('/no-such-page', urls), false);
 });
 
-test('the street is Governing\'s home: no nav item, reached by clicking from the city', () => {
+test('the street is Patron\'s home: no nav item, reached by clicking from the city', () => {
   const street = model.pages.find((p) => p.url === '/street');
   assert.ok(street, 'the street is a hall page');
   assert.deepEqual(street.nav, []);
-  assert.ok(street.reachIn.includes('governing'));
+  assert.ok(street.reachIn.includes('patron'));
   assert.ok(street.in.includes('/city'), 'the city links to the street');
 });

package/tests/hall_start_screen.mjs

@@ -0,0 +1,244 @@
+// tests/hall_start_screen.mjs — the game's start screen and load screen (task 1005143, BONGOS-V3 R03).
+//
+// WHY. Done-when: a sign-in passes through both before the world. That is a chain of hand-offs a
+// reader would only notice breaking as "the hall looks like it used to": the welcome hands a fresh
+// sign-in to shell-game.js, Start turns game mode on, the load screen builds the city week by week
+// from the one bounded city read, and the craft picker waits until the world is showing. So this
+// RUNS the real welcome-boot.js and shell-game.js: the hand-off and the pure parts in a vm, and
+// the two screens in a real browser over Home's own markup (skipped where there is no browser).
+//
+// Run:  node tests/hall_start_screen.mjs
+import assert from 'node:assert/strict';
+import { test, after } from 'node:test';
+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';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+const CITY = fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'home__city.json'), 'utf8');
+
+// ---------- in a vm: the pure parts and the welcome's hand-off ----------
+function sandbox({ store = {}, game = true } = {}) {
+  const started = [], asked = [];
+  const window = {
+    location: { search: '', pathname: '/', hash: '' },
+    __BRANDING__: { identity: { worldName: 'Harbor' } },
+    localStorage: {
+      getItem: (k) => (k in store ? store[k] : null),
+      setItem: (k, v) => { store[k] = String(v); },
+      removeItem: (k) => { delete store[k]; },
+    },
+    sessionStorage: { getItem: () => null, setItem() {} },
+    OTBCraftMode: { markAsked: () => asked.push('marked'), onAccess: (a, b) => asked.push(['picker', a.authed, b.id]) },
+  };
+  const document = { documentElement: { dataset: {}, classList: { add() {}, remove() {} } }, addEventListener() {} };
+  const box = { window, document, URLSearchParams, setTimeout, clearTimeout, console };
+  vm.createContext(box);
+  if (game) {
+    vm.runInContext(read('shell-game.js'), box, { filename: 'shell-game.js' });
+    window.OTBShellGame.start = (o) => { started.push(o); return true; };
+  }
+  vm.runInContext(read('welcome-boot.js'), box, { filename: 'welcome-boot.js' });
+  return { window, store, started, asked };
+}
+
+test('the menu is Start, Options, Achievements, Extras, Quit, in that order', () => {
+  const { window } = sandbox();
+  const MENU = JSON.parse(JSON.stringify(window.OTBShellGame.MENU));   // out of the vm's realm
+  assert.deepEqual(MENU.map((m) => m.label), ['Start', 'Options', 'Achievements', 'Extras', 'Quit']);
+  const links = MENU.filter((m) => m.href).map((m) => [m.id, m.href]);
+  assert.deepEqual(links, [['options', '/settings'], ['achievements', '/profile']]);
+  for (const [, href] of links) assert.ok(fs.existsSync(path.join(HALL, href.slice(1) + '.html')), href + ' is a hall page');
+});
+
+test('the load screen walks the weeks oldest first and lands exactly on now', () => {
+  const { window } = sandbox();
+  const G = window.OTBShellGame;
+  const stops = Array.from(G.historySteps(10, 30));
+  assert.equal(stops.length, 31);
+  assert.equal(stops[0], 0);
+  assert.equal(stops[30], 9, 'the last stop is the latest week, not a rounding short of it');
+  assert.ok(stops.every((v, i) => i === 0 || v >= stops[i - 1]), 'never backwards');
+  assert.deepEqual(Array.from(G.historySteps(1, 30)).filter((v) => v !== 0), [], 'a one-week project stands still');
+  assert.equal(G.whenLabel(10, 0), 'The city, 9 weeks ago');
+  assert.equal(G.whenLabel(10, 8), 'The city, 1 week ago');
+  assert.equal(G.whenLabel(10, 9), 'The city, now');
+});
+
+test('the tips rotate, and every one is a sentence', () => {
+  const { window } = sandbox();
+  const G = window.OTBShellGame;
+  const n = G.TIPS.length;
+  assert.ok(n >= 3);
+  assert.equal(G.tipAt(0), G.TIPS[0]);
+  assert.equal(G.tipAt(n), G.TIPS[0], 'wraps');
+  assert.equal(G.tipAt(n + 1), G.TIPS[1]);
+  assert.equal(G.tipAt('garbage'), G.TIPS[0]);
+  for (const t of G.TIPS) assert.match(t, /^[A-Z].*\.$/);
+});
+
+test('a fresh sign-in is handed to the start screen with the still, and the craft picker waits for the world', () => {
+  const s = sandbox({ store: { 'hall-welcome-signin': '1' } });
+  const access = { authed: true }, builder = { id: 7, display_name: 'Ada' };
+  assert.equal(s.window.OTBWelcome.onAccess(access, builder), true, 'the shell is told a screen is up, so it asks no picker');
+  assert.equal(s.started.length, 1);
+  assert.equal(s.started[0].name, 'Harbor');
+  assert.match(s.started[0].art, /^\/builders\/welcome-(day|night)\.webp$/);
+  assert.equal(s.store['hall-welcome-signin'], undefined, 'the flag is spent');
+  assert.deepEqual(s.asked, [], 'nothing is asked while the start screen is up');
+  s.started[0].done();
+  assert.deepEqual(s.asked, [['picker', true, 7]], 'the picker is asked once the world is showing');
+});
+
+test('a visit that is not a fresh sign-in keeps the welcome, and a hall without shell-game.js greets a sign-in as before', () => {
+  const daily = sandbox();
+  assert.equal(daily.window.OTBWelcome.onAccess({ authed: true }, { id: 7 }), true);
+  assert.deepEqual([daily.started.length, daily.asked], [0, ['marked']], 'the day\'s first visit is the welcome\'s');
+  const bare = sandbox({ store: { 'hall-welcome-signin': '1' }, game: false });
+  assert.equal(bare.window.OTBWelcome.onAccess({ authed: true }, { id: 7 }), true);
+  assert.deepEqual(bare.asked, ['marked']);
+});
+
+test('Home loads the sheet and the script, and the sheet types in no size, corner or breakpoint', () => {
+  const html = read('index.html');
+  assert.match(html, /<link rel="stylesheet" href="\/builders\/shell-game\.css[^"]*">/);
+  assert.ok(html.indexOf('welcome-boot.js') < html.indexOf('shell.js?'), 'the welcome, which hands over, loads before the shell');
+  const css = read('shell-game.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(css, /font-size:\s*[\d.]/);
+  assert.doesNotMatch(css, /border-radius:\s*[\d.]/);
+  assert.doesNotMatch(css, /@media/);
+  assert.doesNotMatch(css, /#[0-9a-fA-F]{3,8}\b/, 'tokens, or black and white: no private palette');
+});
+
+// ---------- in a browser: the two screens over Home's own markup ----------
+const lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
+let browser = null;
+try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+const skip = !browser && 'no system Edge or Chrome';
+
+const ORIGIN = 'http://hall.test';
+const TYPES = { '.js': 'text/javascript', '.css': 'text/css', '.webp': 'image/webp' };
+const INDEX = read('index.html').replace(/<script\b[^>]*>[\s\S]*?<\/script>/g, '').replace(/\{\{[^}]*\}\}/g, '');
+const STUB = '<script>window.__BRANDING__ = { identity: { worldName: "Harbor" } }; window.BongosClient = { createClient: () => ({ request: async () => ({ ok: false, status: 404, data: null }) }) };</script>';
+const SCRIPTS = ['dom-utils.js', 'welcome-boot.js', 'shell-game.js', 'shell-trail.js', 'craft-mode.js', 'shell.js', 'city-draw.js', 'home-city-draw.js']
+  .map((f) => `<script src="/builders/${f}"></script>`).join('');
+const PAGE = INDEX.replace('</body>', STUB + SCRIPTS + '</body>');
+
+async function hall({ city = true, reducedMotion = 'no-preference' } = {}) {
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 }, reducedMotion });
+  await ctx.route(ORIGIN + '/**', (route) => {
+    const p = new URL(route.request().url()).pathname;
+    if (p === '/' || p === '/index.html') return route.fulfill({ contentType: 'text/html', body: PAGE });
+    if (p === '/api/bongos/home/city') return city ? route.fulfill({ contentType: 'application/json', body: CITY }) : route.fulfill({ status: 500, body: '' });
+    const ext = path.extname(p);
+    const f = path.join(HALL, p.replace(/^\/builders\//, ''));
+    if (p.startsWith('/builders/') && TYPES[ext] && fs.existsSync(f)) return route.fulfill({ contentType: TYPES[ext], body: fs.readFileSync(f) });
+    return route.fulfill({ status: 404, body: '' });
+  });
+  return ctx;
+}
+// A page that has just come back from signing in: the flag the sign-in click left, then /me.
+async function signedIn(ctx) {
+  const page = await ctx.newPage();
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(String(e.message)));
+  await page.addInitScript(() => { try { localStorage.setItem('hall-welcome-signin', '1'); } catch (_) { /* no storage */ } });
+  await page.goto(ORIGIN + '/');
+  await page.waitForFunction(() => !!window.OTBShell && !!window.OTBWelcome && !!window.OTBShellGame);
+  await page.evaluate(() => {
+    const me = { authed: true, rank: 'metic', builder: { id: 7, display_name: 'Ada', github_login: 'ada' } };
+    window.OTBShell.applyAccess(me);
+    window.OTBShell.applyAccess(me);
+  });
+  return { page, errors };
+}
+const state = (page) => page.evaluate(() => ({
+  start: !!document.getElementById('game-start'),
+  welcome: !!document.getElementById('welcome-boot'),
+  picker: !!document.getElementById('craft-picker'),
+  game: document.documentElement.dataset.game || null,
+  full: document.documentElement.dataset.fullscreen || null,
+}));
+
+test('a sign-in passes through the start screen and the load screen before the world', { skip }, async () => {
+  const ctx = await hall();
+  const { page, errors } = await signedIn(ctx);
+  await page.waitForSelector('#game-start');
+  assert.deepEqual(await state(page), { start: true, welcome: false, picker: false, game: null, full: null },
+    'the start screen, not the welcome and not the picker; game mode is not on until Start');
+  const menu = await page.evaluate(() => ({
+    title: document.getElementById('gs-title').textContent,
+    items: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras) .gs__item')).map((e) => e.textContent),
+    focus: document.activeElement.textContent,
+    small: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras) .gs__item')).filter((e) => e.getBoundingClientRect().height < 46).length,
+  }));
+  assert.deepEqual(menu, { title: 'Harbor', items: ['Start', 'Options', 'Achievements', 'Extras', 'Quit'], focus: 'Start', small: 0 });
+
+  // The arrows walk the menu; Escape stays with the screen and does not flip the shell underneath.
+  await page.keyboard.press('ArrowDown');
+  assert.equal(await page.evaluate(() => document.activeElement.textContent), 'Options');
+  await page.keyboard.press('ArrowUp');
+  await page.keyboard.press('Escape');
+  await page.evaluate(() => new Promise((r) => setTimeout(r, 50)));
+  assert.equal((await state(page)).start, true, 'Escape does not dismiss the start screen');
+
+  // Extras opens its links; Escape folds them away again.
+  await page.click('[data-gs="extras"]');
+  assert.equal(await page.isVisible('#gs-extras a'), true);
+  await page.keyboard.press('Escape');
+  assert.equal(await page.isVisible('#gs-extras a'), false);
+
+  // Start: game mode on, the load screen with a tip, and the city building up to now.
+  await page.click('[data-gs="start"]');
+  await page.waitForSelector('#gs-load:not([hidden])');
+  assert.equal(await page.isVisible('.gs__menu'), false);
+  assert.match(await page.textContent('#gs-tip'), /\.$/);
+  await page.waitForFunction(() => /weeks? ago$/.test(document.getElementById('gs-when').textContent));
+  assert.ok(await page.evaluate(() => document.querySelectorAll('#gs-city *').length > 20), 'the city is drawn, not a placeholder');
+  await page.waitForFunction(() => { const w = document.getElementById('gs-when'); return !w || w.textContent === 'The city, now'; });
+  await page.waitForSelector('#game-start', { state: 'detached' });
+  await page.waitForSelector('#craft-picker');
+  assert.deepEqual(await state(page), { start: false, welcome: false, picker: true, game: 'on', full: 'on' },
+    'the world: game mode on, the bars gone, and only now the craft picker');
+  assert.equal(await page.evaluate(() => localStorage.getItem('hall-game')), 'on');
+  assert.deepEqual(errors, []);
+  await ctx.close();
+});
+
+test('Quit closes the tab, and says so when the browser keeps it open', { skip }, async () => {
+  const ctx = await hall();
+  const { page } = await signedIn(ctx);
+  await page.waitForSelector('#game-start');
+  await page.evaluate(() => { window.__closed = 0; window.close = () => { window.__closed += 1; }; });
+  await page.click('[data-gs="quit"]');
+  await page.waitForSelector('#gs-note:not([hidden])');
+  assert.equal(await page.evaluate(() => window.__closed), 1);
+  assert.match(await page.textContent('#gs-note'), /Close it to quit/);
+  await ctx.close();
+});
+
+test('with no city to draw, or with reduced motion, the still and the tip stand and the world still opens', { skip }, async () => {
+  for (const opts of [{ city: false }, { reducedMotion: 'reduce' }]) {
+    const ctx = await hall(opts);
+    const { page, errors } = await signedIn(ctx);
+    await page.waitForSelector('#game-start');
+    await page.click('[data-gs="start"]');
+    await page.waitForSelector('#gs-load:not([hidden])');
+    assert.match(await page.textContent('#gs-tip'), /\.$/);
+    if (opts.reducedMotion) {
+      await page.waitForFunction(() => { const w = document.getElementById('gs-when'); return !w || !w.hidden; });
+      assert.equal(await page.evaluate(() => { const w = document.getElementById('gs-when'); return w ? w.textContent : 'The city, now'; }), 'The city, now',
+        'no week-by-week run: the finished city at once');
+    }
+    await page.waitForSelector('#game-start', { state: 'detached' });
+    assert.equal((await state(page)).game, 'on');
+    assert.deepEqual(errors, []);
+    await ctx.close();
+  }
+});

package/tests/hall_street.mjs

@@ -122,11 +122,11 @@ test('a task not started is the prototype\'s workItem "ready" slab, and the more
   const p = new Proto({ mode: 'dark' });
   const T = p.theme('dark');
   const a = []; const b = [];
-  p.workItem(a, T, 'engineer', 'ready', 660, 19, 0);
+  p.workItem(a, T, 'artisan', 'ready', 660, 19, 0);
   S.work(b, S.theme('dark'), 'slab', 660, 0, 19, 6, false);
   assert.deepEqual(b, cityTokens(a), 'the slab, at a base of 0 as workItem draws it');
   const c = []; const d = [];
-  p.workItem(c, T, 'engineer', 'backlog', 660, 40, 0);
+  p.workItem(c, T, 'artisan', 'backlog', 660, 40, 0);
   S.work(d, S.theme('dark'), 'stakes', 660, 0, 40, 0, false);
   assert.deepEqual(d, c, 'the stakes');
 });

package/tests/hall_street_inside.mjs

@@ -131,7 +131,15 @@ test('every district is the prototype\'s road of work, both modes', () => {
         const p = proto(mode, { view: key, ...st });
         const want = p.districtView(p.theme(mode), key);
         const got = I.districtView(S.theme(mode), key, p.districtInfo(key));
-        for (const k of ['kicker', 'name', 'line', 'road', 'ground', 'tx', 'ty', 's', 'shapes', 'legend']) assert.deepEqual(j(got[k]), j(want[k]), `${mode} ${key} ${k}`);
+        for (const k of ['kicker', 'name', 'line', 'road', 'ground', 'tx', 'ty', 's', 'shapes']) assert.deepEqual(j(got[k]), j(want[k]), `${mode} ${key} ${k}`);
+        // The legend's craft line is the one place the hall leaves the prototype's words
+        // (task 1005141): the engineer is the artisan, and the ideator — folded into the
+        // artist — no longer has a pavilion of its own. The status line is unchanged.
+        assert.deepEqual(j(got.legend), [
+          { key: 'a', text: 'Shape is the craft: tower for artisan, studio roof for artist, glass front for UI.' },
+          j(want.legend[1]),
+        ], `${mode} ${key} legend`);
+        assert.equal(want.legend[0].key, 'a', 'the prototype still has the craft line first');
         assert.deepEqual(got.items.map((i) => [i.x, i.y, i.w, i.name, i.meta, i.stage, i.stageColor, i.stageEdge]), want.items.map((i) => [i.x, i.y, i.w, i.name, i.meta, i.stage, i.stageColor, i.stageEdge]), `${mode} ${key} items`);
       }
     }
@@ -142,7 +150,7 @@ test('workItem and crown are verbatim: every craft at every stage, every crown',
   for (const mode of ['dark', 'light']) {
     const p = proto(mode);
     const T = p.theme(mode);
-    for (const craft of ['engineer', 'artist', 'ui', 'ideator']) {
+    for (const craft of ['artisan', 'artist', 'ui']) {
       for (const stage of ['backlog', 'ready', 'being built', 'shipped', 'being graded', 'awaiting a tester']) {
         const a = []; const b = [];
         p.workItem(a, T, craft, stage, 86, 40, 92);
@@ -418,16 +426,16 @@ test('the lift runs to the chosen floor, and the chosen block flips on every pic
 
 test('a district is its own goal\'s tasks: shape from the craft, stage from the status, label the kind', () => {
   const t = (id, status, discipline, kind = 'feature', goal_id = '7', extra = {}) => ({ id: String(id), title: `task ${id}`, status, discipline, kind, goal_id, est_minutes: 120, ...extra });
-  const tasks = [t(1, 'shipped', 'engineer'), t(2, 'ready', 'artist'), t(3, 'active', 'ui'), t(4, 'confirmed', 'ideator', 'spike'), t(5, 'backlog', null, 'bug'), t(6, 'blocked', 'engineer'), t(7, 'completed', 'artist'), t(8, 'cut', 'engineer'), t(9, 'shipped', 'ui', 'feature', '8')];
+  const tasks = [t(1, 'shipped', 'artisan'), t(2, 'ready', 'artist'), t(3, 'active', 'ui'), t(4, 'confirmed', 'artist', 'spike'), t(5, 'backlog', null, 'bug'), t(6, 'blocked', 'artisan'), t(7, 'completed', 'artist'), t(8, 'cut', 'artisan'), t(9, 'shipped', 'ui', 'feature', '8')];
   const d = I.districtInfo('7', goal(7), tasks);
   assert.deepEqual(d.items.map((i) => [i[0], i[1], i[2], i[3], i[5]]), [
-    ['task 1', 'feature', 'engineer', 'shipped', 'shipped'],
-    ['task 4', 'spike', 'ideator', 'graded · landing', 'graded · landing'],
+    ['task 1', 'feature', 'artisan', 'shipped', 'shipped'],
+    ['task 4', 'spike', 'artist', 'graded · landing', 'graded · landing'],
     ['task 7', 'feature', 'artist', 'being graded', 'being graded'],
     ['task 3', 'feature', 'ui', 'being built', 'being built'],
     ['task 2', 'feature', 'artist', 'ready', 'ready'],
-    ['task 6', 'feature', 'engineer', 'backlog', 'blocked'],
-    ['task 5', 'bug', 'engineer', 'backlog', 'backlog'],
+    ['task 6', 'feature', 'artisan', 'backlog', 'blocked'],
+    ['task 5', 'bug', 'artisan', 'backlog', 'backlog'],
   ], 'in the order work moves; a cut task and another goal\'s are not drawn; no craft is a tower');
   assert.equal(d.items[0][4], 56, 'height from the estimate, never a random');
   assert.equal(d.items[4][4], 0, 'a slab or a stake has no height');
@@ -439,7 +447,7 @@ test('a district is its own goal\'s tasks: shape from the craft, stage from the
 });
 
 test('past ten pieces of work the road keeps the ones in flight and counts the rest', () => {
-  const tasks = Array.from({ length: 30 }, (_, i) => ({ id: String(i + 1), title: `t${i + 1}`, status: i < 3 ? 'active' : i < 25 ? 'shipped' : 'backlog', discipline: 'engineer', kind: 'feature', goal_id: '9', shipped_at: `2026-09-${String(1 + (i % 28)).padStart(2, '0')}T00:00:00Z` }));
+  const tasks = Array.from({ length: 30 }, (_, i) => ({ id: String(i + 1), title: `t${i + 1}`, status: i < 3 ? 'active' : i < 25 ? 'shipped' : 'backlog', discipline: 'artisan', kind: 'feature', goal_id: '9', shipped_at: `2026-09-${String(1 + (i % 28)).padStart(2, '0')}T00:00:00Z` }));
   const d = I.districtInfo('9', goal(9), tasks);
   assert.equal(d.items.length, I.MAX_ITEMS);
   assert.equal(d.more, 20);
@@ -636,7 +644,7 @@ test('a matter is a desk row: its name opens it in place; back to the street ret
 });
 
 test('a district address reads its goal\'s tasks once and draws them as buildings', async () => {
-  const tasks = [{ id: '1', title: 'checkout', status: 'shipped', discipline: 'engineer', kind: 'feature', goal_id: '7' }, { id: '2', title: 'tax forms', status: 'active', discipline: 'ui', kind: 'feature', goal_id: '7' }, { id: '3', title: 'other goal', status: 'ready', goal_id: '8' }];
+  const tasks = [{ id: '1', title: 'checkout', status: 'shipped', discipline: 'artisan', kind: 'feature', goal_id: '7' }, { id: '2', title: 'tax forms', status: 'active', discipline: 'ui', kind: 'feature', goal_id: '7' }, { id: '3', title: 'other goal', status: 'ready', goal_id: '8' }];
   const p = await bootPage({ hash: '#district=7', feeds: FEEDS([], { '/api/bongos/tasks?goal_id=7': { tasks } }) });
   await new Promise((r) => setTimeout(r, 0));
   assert.equal(p.calls.filter((c) => c === '/api/bongos/tasks?goal_id=7').length, 1);

package/tests/hall_studio_world.mjs

@@ -277,7 +277,7 @@ async function bootStudio({ reviews = [], shipped = {}, rank = 'metic', flags =
       // the same reason categoryChip is: an undefined helper throws mid-render.
       roleAxisLabel: () => 'Role',
       roleLabel: (d) => (!d ? '' : d === 'unclassified' ? 'No role yet' : d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
-      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
+      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'artisan', label: 'Artisan' }, { value: 'artist', label: 'Artist' }],
       roleIsUnset: (d) => !d || d === 'unclassified',
       ROLE_UNSET: 'unclassified',
       escapeHtml: (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
@@ -592,9 +592,9 @@ function bootShell() {
 test('the Studio nav entry is warmed only for an artist-craft builder', () => {
   const { applyAccess, navStudio } = bootShell();
 
-  applyAccess({ authed: true, rank: 'archon', builder: { display_name: 'Artist A', preferred_disciplines: ['artist', 'ideator'] } });
+  applyAccess({ authed: true, rank: 'archon', builder: { display_name: 'Artist A', preferred_disciplines: ['artist'] } });
   assert.ok(navStudio()._classes.has('nav-item--craft'), 'an artist-craft builder gets the warmed entry');
 
-  applyAccess({ authed: true, rank: 'archon', builder: { display_name: 'Eng E', preferred_disciplines: ['engineer'] } });
+  applyAccess({ authed: true, rank: 'archon', builder: { display_name: 'Eng E', preferred_disciplines: ['artisan'] } });
   assert.ok(!navStudio()._classes.has('nav-item--craft'), 'and a non-artist builder does not (the class is toggled off)');
 });

package/tests/hall_visor.mjs

@@ -0,0 +1,224 @@
+// tests/hall_visor.mjs — the first-person visor (task 1005148, BONGOS-V3 R08; ADR 0399).
+//
+// The checks ADR 0399 §4 names, driven in a real browser over a stand-in scene that
+// behaves like the sky (a canvas that pans on drag, a bubble Escape listener that
+// unpicks and calls preventDefault only when it closed something):
+//   - the glass passes pointers through — a drag on the world with the visor up pans it;
+//   - an open sheet's Escape leaves the star picked;
+//   - in game mode the last Escape reaches the options menu, never the visor.
+// Plus the criterion's own proof half that is the visor's: an Artisan and an Artist
+// are offered DIFFERENT actions on the glass. The pure parts run in a vm.
+import assert from 'node:assert/strict';
+import { test, after } from 'node:test';
+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';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+const VISOR = read('visor.js');
+
+// ---------- the pure parts, in a vm ----------
+function loadPure() {
+  const listeners = {};
+  const doc = {
+    readyState: 'complete', body: null, documentElement: { dataset: {}, classList: { contains: () => false, toggle() {}, remove() {} } },
+    addEventListener(ev, fn) { listeners[ev] = fn; }, querySelector: () => null, createElement: () => ({}),
+  };
+  const win = { document: doc, location: { pathname: '/', assign() {} }, addEventListener() {} };
+  win.window = win;
+  vm.runInNewContext(VISOR, win);
+  return win.OTBVisor;
+}
+
+test('each character is offered its own actions, and the Artisan\'s and the Artist\'s differ', () => {
+  const V = loadPure();
+  const ids = (c) => JSON.parse(JSON.stringify(V.actionsFor(c).map((a) => a.id))); // out of the vm's realm
+  assert.deepEqual(ids('artisan'), ['claim', 'blockers', 'sky', 'thinking']);
+  assert.deepEqual(ids('artist'), ['review', 'words', 'idea', 'studio']);
+  assert.deepEqual(ids('patron'), ['board', 'city', 'blockers', 'watch']);
+  assert.equal(ids('artisan').filter((id) => ids('artist').includes(id)).length, 0, 'the two glasses share no action');
+  assert.equal(V.actionsFor('nobody').length, 0, 'an unknown character gets nothing, not a default');
+  for (const c of ['artisan', 'artist', 'patron']) {
+    const keys = V.actionsFor(c).map((a) => a.key);
+    assert.equal(new Set(keys).size, keys.length, `${c}: one key per action`);
+    assert.ok(!keys.includes('a'), `${c}: A is the sheet's`);
+    for (const k of keys) assert.ok(!['l', '0', '/', '?', 'f', 'k'].includes(k), `${c}: ${k} is not a key a scene already binds`);
+    for (const a of V.actionsFor(c)) assert.ok(a.href || a.tool, `${c}: ${a.id} opens a page or a tool the hall already has`);
+  }
+});
+
+test('a key means an action only when nothing else spent it', () => {
+  const V = loadPure();
+  const ev = (key, extra = {}) => ({ key, defaultPrevented: false, ctrlKey: false, metaKey: false, altKey: false, ...extra });
+  assert.equal(V.keyFor('artisan', ev('c')).id, 'claim');
+  assert.equal(V.keyFor('artisan', ev('C')).id, 'claim', 'case does not matter');
+  assert.equal(V.keyFor('artisan', ev('a')), 'sheet');
+  assert.equal(V.keyFor('artisan', ev('r')), null, 'the Artist\'s key is not the Artisan\'s');
+  assert.equal(V.keyFor('artisan', ev('c', { defaultPrevented: true })), null, 'a scene that used the key keeps it');
+  for (const m of ['ctrlKey', 'metaKey', 'altKey']) assert.equal(V.keyFor('artisan', ev('c', { [m]: true })), null, `${m} leaves it to the browser`);
+  assert.equal(V.keyFor('artisan', ev('Escape')), null, 'the ambient glass never takes Escape (ADR 0399 §2.4)');
+});
+
+test('credits, never a payout: the count reads as credits, with thousands grouped', () => {
+  const V = loadPure();
+  assert.equal(V.creditsText(56021), '56,021 credits');
+  assert.equal(V.creditsText(1), '1 credit');
+  assert.equal(V.creditsText(0), '0 credits');
+  assert.equal(V.creditsText(null), '');
+  assert.doesNotMatch(V.creditsText(56021), /[$€£]/, 'a count of credits, not a sum of money');
+});
+
+test('source: the visor loads after the shell on every scene page, with its sheet, and nowhere else', () => {
+  for (const f of ['index.html', 'city.html', 'goal-map.html', 'thinking.html']) {
+    const html = read(f);
+    const at = (s) => html.indexOf(s);
+    assert.ok(at('/builders/visor.js') > at('/builders/shell.js?') && at('/builders/shell.js?') > at('/builders/shell-game.js'), `${f}: shell-game, shell, then the visor`);
+    assert.match(html, /<link rel="stylesheet" href="\/builders\/visor\.css/, `${f}: links visor.css`);
+  }
+  for (const f of ['sky-interaction.js', 'city.js', 'home-city.js']) assert.match(read(f), /window\.__visorScene = /, `${f} registers its scene`);
+  assert.doesNotMatch(VISOR, /cam\.(x|y|k)\s*=/, 'the visor writes no camera (ADR 0399 §2.2)');
+  assert.doesNotMatch(VISOR, /setAttribute\('hidden'|\.hidden = true;[^\n]*nav/, 'it hides nothing but itself');
+  assert.match(read('visor.css'), /html\[data-game="on"\] \.visor/, 'game mode only');
+  assert.match(read('visor.css'), /pointer-events: none/, 'the glass lets the pointer through');
+});
+
+// ---------- in a browser: the glass over a stand-in scene ----------
+const lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
+let browser = null;
+try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+const skip = !browser && 'no system Edge or Chrome';
+
+const ORIGIN = 'http://hall.test';
+const TYPES = { '.js': 'text/javascript', '.css': 'text/css', '.png': 'image/png' };
+// The stand-in scene: a canvas filling the window that pans on drag, and the sky's Escape rule.
+const SCENE = `<script>
+  window.cam = { x: 0, y: 0 }; window.picked = true; window.optionsOpened = 0;
+  window.OTBOptions = { escape() { window.optionsOpened++; } };
+  const cv = document.getElementById('world'); let drag = null;
+  cv.addEventListener('pointerdown', (e) => { drag = { x: e.clientX, y: e.clientY, cx: cam.x, cy: cam.y }; });
+  cv.addEventListener('pointermove', (e) => { if (drag) { cam.x = drag.cx - (e.clientX - drag.x); cam.y = drag.cy - (e.clientY - drag.y); } });
+  cv.addEventListener('pointerup', () => { drag = null; });
+  addEventListener('keydown', (e) => { if (e.key === 'Escape' && window.picked) { e.preventDefault(); window.picked = false; } });
+  window.OTBCraftMode = { held: 'artisan', character() { return this.held; }, current() { return null; },
+    me() { return { builder: { total_credits: 56021 } }; }, spriteSrc(id) { return '/builders/characters/' + id + '.png'; }, openTool(id) { window.toolOpened = id; } };
+  window.__visorScene = { name: 'test', place: 'Test city', actions: [{ label: 'Back to centre', key: '0', run() { window.centred = true; } }], keys: [{ label: 'Look around', key: 'drag' }] };
+</script>`;
+const PAGE = (game) => `<!doctype html><html${game ? ' data-game="on"' : ''}><head><meta charset="utf-8">
+<link rel="stylesheet" href="/builders/visor.css"><style>:root{--ink:#111;--ink-soft:#555;--ink-faint:#777;--rule:#ccc;--rule-soft:#ddd;--bg-card:#fff;--bg-deep:#eee;--accent:#fb9569;--accent-on:#111;--accent-deep:#a3481a;--focus:#a3481a}
+body{margin:0}#world{position:fixed;inset:0;width:100vw;height:100vh;display:block}</style></head>
+<body><canvas id="world"></canvas>${SCENE}<script src="/builders/shell-game.js"></script><script src="/builders/visor.js"></script></body></html>`;
+
+async function open({ game = true } = {}) {
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
+  await ctx.route(ORIGIN + '/**', (route) => {
+    const p = new URL(route.request().url()).pathname;
+    if (p === '/' ) return route.fulfill({ contentType: 'text/html', body: PAGE(game) });
+    const f = path.join(HALL, p.replace(/^\/builders\//, ''));
+    if (p.startsWith('/builders/') && TYPES[path.extname(p)] && fs.existsSync(f)) return route.fulfill({ contentType: TYPES[path.extname(p)], body: fs.readFileSync(f) });
+    return route.fulfill({ status: 404, body: '' });
+  });
+  const page = await ctx.newPage();
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(String(e.message)));
+  await page.addInitScript((g) => { try { localStorage.setItem('hall-game', g ? 'on' : 'off'); window.OTB = { escapeHtml: (s) => String(s) }; } catch (_) { /* none */ } }, game);
+  await page.goto(ORIGIN + '/');
+  await page.waitForFunction(() => !!window.OTBVisor);
+  return { ctx, page, errors };
+}
+
+test('outside game mode the hall is as it was: no glass', { skip }, async () => {
+  const { ctx, page, errors } = await open({ game: false });
+  assert.equal(await page.evaluate(() => getComputedStyle(document.getElementById('visor')).display), 'none');
+  assert.deepEqual(errors, []);
+  await ctx.close();
+});
+
+test('in game mode the glass shows the place, the main action, the sprite and the credits', { skip }, async () => {
+  const { ctx, page, errors } = await open();
+  const g = await page.evaluate(() => ({
+    shown: getComputedStyle(document.getElementById('visor')).display,
+    place: document.querySelector('.visor__place').textContent,
+    main: document.querySelector('.visor__pill--main').textContent,
+    who: document.querySelector('.visor__name').textContent,
+    credits: document.querySelector('.visor__credits').textContent,
+    sprite: document.querySelector('.visor__sprite').getAttribute('src'),
+  }));
+  assert.equal(g.shown, 'block');
+  assert.equal(g.place, 'Test city');
+  assert.match(g.main, /^Claim a task/);
+  assert.equal(g.who, 'Artisan');
+  assert.equal(g.credits, '56,021 credits');
+  assert.equal(g.sprite, '/builders/characters/artisan.png');
+  assert.deepEqual(errors, []);
+  await ctx.close();
+});
+
+test('the glass passes the pointer through: a drag over the frame pans the world', { skip }, async () => {
+  const { ctx, page } = await open();
+  // The left side line runs down x≈1.8% of the width; drag straight across it.
+  await page.mouse.move(20, 400); await page.mouse.down(); await page.mouse.move(220, 450, { steps: 5 }); await page.mouse.up();
+  const cam = await page.evaluate(() => window.cam);
+  assert.deepEqual(cam, { x: -200, y: -50 });
+  assert.equal(await page.evaluate(() => document.elementFromPoint(640, 400).id), 'world', 'the centre cross is not a target');
+  await ctx.close();
+});
+
+test('Escape closes one layer, top first: the sheet, then the scene\'s pick, then the options menu', { skip }, async () => {
+  const { ctx, page } = await open();
+  await page.keyboard.press('a');
+  assert.equal(await page.evaluate(() => OTBVisor.isOpen()), true, 'A opens the sheet');
+  await page.keyboard.press('Escape');
+  let s = await page.evaluate(() => ({ open: OTBVisor.isOpen(), picked: window.picked, menu: window.optionsOpened }));
+  assert.deepEqual(s, { open: false, picked: true, menu: 0 }, 'the sheet took the press and stopped it: the star stays picked');
+  await page.keyboard.press('Escape');
+  s = await page.evaluate(() => ({ picked: window.picked, menu: window.optionsOpened }));
+  assert.deepEqual(s, { picked: false, menu: 0 }, 'the scene took the next one');
+  await page.keyboard.press('Escape');
+  await page.waitForTimeout(50);
+  assert.equal(await page.evaluate(() => window.optionsOpened), 1, 'nothing left open: the options menu has it, not the glass');
+  await ctx.close();
+});
+
+test('the sheet lists the character\'s actions, then this place, and runs a scene action', { skip }, async () => {
+  const { ctx, page } = await open();
+  await page.click('[data-visor-sheet]');
+  const rows = await page.$$eval('.visor__sheet .visor__row', (r) => r.map((x) => [...x.children].map((c) => c.textContent).join(' ')));
+  assert.deepEqual(rows, ['Claim a task C', 'Blockers B', 'Goal sky G', 'Your thinking T', 'Back to centre 0', 'Look around drag', 'Options Esc']);
+  await page.click('[data-visor-scene="0"]');
+  assert.deepEqual(await page.evaluate(() => ({ centred: window.centred, open: OTBVisor.isOpen() })), { centred: true, open: false });
+  await ctx.close();
+});
+
+test('an Artist\'s glass offers other actions, and its keys open the Artist\'s tools', { skip }, async () => {
+  const { ctx, page } = await open();
+  await page.evaluate(() => { OTBCraftMode.held = 'artist'; OTBVisor.render(); });
+  assert.match(await page.textContent('.visor__pill--main'), /^Review this page/);
+  await page.keyboard.press('e');
+  assert.equal(await page.evaluate(() => window.toolOpened), 'paintbrush');
+  await ctx.close();
+});
+
+test('the keys wait while someone types, or while a dialog is up', { skip }, async () => {
+  const { ctx, page } = await open();
+  await page.evaluate(() => { const i = document.createElement('input'); i.id = 'field'; document.body.appendChild(i); });
+  await page.focus('#field');
+  await page.keyboard.press('a');
+  assert.equal(await page.evaluate(() => OTBVisor.isOpen()), false, 'typing A in a field is typing');
+  await page.evaluate(() => { document.activeElement.blur(); const d = document.createElement('div'); d.setAttribute('aria-modal', 'true'); document.body.appendChild(d); });
+  await page.keyboard.press('a');
+  assert.equal(await page.evaluate(() => OTBVisor.isOpen()), false, 'a modal dialog has the keyboard');
+  await ctx.close();
+});
+
+test('no character, or no scene: no glass', { skip }, async () => {
+  const { ctx, page } = await open();
+  await page.evaluate(() => { OTBCraftMode.held = null; OTBVisor.render(); });
+  assert.equal(await page.evaluate(() => document.getElementById('visor').hidden), true);
+  await ctx.close();
+});