@bongos/core 1.24.80 → 1.24.81

package/tests/hall_helm.mjs

@@ -0,0 +1,187 @@
+// tests/hall_helm.mjs — Helm, the look the builders' hall wears (task 1005192, ADR 0402).
+//
+// WHY. Two owner decisions are easy to break without anyone seeing it on their own
+// machine: Helm is the hall's alone (the landing, the hub and the status page keep
+// their look), and the hall is dark only (no page offers light, and a light OS never
+// flashes it). Both are decided in one serve-time seam, src/hall-helm.js, which
+// recognises a hall page by the sheet it links. This file runs that seam over the
+// real pages, and holds the pieces of the kit a browser would hide:
+//   * every hall page is served with html[data-theme="dark"], and nothing else is;
+//   * the Helm faces reach a hall whose pack names the default faces, and never a
+//     hall that chose its own, and never the landing or the status page;
+//   * the font stylesheet loads the way tests/google_fonts_nonblocking.mjs asks of
+//     a typed-in link (both preconnects on the page, display=swap), which that sweep
+//     cannot see because the link is built at serve time;
+//   * no hall script writes a theme choice, and the shell offers no switch;
+//   * the Helm neutrals: the two dark twins carry the night, the ice and no black;
+//   * the kit's recipes exist once, as hall-tier tokens and shared rules.
+//
+// Run:  node --test tests/hall_helm.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+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 = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
+const decomment = (css) => css.replace(/\/\*[\s\S]*?\*\//g, '');
+
+const { applyHelm, isHallPage, wearsHelmFaces, stampHtml, HELM_FONTS_HREF } = require('../src/hall-helm.js');
+const { injectBrandingGlobal } = require('../src/bongos/serve-internal.js');
+const { clientBranding, resolveBranding } = require('../src/branding.js');
+
+const NEUTRAL = JSON.parse(read('config', 'branding.neutral.json'));
+const DEFAULTS = NEUTRAL.theme.ui.fonts;
+const hallPages = fs.readdirSync(HALL).filter((f) => f.endsWith('.html'));
+const htmlTag = (html) => (html.match(/<html\b[^>]*>/i) || [''])[0];
+
+// ── the seam ────────────────────────────────────────────────────────────────
+
+test('a hall page is the one that links the hall sheet; the landing, the hub and the status page are not', () => {
+  for (const f of hallPages) assert.ok(isHallPage(read('modules', 'hall-ui', 'public', f)), `${f} links the hall's sheet`);
+  for (const p of [['modules', 'public-landing', 'public', 'index.html'], ['modules', 'public-landing', 'public', 'projects.html'], ['modules', 'status-ui', 'public', 'index.html'], ['modules', 'ui-design', 'public', 'brand.html']]) {
+    assert.equal(isHallPage(read(...p)), false, `${p.join('/')} is not a hall page`);
+  }
+});
+
+test('every hall page is served pinned dark, in the Helm faces, and no other surface is touched', () => {
+  const brand = clientBranding(resolveBranding({ neutral: NEUTRAL }));
+  for (const f of hallPages) {
+    const out = injectBrandingGlobal(read('modules', 'hall-ui', 'public', f), brand, {});
+    const tag = htmlTag(out);
+    assert.match(tag, / data-theme="dark"/, `${f}: dark before first paint`);
+    assert.match(tag, / data-faces="helm"/, `${f}: the Helm faces`);
+    assert.equal((tag.match(/data-theme=/g) || []).length, 1, `${f}: stamped once`);
+    assert.ok(out.includes(`href="${HELM_FONTS_HREF.replace(/&/g, '&amp;')}"`), `${f}: the two families are linked`);
+    // the link follows the pack's own splice, so it is the last word in <head>
+    assert.ok(out.indexOf('Barlow') > out.indexOf('--font-display:'), `${f}: after the pack's :root`);
+  }
+  for (const p of [['modules', 'public-landing', 'public', 'index.html'], ['modules', 'status-ui', 'public', 'index.html']]) {
+    const src = read(...p);
+    const out = injectBrandingGlobal(src, brand, {});
+    assert.equal(htmlTag(out), htmlTag(src), `${p.join('/')}: its <html> tag is as authored`);
+    assert.doesNotMatch(out, /Barlow|data-faces/, `${p.join('/')}: no Helm face`);
+  }
+});
+
+test('a hall that wears faces of its own keeps them; it is still dark only', () => {
+  const page = '<!doctype html><html lang="en"><head><link rel="stylesheet" href="/builders/style.css?v=1"></head><body></body></html>';
+  const own = { fonts: { display: '"Archivo", sans-serif', body: DEFAULTS.body, links: [] } };
+  assert.equal(wearsHelmFaces(own, DEFAULTS), false, 'one face of its own is a pack that chose');
+  const kept = applyHelm(page, own, DEFAULTS);
+  assert.match(htmlTag(kept.html), /data-theme="dark"/);
+  assert.doesNotMatch(kept.html, /data-faces/);
+  assert.equal(kept.tail, '', 'and no Helm stylesheet is linked');
+  // the default faces, and a pack that names none, take Helm
+  assert.equal(wearsHelmFaces({ fonts: { display: DEFAULTS.display, body: DEFAULTS.body } }, DEFAULTS), true);
+  assert.equal(wearsHelmFaces({}, DEFAULTS), true);
+  // a look from the style library with its own faces (ADR 0358) keeps them through the real resolver
+  const looked = clientBranding(resolveBranding({ neutral: NEUTRAL, env: { BONGOS_LOOK: 'expedition' } }));
+  if (looked.theme.look === 'expedition') {
+    const out = injectBrandingGlobal(page, looked, {});
+    assert.match(htmlTag(out), /data-theme="dark"/);
+    assert.doesNotMatch(out, /data-faces|Barlow/, 'the expedition look keeps Archivo');
+  }
+});
+
+test('the stamp replaces an attribute already there and leaves the others alone', () => {
+  assert.equal(stampHtml('<html lang="en" data-artist="on">', 'data-theme', 'dark'), '<html lang="en" data-artist="on" data-theme="dark">');
+  assert.equal(stampHtml('<html data-theme="light" lang="en">', 'data-theme', 'dark'), '<html lang="en" data-theme="dark">');
+  assert.equal(applyHelm('<html><head></head></html>', {}, DEFAULTS).html, '<html><head></head></html>', 'a page with no hall sheet is untouched');
+});
+
+test('the Helm stylesheet loads without blocking: swap, and both preconnects on every hall page', () => {
+  assert.match(HELM_FONTS_HREF, /^https:\/\/fonts\.googleapis\.com\/css2\?/);
+  assert.match(HELM_FONTS_HREF, /[?&]display=swap$/);
+  assert.match(HELM_FONTS_HREF, /family=Barlow\+Condensed:wght@400;500;600/);
+  assert.match(HELM_FONTS_HREF, /family=Barlow:wght@400;500/);
+  const missing = [];
+  for (const f of hallPages) {
+    const html = read('modules', 'hall-ui', 'public', f);
+    if (!/<link rel="preconnect" href="https:\/\/fonts\.googleapis\.com">/.test(html)) missing.push(`${f}: fonts.googleapis.com`);
+    if (!/<link rel="preconnect" href="https:\/\/fonts\.gstatic\.com" crossorigin>/.test(html)) missing.push(`${f}: fonts.gstatic.com (crossorigin)`);
+  }
+  assert.deepEqual(missing, [], 'a hall page that links a web font warms both font origins first');
+});
+
+// ── dark only ───────────────────────────────────────────────────────────────
+
+test('no hall script stores or offers a theme, and the shell pins dark', () => {
+  const shell = read('modules', 'hall-ui', 'public', 'shell.js');
+  assert.match(shell, /function applyTheme\(\) \{\s*document\.documentElement\.dataset\.theme = 'dark';\s*\}/, 'the shell sets dark, whatever was stored');
+  assert.doesNotMatch(shell, /theme-toggle|toggleTheme/, 'no switch on the top bar');
+  const writers = [];
+  for (const f of fs.readdirSync(HALL).filter((x) => x.endsWith('.js'))) {
+    const src = read('modules', 'hall-ui', 'public', f).replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:'"])\/\/.*$/gm, '$1');
+    if (/['"]hall-theme['"]/.test(src)) writers.push(`${f}: names the retired 'hall-theme' preference`);
+    if (/dataset\.theme\s*=\s*(?![\s=]|'dark')|setAttribute\(\s*['"]data-theme['"]\s*,\s*(?!\s|'dark')/.test(src)) writers.push(`${f}: writes a theme other than dark`);
+  }
+  assert.deepEqual(writers, []);
+  for (const f of hallPages) assert.doesNotMatch(read('modules', 'hall-ui', 'public', f), /id="(theme-toggle|cityMode|streetMode)"/, `${f}: no light/dark switch`);
+  assert.doesNotMatch(decomment(read('modules', 'hall-ui', 'public', 'style.css')), /\.theme-toggle/, 'and no styles for one');
+});
+
+// ── the Helm tier ───────────────────────────────────────────────────────────
+
+const STYLE = read('modules', 'hall-ui', 'public', 'style.css');
+const blockAt = (marker) => {
+  const at = STYLE.indexOf(marker);
+  assert.notEqual(at, -1, `style.css holds ${marker}`);
+  const open = STYLE.indexOf('{', at);
+  let depth = 0;
+  for (let i = open; i < STYLE.length; i++) {
+    if (STYLE[i] === '{') depth++;
+    else if (STYLE[i] === '}' && --depth === 0) return STYLE.slice(open + 1, i);
+  }
+  throw new Error('unbalanced');
+};
+const decls = (body) => Object.fromEntries([...decomment(body).matchAll(/(--[\w-]+)\s*:\s*([^;]+);/g)].map((m) => [m[1], m[2].replace(/\s+/g, ' ').trim()]));
+const root = decls(blockAt('\n:root {'));
+const dark = decls(blockAt('html[data-theme="dark"] {'));
+
+test('the dark tier is the Helm neutrals: night grounds, white and ice inks, ice hairlines', () => {
+  assert.deepEqual(
+    Object.fromEntries(['--bg', '--bg-card', '--bg-deep', '--bg-frame', '--ink', '--ink-soft', '--rule', '--rule-soft', '--void'].map((k) => [k, dark[k]])),
+    { '--bg': '#050d16', '--bg-card': '#0a1622', '--bg-deep': '#050d16', '--bg-frame': '#07111b', '--ink': '#ffffff', '--ink-soft': '#c8f1f7', '--rule': 'rgba(200, 241, 247, .4)', '--rule-soft': 'rgba(200, 241, 247, .2)', '--void': '#050d16' },
+  );
+  // the accent is still the pack's: the moon is never pinned (the Unpinned Accent Rule)
+  for (const name of ['--accent', '--accent-deep', '--sea', '--terracotta', '--font-display', '--font-body']) assert.equal(dark[name], undefined, `${name} is not set in the dark tier`);
+  // in dark a label is the name voice
+  assert.equal(dark['--label-face'], 'var(--font-display)');
+});
+
+test('the Helm faces are hall-tier tokens, handed to the two font tokens only under html[data-faces="helm"]', () => {
+  assert.match(root['--helm-display'], /^"Barlow Condensed", /);
+  assert.match(root['--helm-body'], /^"Barlow", /);
+  // the contract tier still equals the pack (tests/hall_tokens.mjs holds that); Helm does not overwrite it there
+  assert.equal(root['--font-display'], DEFAULTS.display);
+  const faces = decls(blockAt('\nhtml[data-faces="helm"] {'));
+  assert.deepEqual(faces, { '--font-display': 'var(--helm-display)', '--font-body': 'var(--helm-body)' });
+  assert.equal((decomment(STYLE).match(/Barlow/g) || []).length, 2, 'the family names live once each, in the token block');
+  for (const f of fs.readdirSync(HALL).filter((x) => x.endsWith('.css') && x !== 'style.css')) {
+    assert.doesNotMatch(read('modules', 'hall-ui', 'public', f), /Barlow/, `${f} takes the face from the tokens`);
+  }
+});
+
+test('the kit\'s recipes are named once: the name voice, the cut, the segment, the panel over art', () => {
+  assert.equal(root['--name-face'], 'var(--font-display)');
+  assert.equal(root['--name-case'], 'uppercase');
+  for (const k of ['--name-space', '--name-space-wide', '--name-space-tight']) {
+    const em = Number((root[k].match(/^(\.\d+)em$/) || [])[1]);
+    assert.ok(em >= 0.16 && em <= 0.3, `${k} is wide tracking (${root[k]})`);
+  }
+  assert.equal(root['--cut'], '12px');
+  assert.equal(root['--seg-skew'], '-28deg');
+  assert.equal(root['--night-glass'], 'color-mix(in srgb, var(--bg) 72%, transparent)');
+  const controls = decomment(read('modules', 'hall-ui', 'public', 'controls.css'));
+  const seg = controls.match(/\n\.seg \{([^}]*)\}/);
+  assert.ok(seg, 'the segment is a shared rule');
+  assert.match(seg[1], /transform: skewX\(var\(--seg-skew\)\);/);
+  assert.match(seg[1], /height: var\(--seg-h\);/);
+  assert.match(controls, /\n\.seg--done \{ background: var\(--ink-soft\);/, 'a finished step is information, so it is ice, not the accent');
+  assert.match(controls, /\n\.seg--now \{ background: var\(--accent\);/, 'the accent is the step you can act on');
+});

package/tests/hall_record_world.mjs

@@ -152,14 +152,16 @@ test('.btn and .btn--ghost are defined, and say what .btn-accent / .btn-ghost sa
   assert.match(btn, /background:\s*var\(--accent\)/, '.btn is the accent door');
   assert.match(btn, /color:\s*var\(--accent-on\)/, '--accent-on is the dark ink for the salmon');
   const shape = ruleHolding(controlsCss, '.btn', 'border-radius');
-  assert.match(shape, /border-radius:\s*var\(--radius-pill\)/, 'pill or nothing (DESIGN.md, Shapes)');
+  // Helm (task 1005192, ADR 0402): the hall's corner is the cut; the pill is the fallback where the hall's tier is not loaded
+  assert.match(shape, /border-radius:\s*var\(--press-radius, var\(--radius-pill\)\)/, 'the cut corner in the hall, the pill elsewhere (DESIGN.md, The hall)');
+  assert.match(shape, /clip-path:\s*var\(--cut-path, none\)/, 'anything you can press takes the cut corner');
   // collab.css's .btn--quiet sets only a border-COLOUR; a modifier cannot paint
   // an edge that was never reserved, so the base has to carry a transparent one.
   assert.match(shape, /border:\s*var\(--line\)\s+solid\s+transparent/,
     'the edge is reserved so a modifier that sets only border-color still draws');
   const ghost = ruleHolding(controlsCss, '.btn--ghost', 'background');
   assert.ok(ghost, '.btn--ghost has a rule');
-  assert.match(ghost, /background:\s*transparent/, 'the quiet sibling is a hairline pill, not a fill');
+  assert.match(ghost, /background:\s*var\(--press-fill, transparent\)/, 'the quiet sibling is the press fill inside a hairline, never the accent');
   assert.equal(ghost, ruleHolding(controlsCss, '.btn-ghost', 'background'), 'and .btn-ghost says the same, in the same rule');
   assert.match(ghost, /border-color:\s*var\(--rule\)/, 'and it takes the reserved edge');
 });

package/tests/hall_start_screen.mjs

@@ -82,6 +82,16 @@ test('the tips rotate, and every one is a sentence', () => {
   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' };
@@ -113,6 +123,13 @@ test('Home loads the sheet and the script, and the sheet types in no size, corne
   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 ----------
@@ -130,8 +147,8 @@ const SCRIPTS = ['dom-utils.js', 'welcome-boot.js', 'shell-game.js', 'shell-trai
   .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 });
+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 });
@@ -180,6 +197,27 @@ test('a sign-in passes through the start screen and the load screen before the w
   }));
   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');
@@ -201,7 +239,11 @@ test('a sign-in passes through the start screen and the load screen before the w
   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' },
@@ -211,6 +253,27 @@ test('a sign-in passes through the start screen and the load screen before the w
   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);

package/tests/hall_street.mjs

@@ -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_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`);

package/tests/nav_permission_atoms.mjs

@@ -103,7 +103,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // task 1005070: the remembered nav (the rail paints before /me).
 // task 1005088: the sidebar mark is drawn by reference to the one brand mark.
 // task 1005144: My agents, Project settings, Permissions and Modules left for the options menu.
-const SHELL_SHA = 'fb82186606e781b5';
+const SHELL_SHA = 'a4d41b30b41e49f4';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);