@bongos/core 1.24.79 → 1.24.81

package/tests/hall_start_screen.mjs

@@ -0,0 +1,307 @@
+// 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('the load screen fills one segment per week, up to the week it is showing (task 1005192)', () => {
+  const { window } = sandbox();
+  const G = window.OTBShellGame;
+  assert.equal(G.segsDone(10, 0), 1, 'the oldest week is the first segment');
+  assert.equal(G.segsDone(10, 4.5), 5);
+  assert.equal(G.segsDone(10, 9), 10, 'now fills the row');
+  assert.equal(G.segsDone(10, 99), 10, 'never more than there are weeks');
+  assert.equal(G.segsDone(0, 0), 0);
+});
+
+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');
+  // Helm (task 1005192, ADR 0402): the literal floor is zero, the voice and the panel are the hall tier's tokens
+  assert.doesNotMatch(css, /rgba?\(|hsla?\(|box-shadow:\s*[\d-]|text-shadow:\s*[\d-]|font-family:(?!\s*var\()/, 'no typed colour, shadow or face');
+  assert.match(css, /\.gs__title \{[^}]*font-family: var\(--name-face\);[^}]*letter-spacing: var\(--name-space-wide\); text-transform: var\(--name-case\);/, 'the title is the name voice');
+  assert.match(css, /\.gs__item \{[^}]*font-family: var\(--name-face\);[^}]*text-transform: var\(--name-case\);/, 'so is every choice');
+  assert.match(css, /\.gs__menu, \.gs__load \{[^}]*background: var\(--night-glass\);/, 'both panels are the night over the art');
+  assert.match(css, /\.gs__item\[data-gs="start"\] \{\s*background: var\(--accent\); color: var\(--accent-on\);/, 'Start is the one thing lit, under the dark ink');
+  assert.match(css, /\.gs__item:focus-visible \{[^}]*box-shadow: var\(--press-focus\);/, 'a row rings inside itself, in two tones');
+});
+
+// ---------- 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', viewport = { width: 1280, height: 800 } } = {}) {
+  const ctx = await browser.newContext({ viewport, 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 });
+
+  // Helm (task 1005192): one full-height night panel on the left, the mark over the name, a line at the foot.
+  const panel = await page.evaluate(() => {
+    const box = (sel) => { const r = document.querySelector(sel).getBoundingClientRect(); return { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height) }; };
+    const start = document.querySelector('[data-gs="start"]'), title = document.getElementById('gs-title');
+    return {
+      menu: box('.gs__menu'), start: box('[data-gs="start"]'), view: { w: window.innerWidth, h: window.innerHeight },
+      mark: !!document.querySelector('.gs__head .gs__mark'), line: document.getElementById('gs-line').textContent,
+      caps: getComputedStyle(title).textTransform, startCaps: getComputedStyle(start).textTransform,
+      key: getComputedStyle(start, '::after').content, sideways: document.getElementById('game-start').scrollWidth - document.getElementById('game-start').clientWidth,
+    };
+  });
+  assert.equal(panel.menu.w, 400, 'the panel is 400 wide on a desk');
+  assert.ok(panel.menu.x > 0 && panel.menu.x < panel.view.w / 4, 'and stands on the left, off the edge');
+  assert.deepEqual([panel.menu.y, panel.menu.h], [0, panel.view.h], 'the full height of the screen');
+  assert.ok(panel.start.w >= panel.menu.w - 4, 'Start is a bar the width of the panel');
+  assert.equal(panel.mark, true, 'the mark stands over the name');
+  assert.match(panel.line, /^[A-Z].*\.$/, 'the foot carries one sentence');
+  assert.deepEqual([panel.caps, panel.startCaps], ['uppercase', 'uppercase'], 'names are capitals');
+  assert.equal(panel.key, '"Enter"', 'Start names the key that takes it');
+  assert.equal(panel.sideways, 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');
+  const weeks = JSON.parse(CITY).weeks.length;
+  assert.equal(await page.evaluate(() => document.querySelectorAll('#gs-segs:not([hidden]) > .seg').length), weeks, 'one segment per week of the history');
+  await page.waitForFunction(() => { const w = document.getElementById('gs-when'); return !w || w.textContent === 'The city, now'; });
+  const segs = await page.evaluate(() => { const b = document.getElementById('gs-segs'); return b ? [b.querySelectorAll('.seg--done').length, b.getAttribute('aria-hidden')] : null; });
+  if (segs) assert.deepEqual(segs, [weeks, 'true'], 'at now every segment is filled; the words beside them say it, so the row is hidden from a screen reader');
+  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('on a phone the panel is the whole width, nothing scrolls sideways and every choice clears the floor (task 1005192)', { skip }, async () => {
+  for (const [w, h] of [[390, 844], [320, 700]]) {
+    const ctx = await hall({ viewport: { width: w, height: h } });
+    const { page, errors } = await signedIn(ctx);
+    await page.waitForSelector('#game-start');
+    const m = await page.evaluate(() => {
+      const gs = document.getElementById('game-start'), r = document.querySelector('.gs__menu').getBoundingClientRect();
+      return {
+        x: Math.round(r.left), w: Math.round(r.width), sideways: gs.scrollWidth - gs.clientWidth,
+        small: Array.from(document.querySelectorAll('.gs__item')).filter((e) => !e.closest('[hidden]')).filter((e) => { const b = e.getBoundingClientRect(); return b.height < 24 || b.width < 24 || b.right > window.innerWidth + 1; }).length,
+      };
+    });
+    assert.deepEqual(m, { x: 0, w, sideways: 0, small: 0 }, `at ${w}px`);
+    await page.click('[data-gs="start"]');
+    await page.waitForSelector('#gs-load:not([hidden])');
+    assert.equal(await page.evaluate(() => { const gs = document.getElementById('game-start'); return gs.scrollWidth - gs.clientWidth; }), 0, `the load screen fits ${w}px`);
+    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');
 });
@@ -488,7 +488,8 @@ test('the page holds the prototype\'s header, the street, the readings and the c
   assert.equal((html.match(/<main\b/g) || []).length, 1);
   assert.equal((html.match(/<h1\b/g) || []).length, 1);
   assert.match(html, /<a class="street-mark" id="streetHome" href="\/builders\/city"[^>]*>\{\{productName\}\}</);
-  for (const id of ['hudNeeds', 'hudMoving', 'hudShare', 'streetMode', 'streetSigns', 'streetPins', 'streetDoors', 'streetCard']) assert.match(html, new RegExp(`id="${id}"`), id);
+  assert.doesNotMatch(html, /streetMode/, 'no light/dark switch: the hall is dark only (task 1005192, ADR 0402)');
+  for (const id of ['hudNeeds', 'hudMoving', 'hudShare', 'streetSigns', 'streetPins', 'streetDoors', 'streetCard']) assert.match(html, new RegExp(`id="${id}"`), id);
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
   assert.deepEqual(scripts.filter((s) => !/^street-(deck|office)$/.test(s)), ['dom-utils', 'shell-game', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'street-draw', 'street-card', 'street-inside', 'street-depth', 'street-desk', 'street-amend', 'street'], 'the hall shell (task 1004544), the living model and its one reader (task 1004685: city-draw.js counts with it, so it loads first), the shared kit, then the card (task 1004528), the interiors (task 1004526), the living street\'s exterior (street-depth.js), the floor desk (task 1004558) and the drafted amendment (task 1004530); the deck rides beside them');
   assert.equal(City.STREET_HREF, '/builders/street', 'the city\'s door is this page');
@@ -552,7 +553,7 @@ function fakeDom() {
   };
   const focused = { el: null };
   const html = mk('html');
-  const ids = ['streetMode', 'streetModeIcon', 'streetModeWord', 'streetWindow', 'streetSizer', 'streetBoard', 'streetSvg', 'streetFlat', 'streetBlds', 'streetCrates', 'streetCols', 'streetGroups', 'streetDoors', 'streetPins', 'streetSigns', 'streetEvening', 'streetEveningLine', 'hudNeeds', 'hudMoving', 'hudShare', 'hudDot', 'streetHome', 'streetCard', 'streetCardWhere', 'streetCardWhen', 'streetCardTitle', 'streetCardBody', 'streetCardOpen', 'streetCardClose', 'streetToast'];
+  const ids = ['streetWindow', 'streetSizer', 'streetBoard', 'streetSvg', 'streetFlat', 'streetBlds', 'streetCrates', 'streetCols', 'streetGroups', 'streetDoors', 'streetPins', 'streetSigns', 'streetEvening', 'streetEveningLine', 'hudNeeds', 'hudMoving', 'hudShare', 'hudDot', 'streetHome', 'streetCard', 'streetCardWhere', 'streetCardWhen', 'streetCardTitle', 'streetCardBody', 'streetCardOpen', 'streetCardClose', 'streetToast'];
   for (const id of ids) mk('x').setAttribute('id', id);
   const document = { documentElement: html, getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_ns, t) => mk(t) };
   return { document, byId, html, focused };
@@ -701,32 +702,18 @@ test('the header counts wear the pins\' colours, so they double as the legend',
   assert.ok(size('urgent') > size('needs') && size('needs') > size('moving') && size('moving') > size('settled'), 'urgent > needs > moving > settled');
 });
 
-test('the switch reads and writes the hall\'s own theme preference and redraws the street', async () => {
-  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: true });
-  assert.equal(p.html.attrs['data-theme'], 'light', 'the stored hall choice beats the OS');
-  assert.equal(p.byId.get('streetMode').attrs['aria-label'], 'Switch to dark mode');
-  assert.equal(p.byId.get('streetModeWord').textContent, 'dark');
-  const before = JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs);
-  p.byId.get('streetMode').fire('click');
-  assert.equal(p.store.get('hall-theme'), 'dark');
-  assert.equal(p.html.attrs['data-theme'], 'dark');
-  assert.notEqual(JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs), before, 'the street redraws in the new mode');
-});
-
-test('in the hall, the street and the top bar\'s theme switch never disagree (task 1004544)', async () => {
-  let shellPaints = 0;
-  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: true, shell: { applyTheme() { shellPaints++; } } });
-  assert.equal(p.observers.length, 1, 'the page watches html[data-theme]');
-  p.byId.get('streetMode').fire('click');
-  assert.equal(shellPaints, 1, 'this switch repaints the shell\'s');
-  const before = JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs);
-  p.store.set('hall-theme', 'light'); p.html.setAttribute('data-theme', 'light'); // the shell's switch
-  p.observers[0].fn();
-  assert.equal(p.byId.get('streetModeWord').textContent, 'dark', 'this switch follows the shell\'s');
-  assert.notEqual(JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs), before, 'and the street redraws in that mode');
-  assert.equal(shellPaints, 1, 'following the shell does not echo back to it');
+test('the street is dark only: no stored choice and no OS setting reaches it (task 1005192, ADR 0402)', async () => {
+  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: false, shell: { applyTheme() { throw new Error('the street no longer drives the shell'); } } });
+  assert.equal(p.html.attrs['data-theme'], 'dark', 'a stored light choice and a light OS are both ignored');
+  assert.equal(p.store.get('hall-theme'), 'light', 'and the old preference is never written');
+  assert.equal(p.observers.length, 0, 'nothing flips the theme, so nothing watches it');
+  const q = await bootPage({ feeds: FEEDS([]), stored: null, osDark: true });
+  assert.equal(JSON.stringify(q.byId.get('streetBlds').children[0].children[0].attrs), JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs), 'one drawing whatever was stored');
+  assert.doesNotMatch(read('street.js'), /hall-theme|prefers-color-scheme/, 'street.js reads no theme preference');
 });
 
+
+
 test('arriving through a door marks that building, and a failed docket says so', async () => {
   const p = await bootPage({ feeds: FEEDS([]), hash: '#building=treasury' });
   const here = p.byId.get('streetDoors').children.filter((a) => a.attrs['aria-current'] === 'location');

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_topbar_320.mjs

@@ -63,7 +63,7 @@ async function measureBar(width, scheme) {
   const ctx = await context(width, scheme);
   const page = await ctx.newPage();
   await page.goto(ORIGIN + '/work');
-  await page.waitForSelector('#app-topbar .topbar-side #theme-toggle');
+  await page.waitForSelector('#app-topbar .topbar-side #zoom-toggle');
   return page.evaluate(() => {
     const side = document.querySelector('#app-topbar .topbar-side');
     if (!document.getElementById('upd-pill')) {
@@ -86,9 +86,11 @@ for (const scheme of ['light', 'dark']) {
   test(`at 320px the top bar fits, every button inside it and at least 24px (${scheme})`, { skip }, async () => {
     const m = await measureBar(320, scheme);
     const ids = m.buttons.map((b) => b.id);
-    for (const want of ['upd-pill', 'topbar-jump', 'zoom-toggle', 'theme-toggle', 'fullscreen-toggle']) {
+    for (const want of ['upd-pill', 'topbar-jump', 'zoom-toggle', 'fullscreen-toggle']) {
       assert.ok(ids.includes(want), `${want} is on the bar (got ${ids.join(', ')})`);
     }
+    // the hall is dark only (task 1005192, ADR 0402): the bar offers no light/dark switch
+    assert.ok(!ids.includes('theme-toggle'), 'no theme switch on the bar');
     assert.ok(m.scrollWidth <= 320, `the page is ${m.scrollWidth}px wide at 320 (the top bar spills)`);
     for (const b of m.buttons) {
       assert.ok(b.left >= 0 && b.right <= 320, `${b.id} sits at ${Math.round(b.left)}..${Math.round(b.right)}, outside 0..320`);