@bongos/core 1.24.80 → 1.24.82

package/tests/hall_fullscreen.mjs

@@ -94,7 +94,8 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
     get cookie() { return ''; }, set cookie(_v) {},
   };
   const assigned = []; // task 1005144: where the page sent the browser (game mode's Escape opens the menu)
-  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/' + page + search, pathname: path || '/' + page, hash, search, assign(u) { assigned.push(u); }, replace() {} };
+  const replaced = []; // task 1005200: a classic page in game mode sends the browser to the city
+  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/' + page + search, pathname: path || '/' + page, hash, search, assign(u) { assigned.push(u); }, replace(u) { replaced.push(u); } };
   // `session` is the TAB's sessionStorage: pass one object to several boots and
   // they are page loads in one tab (the trail, task 1004476).
   const sessionStorage = {
@@ -135,6 +136,7 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
   return {
     store,
     assigned,
+    replaced,
     game: () => windowObj.OTBShellGame,
     gameStamp: () => root.dataset.game === 'on',
     // The "how to leave" line: showing = the shell created it and it is not hidden.
@@ -517,17 +519,36 @@ test('game mode: every hall page carries the switch — none opts out, and each
   }
 });
 
-test('game mode: leaving brings the bars back for THIS page only, and never rewrites a page\'s own memory', () => {
+// task 1005200 (owner, 2026-11-11): game OR classic, never both. Inside game mode there is
+// no way back to the bars — the corner button is hidden (style.css) and, pressed
+// anyway, does nothing; Escape is the options menu's, where the view is switched.
+test('game mode: there is no way back to the bars inside it, and a page\'s own memory is never rewritten', () => {
   const store = { 'hall-game': 'on', 'hall-fullscreen:thinking': 'on' };
-  const goals = boot({ page: 'goals', optIn: false, store });
-  goals.button().click();
-  assert.equal(goals.on(), false, 'the corner button still leaves (Escape opens the options menu, below)');
-  assert.equal(store['hall-fullscreen:goals'], undefined, 'nothing remembered for the page');
-  assert.equal(boot({ page: 'goals', optIn: false, store }).on(), true, 'the next load opens without bars again');
+  const profile = boot({ page: 'profile', optIn: false, store });
+  profile.button().click();
+  assert.equal(profile.on(), true, 'the corner button does not leave game mode');
+  assert.equal(store['hall-fullscreen:profile'], undefined, 'nothing remembered for the page');
   const sky = boot({ page: 'thinking', store });
   sky.button().click();
-  assert.equal(sky.on(), false, 'the corner button leaves too');
+  sky.press('Escape');
+  assert.equal(sky.on(), true, 'nor does Escape');
   assert.equal(store['hall-fullscreen:thinking'], 'on', 'the sky\'s own choice survives game mode');
+  assert.match(read('style.css'), /html\[data-game="on"\] \.fullscreen-toggle \{ display: none; \}/, 'and the button is not drawn');
+});
+
+test('game mode: only the game\'s places are there — a classic page sends the browser to the city', () => {
+  const store = { 'hall-game': 'on' };
+  assert.deepEqual(boot({ page: 'goals', optIn: false, store }).replaced, ['/'], 'Goals is a classic page');
+  assert.deepEqual(boot({ page: 'work', optIn: false, store, path: '/builders/work' }).replaced, ['/builders/'], 'on the apex too');
+  for (const page of ['home', 'city', 'goal-map', 'thinking', 'atlas', 'settings', 'profile']) {
+    assert.deepEqual(boot({ page, optIn: false, store }).replaced, [], `${page} is a game place`);
+  }
+  assert.deepEqual(boot({ page: 'goals', optIn: false, store: {} }).replaced, [], 'classic reaches every page');
+  const G = boot({ page: 'city', store }).game();
+  assert.equal(G.isPlace('/city'), true);
+  assert.equal(G.isPlace('/builders/'), true);
+  assert.equal(G.isPlace('/work'), false);
+  assert.equal(G.isPlace('/blockers?x=1'), false);
 });
 
 // task 1005144 (BONGOS-V3 R04, ADR 0399 §2.4 row 6): in game mode the last Escape is the
@@ -562,35 +583,35 @@ test('game mode: the Escape hand-off is unchanged — a press the page used, or
 
 test('game mode: set() switches the page live, and turning it off hands each page back its own memory', () => {
   const store = { 'hall-fullscreen:thinking': 'on' };
-  const goals = boot({ page: 'goals', optIn: false, store });
+  const goals = boot({ page: 'profile', optIn: false, store });
   goals.game().set(true);
   assert.equal(store['hall-game'], 'on');
   assert.equal(goals.on(), true, 'on at once, no reload');
   assert.ok(goals.resizes() >= 1, 'a page that sizes to its box is told to re-measure');
   goals.game().set(false);
-  assert.equal(goals.on(), false, 'goals remembered nothing, so its bars return');
+  assert.equal(goals.on(), false, 'the profile remembered nothing, so its bars return');
   assert.equal(goals.gameStamp(), false);
-  assert.equal(store['hall-fullscreen:goals'], undefined, 'and switching the mode wrote nothing for the page');
+  assert.equal(store['hall-fullscreen:profile'], undefined, 'and switching the mode wrote nothing for the page');
+  const work = boot({ page: 'work', optIn: false, store: {} });
+  work.game().set(true);
+  assert.deepEqual(work.replaced, ['/'], 'switched to game on a classic page: to the city');
   const sky = boot({ page: 'thinking', store: Object.assign(store, { 'hall-game': 'on' }) });
   sky.game().set(false);
   assert.equal(sky.on(), true, 'the sky had chosen full screen itself, and keeps it');
 });
 
-test('game mode: ?game=on / ?game=off set it from the URL; anything else is ignored', () => {
+test('game mode: the address does not switch it — Options and the sign-in chooser do (task 1005200)', () => {
   const store = {};
-  assert.equal(boot({ page: 'work', optIn: false, store, search: '?game=on' }).on(), true);
-  assert.equal(store['hall-game'], 'on');
-  assert.equal(boot({ page: 'goals', optIn: false, store }).on(), true, 'and it holds on the next page');
-  assert.equal(boot({ page: 'work', optIn: false, store, search: '?game=off' }).on(), false);
-  boot({ page: 'work', optIn: false, store, search: '?game=%22%3E%3Cimg%3E' });
-  assert.equal(store['hall-game'], 'off', 'a value that is not on/off is not stored');
+  assert.equal(boot({ page: 'profile', optIn: false, store, search: '?game=on' }).on(), false);
+  assert.equal(store['hall-game'], undefined, 'nothing stored from the URL');
+  assert.doesNotMatch(read('shell-game.js'), /get\('game'\)/, 'the ?game= reader is gone');
 });
 
-test('game mode: how to leave is said once per tab, not on every page; outside it the shell\'s rule stands', () => {
+test('game mode never says how to leave full screen (there is no leaving); outside it the shell\'s rule stands', () => {
   const store = { 'hall-game': 'on' };
   const session = {};
-  assert.equal(boot({ page: 'goals', optIn: false, store, session }).hintShowing(), true, 'the first page says it');
-  assert.equal(boot({ page: 'work', optIn: false, store, session }).hintShowing(), false, 'the next does not repeat it');
+  assert.equal(boot({ page: 'profile', optIn: false, store, session }).hintShowing(), false, 'no line in game mode');
+  assert.equal(boot({ page: 'city', store, session }).hintShowing(), false);
   const own = { 'hall-fullscreen:thinking': 'on' };
   assert.equal(boot({ page: 'thinking', store: own, session: {} }).hintShowing(), true);
   assert.equal(boot({ page: 'thinking', store: own, session: {} }).hintShowing(), true, 'a remembered page says it on every open, as before');

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 });
@@ -171,15 +188,45 @@ test('a sign-in passes through the start screen and the load screen before the w
   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');
+    'the start screen, not the welcome and not the picker; game mode is not on until it is chosen');
+  // task 1005200: first the chooser — game or classic — then, for game, the start screen.
+  const views = await page.evaluate(() => ({
+    items: Array.from(document.querySelectorAll('.gs__items:not([hidden]) .gs__item')).map((e) => e.textContent),
+    focus: document.activeElement.textContent,
+  }));
+  assert.deepEqual(views, { items: ['GameThe city, full screen', 'ClassicThe hall with its sidebar'], focus: 'GameThe city, full screen' });
+  await page.keyboard.press('Enter');
+  await page.waitForSelector('#gs-items:not([hidden])');
+  assert.equal((await state(page)).game, 'on', 'choosing Game turns game mode on');
   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),
+    items: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras):not([hidden]) .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,
+    small: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras):not([hidden]) .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');
@@ -201,7 +248,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,11 +262,57 @@ test('a sign-in passes through the start screen and the load screen before the w
   await ctx.close();
 });
 
+// task 1005200: Classic at the chooser — the screen goes, game mode is off, and the account
+// is told. The view chosen last time is the one marked and focused.
+test('choosing Classic at sign-in closes the screen, leaves game mode off, and saves it to the account', { skip }, async () => {
+  const ctx = await hall();
+  const saved = [];
+  await ctx.route(ORIGIN + '/api/bongos/me/hall-view', (route) => {
+    if (route.request().method() === 'PATCH') saved.push(JSON.parse(route.request().postData()));
+    return route.fulfill({ contentType: 'application/json', body: JSON.stringify({ view: null }) });
+  });
+  const page = await ctx.newPage();
+  await page.addInitScript(() => { try { localStorage.setItem('hall-welcome-signin', '1'); localStorage.setItem('hall-game', 'off'); } 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); });
+  await page.waitForSelector('#game-start');
+  assert.equal(await page.evaluate(() => document.activeElement.textContent), 'ClassicLast timeThe hall with its sidebar', 'the view chosen last time is focused and marked');
+  await page.keyboard.press('Enter');
+  await page.waitForSelector('#game-start', { state: 'detached' });
+  assert.equal((await state(page)).game, null);
+  assert.deepEqual(saved, [{ view: 'classic' }]);
+  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="view-game"]');
+    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="view-game"]');
   await page.click('[data-gs="quit"]');
   await page.waitForSelector('#gs-note:not([hidden])');
   assert.equal(await page.evaluate(() => window.__closed), 1);
@@ -228,6 +325,7 @@ test('with no city to draw, or with reduced motion, the still and the tip stand
     const ctx = await hall(opts);
     const { page, errors } = await signedIn(ctx);
     await page.waitForSelector('#game-start');
+    await page.click('[data-gs="view-game"]');
     await page.click('[data-gs="start"]');
     await page.waitForSelector('#gs-load:not([hidden])');
     assert.match(await page.textContent('#gs-tip'), /\.$/);

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