@bongos/core 1.24.54 → 1.24.56

package/tests/hall_city.mjs

@@ -25,6 +25,7 @@ import path from 'node:path';
 import vm from 'node:vm';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
+import { cityTokens } from './helpers.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const PUB = path.join(ROOT, 'modules/hall-ui/public');
@@ -66,13 +67,13 @@ test('the nine civic recipes draw exactly the prototype paths, in both modes', (
       const a = []; const b = [];
       p.isoInstitution(a, pk, kind, x, y, { fixes: false });
       City.isoInstitution(b, ck, kind, x, y, { fixes: false });
-      assert.deepEqual(b, a, `${mode} ${kind}`);
+      assert.deepEqual(b, cityTokens(a), `${mode} ${kind}`);
     }
   }
 });
 
 test('the iso sub-palette is the prototype theme().iso, both modes', () => {
-  for (const mode of ['dark', 'light']) assert.deepEqual(City.isoTheme(mode), new Proto({ mode }).theme(mode).iso, mode);
+  for (const mode of ['dark', 'light']) assert.deepEqual(City.isoTheme(mode), cityTokens(new Proto({ mode }).theme(mode).iso), mode);
 });
 
 test('every work kind the prototype draws is drawn the same way', () => {
@@ -83,7 +84,7 @@ test('every work kind the prototype draws is drawn the same way', () => {
     const a = []; const b = [];
     p.isoWork(a, pk, 6, 2, kind, 58);
     City.isoWork(b, ck, 6, 2, kind, 58);
-    assert.deepEqual(b, a, kind);
+    assert.deepEqual(b, cityTokens(a), kind);
   }
 });
 
@@ -95,7 +96,7 @@ test('the ground, ring road, lanes and plaza are the prototype home view, path f
   const home = p.homeView(T, p.matters(), false);
   const model = City.cityModel({ docket: docket([matter()]), goals: [], rollups: [], mode: 'light' });
   // The prototype's flat list is ground, 4 roads, lanes, plaza, then its 4 plots and their grid.
-  assert.deepEqual(model.flat.slice(0, 7), home.flat.slice(0, 7));
+  assert.deepEqual(model.flat.slice(0, 7), cityTokens(home.flat.slice(0, 7)));
 });
 
 test('with four goals the districts sit on the prototype\'s four plots, in its order', () => {

package/tests/hall_private_palettes.mjs

@@ -0,0 +1,148 @@
+// tests/hall_private_palettes.mjs — the hall's private-palette rooms mix the shared tokens only
+// (task 1005087, goal 1000138 "One Cloud Bongos design system").
+//
+// The UI audit found Studio, Thinking (the sky), the Tweak editor, City, Approvals, Atlas and the
+// welcome screen each re-typing the salmon and the ink, their own font stacks, and off-the-shelf
+// green / amber / red — so a re-branded instance saw those rooms in Cloud Bongos's colours. This
+// scans every sheet and script of those rooms (comments stripped) and fails on:
+//   * a hex, an rgb()/rgba() or a bare [r, g, b] triple equal to one of the pack's colours, the
+//     hall's dark-tier inks, the accent's light tint, or an off-the-shelf status green/amber/red;
+//   * a font family typed in by name instead of the pack's stacks;
+//   * an overshooting (bounce) easing;
+//   * the welcome screen's beacon or star twinkle coming back.
+// Black and white (with or without alpha) stay legal: they are scrims, halos and the glass rooms'
+// inks. Each guard was watched go red on the pre-task sheets.
+import { test, after } 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 kit = require('../modules/ui-design/kit/lib.js');
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const ROOMS = /^(studio|thinking|sky-|tweak-editor|city|approval-queue|atlas|welcome-boot)/;
+const FILES = fs.readdirSync(PUB).filter((f) => ROOMS.test(f) && /\.(css|js|html)$/.test(f));
+
+const strip = (s) => s.replace(/\/\*[\s\S]*?\*\//g, '').replace(/<!--[\s\S]*?-->/g, '').replace(/(^|[^:'"`\\])\/\/[^\n]*/g, '$1');
+
+const PACK = Object.values(JSON.parse(fs.readFileSync(path.join(ROOT, 'config', 'branding.neutral.json'), 'utf8')).theme.ui.colors);
+const BRAND = new Set([...PACK,
+  // the hall's dark-tier inks and grounds, and the accent's light tint the glass rooms used for links
+  '#101012', '#08080a', '#c0c0c0', '#a8a8a8', '#fcbfa4', '#96410f',
+  // off-the-shelf status green / amber / red (Tailwind's, and the rooms' own copies of them)
+  '#10b981', '#22c55e', '#4ade80', '#16a34a', '#15803d', '#166534', '#1f7a44',
+  '#f59e0b', '#fbbf24', '#facc15', '#d97706', '#b45309', '#92400e', '#8f6a0c',
+  '#ef4444', '#dc2626', '#b91c1c', '#991b1b', '#f87171', '#bb1f1f',
+].map((h) => h.toLowerCase()));
+const tripleOf = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16)).join(',');
+const TRIPLES = new Set([...BRAND].map(tripleOf));
+
+function brandLiterals(src) {
+  const s = strip(src);
+  const hits = [];
+  for (const m of s.matchAll(/#[0-9a-f]{6}\b/gi)) if (BRAND.has(m[0].toLowerCase())) hits.push(m[0]);
+  for (const m of s.matchAll(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/gi)) if (TRIPLES.has(`${+m[1]},${+m[2]},${+m[3]}`)) hits.push(m[0]);
+  for (const m of s.matchAll(/\[\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]/g)) if (TRIPLES.has(`${+m[1]},${+m[2]},${+m[3]}`)) hits.push(m[0]);
+  for (const m of s.matchAll(/--[a-z-]+-rgb\s*:\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/gi)) if (TRIPLES.has(`${+m[1]},${+m[2]},${+m[3]}`)) hits.push(m[0]);
+  return hits;
+}
+
+test('the rooms are all here (the scan is not vacuous)', () => {
+  for (const f of ['studio.css', 'thinking.css', 'sky-draw.js', 'tweak-editor.css', 'city.css', 'city-draw.js', 'approval-queue.css', 'atlas.css', 'atlas.js', 'welcome-boot.css', 'welcome-boot.js']) {
+    assert.ok(FILES.includes(f), `${f} is scanned`);
+  }
+});
+
+test('no hex, rgb or [r, g, b] literal for a brand colour or an off-the-shelf status colour remains', () => {
+  const found = {};
+  for (const f of FILES) { const h = brandLiterals(fs.readFileSync(path.join(PUB, f), 'utf8')); if (h.length) found[f] = [...new Set(h)]; }
+  assert.deepEqual(found, {}, 'mix the shared tokens (the pack\'s, the status vocabulary) instead');
+});
+
+test('the scan catches each shape of brand literal, and spares black, white and comments', () => {
+  assert.deepEqual(brandLiterals('a { color: #FB9569; }'), ['#FB9569']);
+  assert.deepEqual(brandLiterals('a { color: rgba(23, 24, 26, .4); }'), ['rgba(23, 24, 26']);
+  assert.deepEqual(brandLiterals('const ACC = [251, 149, 105];'), ['[251, 149, 105]']);
+  assert.deepEqual(brandLiterals('--sky-accent-rgb: 251,149,105;'), ['--sky-accent-rgb: 251,149,105']);
+  assert.deepEqual(brandLiterals("dot: '#f59e0b'"), ['#f59e0b']);
+  assert.deepEqual(brandLiterals('/* was #fb9569 */ a { color: rgba(0, 0, 0, .5); background: #ffffff; }'), []);
+});
+
+test('no room types a font family by name: the pack\'s stacks only', () => {
+  const hits = [];
+  for (const f of FILES.filter((n) => /\.(css|js)$/.test(n))) {
+    const s = strip(fs.readFileSync(path.join(PUB, f), 'utf8'));
+    if (/Manrope|JetBrains Mono|Segoe UI|Helvetica|Arial\b/.test(s)) hits.push(f);
+  }
+  assert.deepEqual(hits, [], 'use var(--font-body) / var(--font-display) / var(--font-mono)');
+});
+
+test('no bounce: no easing in the rooms overshoots (use --ds-ease / --ds-ease-arrive)', () => {
+  const hits = [];
+  for (const f of FILES) {
+    const s = strip(fs.readFileSync(path.join(PUB, f), 'utf8'));
+    for (const m of s.matchAll(/cubic-bezier\(\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\)/g)) {
+      if (+m[2] > 1 || +m[4] > 1 || +m[2] < 0 || +m[4] < 0) hits.push(`${f}: ${m[0]}`);
+    }
+  }
+  assert.deepEqual(hits, []);
+});
+
+test('the welcome screen keeps no beacon and no twinkle', () => {
+  const css = strip(fs.readFileSync(path.join(PUB, 'welcome-boot.css'), 'utf8'));
+  const js = strip(fs.readFileSync(path.join(PUB, 'welcome-boot.js'), 'utf8'));
+  assert.doesNotMatch(css, /wb-beacon|wb-twinkle/, 'no beacon blink, no star twinkle in the sheet');
+  assert.doesNotMatch(js, /wb-beacon/, 'the script draws no beacon');
+  assert.doesNotMatch(js, /\.wb-star[^]*animation-duration/, 'no star carries a twinkle timing');
+});
+
+// ── the done-when, in a browser: a re-branded look renders the rooms in its own colours ──
+// The ui-design kit's stub serves the hall under a look from the style library (grove: a
+// sand accent), and every computed colour on each room is checked for the neutral pack's
+// salmon. Skips when the machine has no system Edge or Chrome, as ui_design_kit_fit does.
+let browser = null;
+try { browser = await kit.launchBrowser(); } catch (e) { if (!(e instanceof kit.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+
+test('under the grove look, Thinking, the Tweak editor, Atlas, City and Studio show no salmon in either mode', { skip: !browser && 'no system Edge or Chrome', timeout: 180000 }, async () => {
+  const stub = await kit.startStub({ surface: 'hall-ui', prefix: '/builders/', style: 'grove', auth: true });
+  try {
+    for (const mode of ['dark', 'light']) {
+      const ctx = await browser.newContext({ viewport: { width: 1280, height: 860 }, colorScheme: mode });
+      await ctx.addInitScript(() => { try { sessionStorage.setItem('hall-craft-asked', '1'); } catch (e) { /* private mode */ } });
+      for (const room of ['thinking', 'tweak-editor', 'atlas', 'city', 'studio']) {
+        const page = await ctx.newPage();
+        await page.goto(`${stub.base}/builders/${room}`, { waitUntil: 'load' });
+        await page.waitForTimeout(800);
+        const r = await page.evaluate(() => {
+          const SALMON = /\b251,\s*149,\s*105\b/;
+          const hits = [];
+          for (const el of document.querySelectorAll('*')) {
+            const cs = getComputedStyle(el);
+            for (const k of ['color', 'backgroundColor', 'borderTopColor', 'fill', 'stroke', 'outlineColor', 'boxShadow', 'backgroundImage']) {
+              if (SALMON.test(cs[k] || '')) hits.push(`${el.tagName.toLowerCase()} ${k}`);
+            }
+          }
+          return { accent: getComputedStyle(document.documentElement).getPropertyValue('--accent').trim().toLowerCase(), hits };
+        });
+        await page.close();
+        assert.notEqual(r.accent, '#fb9569', `${mode} ${room}: the look's accent is applied`);
+        assert.deepEqual(r.hits, [], `${mode} ${room}: no salmon left`);
+      }
+      await ctx.close();
+    }
+  } finally { stub.stop(); }
+});
+
+test('the sky reads its colours off the stage as tokens, not channels', () => {
+  const css = strip(fs.readFileSync(path.join(PUB, 'thinking.css'), 'utf8'));
+  assert.doesNotMatch(css, /--sky-[a-z]+-rgb/, 'no rgb channel tokens');
+  assert.match(css, /--void:\s*var\(--bg\)/, 'the void is the hall\'s ground');
+  assert.match(css, /--accent:\s*var\(--accent-ink\)/, 'the accent is the pack\'s (darkened on paper by the hall\'s own rule)');
+  const draw = fs.readFileSync(path.join(PUB, 'sky-draw.js'), 'utf8');
+  for (const tok of ['--ink', '--void', '--sky-cold', '--accent', '--chart']) assert.match(draw, new RegExp(`fill\\('${tok}'`), `sky-draw reads ${tok}`);
+});

package/tests/hall_sky.mjs

@@ -559,65 +559,62 @@ const skyBlocks = () => {
   return { dark: dark && dark[1], light: light && light[1], twin: twin && twin[1] };
 };
 
+// What the stage's computed style answers in each theme: the two blocks above,
+// read the way the browser would.
+const stageStyles = (body) => Object.fromEntries([...body.matchAll(/(--[\w-]+)\s*:\s*([^;]+);/g)].map((m) => [m[1], m[2].trim()]));
+
 await test('LIGHT IS WRITTEN TWICE AND THE TWO ARE ONE — the data-theme block and its first-paint twin declare the same lines', () => {
   const { dark, light, twin } = skyBlocks();
-  assert.ok(dark, 'the dark (template) token block is found');
+  assert.ok(dark, 'the stage token block is found');
   assert.ok(light, 'the html[data-theme="light"] block is found');
   assert.ok(twin, 'the prefers-color-scheme: light twin is found');
   same(declLines(twin), declLines(light), 'the twin is the data-theme block, line for line');
-  assert.ok(declLines(light).length >= 6, 'and the block is not vacuously empty');
-});
-
-await test('light re-declares every colour the dark set declares, and every channel is three bytes', () => {
-  const { dark, light } = skyBlocks();
-  const type = new Set(['--label', '--mono', '--face']); // the faces are not a theme
-  const want = [...declNames(dark)].filter((n) => !type.has(n));
-  assert.ok(want.length >= 15, `the dark set names its colours (${want.length})`);
-  const have = declNames(light);
-  same(want.filter((n) => !have.has(n)), [], 'no dark colour is left for light to inherit');
-  for (const [name, body] of [['dark', dark], ['light', light]]) {
-    const chans = [...body.matchAll(/(--sky-[\w-]+-rgb)\s*:\s*([^;]+);/g)];
-    assert.ok(chans.length >= 5, `${name} declares the canvas's channels`);
-    for (const [, n, v] of chans) {
-      const parts = v.split(',').map((x) => Number(x.trim()));
-      assert.ok(parts.length === 3 && parts.every((x) => Number.isInteger(x) && x >= 0 && x <= 255), `${name} ${n} is r,g,b (got "${v}")`);
-    }
-  }
+  same([...declNames(light)].sort(), ['--sky-drop', '--sky-temp', 'color-scheme'], 'and it carries only what the hall\'s own tier cannot: the card shadow and the canvas warmth');
 });
 
-// What the stage's computed style answers in each theme: the two blocks above,
-// read the way the browser would.
-const stageStyles = (body) => Object.fromEntries([...body.matchAll(/(--[\w-]+)\s*:\s*([^;]+);/g)].map((m) => [m[1], m[2].trim()]));
+// task 1005087: the sky's colours are the HALL's tokens, which already flip with the theme and
+// follow the pack, so a re-branded instance's sky wears its colours. No literal, no rgb channel.
+await test('the stage mixes the hall\'s tokens only: every colour is a var() or a color-mix of them', () => {
+  const { dark } = skyBlocks();
+  const type = new Set(['--label', '--mono', '--face', '--sky-temp', '--sky-drop']);
+  const colours = Object.entries(stageStyles(dark)).filter(([n]) => !type.has(n));
+  assert.ok(colours.length >= 10, `the stage names its colours (${colours.length})`);
+  for (const [n, v] of colours) assert.match(v, /^(var\(--[\w-]+\)|color-mix\(in srgb, var\(--[\w-]+\) [\d.]+%, (transparent|var\(--[\w-]+\))\))$/, `${n}: ${v}`);
+  assert.doesNotMatch(SKY_CSS.replace(/\/\*[\s\S]*?\*\//g, ''), /--sky-[\w-]+-rgb/, 'no rgb channel is left');
+});
+
+// The stage's computed colours in each theme, as the browser answers the probe sky-draw.js reads.
+const DARK = { '--ink': 'rgb(255, 255, 255)', '--void': 'rgb(0, 0, 0)', '--sky-cold': 'color(srgb 0.08 0.08 0.08)', '--accent': 'rgb(251, 149, 105)', '--chart': 'rgb(251, 191, 36)', '--sky-temp': '1' };
+const LIGHT = { '--ink': 'rgb(23, 24, 26)', '--void': 'rgb(237, 236, 238)', '--sky-cold': 'color(srgb 0.88 0.88 0.89)', '--accent': 'rgb(163, 72, 26)', '--chart': 'rgb(180, 83, 9)', '--sky-temp': '.42' };
 
 await test('THE CANVAS FOLLOWS THE TOGGLE — a theme flip re-reads the stage and repaints, with no reload', async () => {
-  const { dark, light } = skyBlocks();
-  const styles = stageStyles(dark);
+  const styles = { ...DARK };
   const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions(), styles });
   const SKY = p.SKY(); const acc = SKY.ACC;
   assert.ok(p.themeObservers() >= 1, 'the page watches html[data-theme]');
   p.frame();
-  same(SKY.INK, [255, 255, 255], 'dark: the ink is the template white');
+  same(SKY.INK, [255, 255, 255], 'dark: the ink is the hall\'s white');
   same(SKY.VOID, [0, 0, 0], 'dark: the void is black');
   same(SKY.tone([255, 238, 222]), [255, 238, 222], 'dark: a thought keeps its temperature');
 
-  Object.assign(styles, stageStyles(light));
+  Object.assign(styles, LIGHT);
   p.S().dirty = false;
   p.setTheme('light');
   assert.equal(!!p.S().dirty, true, 'the flip marks the sky for a redraw');
   p.frame();
-  same(SKY.INK, stageStyles(light)['--sky-ink-rgb'].split(',').map(Number), 'light: the ink is the stage\'s');
-  same(SKY.VOID, stageStyles(light)['--sky-void-rgb'].split(',').map(Number), 'light: the void is paper');
-  same(SKY.ACC, stageStyles(light)['--sky-accent-rgb'].split(',').map(Number), 'light: the accent darkens');
+  same(SKY.INK, [23, 24, 26], 'light: the ink is the stage\'s');
+  same(SKY.VOID, [237, 236, 238], 'light: the void is paper');
+  same(SKY.ACC, [163, 72, 26], 'light: the accent darkens');
   assert.equal(SKY.ACC === acc, true, 'refilled in place, so SKY.ACC is still the object every file holds');
-  const k = Number(stageStyles(light)['--sky-temp']);
-  same(SKY.tone([255, 238, 222]), [255, 238, 222].map((v) => Math.round(v * k)), 'light: a near-white thought darkens to read on paper');
+  same(SKY.tone([255, 238, 222]), [255, 238, 222].map((v) => Math.round(v * 0.42)), 'light: a near-white thought darkens to read on paper');
   assert.equal(SKY.ink(0.5), `rgba(${SKY.INK.join(',')},0.5)`, 'ink() paints in the new ink');
 
-  Object.assign(styles, stageStyles(dark));
+  Object.assign(styles, DARK);
   p.setTheme('dark');
   p.frame();
   same(SKY.INK, [255, 255, 255], 'and back: the white returns');
   assert.equal(SKY.ink(0.5), 'rgba(255,255,255,0.5)', 'ink() forgot the light strings');
 });
 
+
 summary();

package/tests/hall_street.mjs

@@ -26,6 +26,7 @@ import path from 'node:path';
 import vm from 'node:vm';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
+import { cityTokens } from './helpers.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const PUB = path.join(ROOT, 'modules/hall-ui/public');
@@ -83,7 +84,7 @@ test('the street palette is the prototype theme() (less the iso half city-draw.j
     const t = new Proto({ mode }).theme(mode);
     delete t.iso;
     assert.deepEqual(S.theme(mode), t, mode);
-    assert.deepEqual(City.isoTheme(mode), new Proto({ mode }).theme(mode).iso, 'and the iso half is still city-draw.js\'s');
+    assert.deepEqual(City.isoTheme(mode), cityTokens(new Proto({ mode }).theme(mode).iso), 'and the iso half is still city-draw.js\'s');
   }
 });
 
@@ -123,7 +124,7 @@ test('a task not started is the prototype\'s workItem "ready" slab, and the more
   const a = []; const b = [];
   p.workItem(a, T, 'engineer', 'ready', 660, 19, 0);
   S.work(b, S.theme('dark'), 'slab', 660, 0, 19, 6, false);
-  assert.deepEqual(b, a, 'the slab, at a base of 0 as workItem draws it');
+  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);
   S.work(d, S.theme('dark'), 'stakes', 660, 0, 40, 0, false);

package/tests/helpers.mjs

@@ -980,7 +980,12 @@ export function bootSkyPage({
     setTimeout: windowObj.setTimeout, clearTimeout: windowObj.clearTimeout,
     MutationObserver, console, Event, URLSearchParams, Math, Number, Date, JSON, Map, Set, Promise, Object, Array, String, Infinity, NaN,
   };
-  if (styles) sandbox.getComputedStyle = (el) => ({ getPropertyValue: (name) => (el && String(el.className || '').split(/\s+/).includes('sky-stage') && name in styles ? styles[name] : '') });
+  if (styles) sandbox.getComputedStyle = (el) => ({
+    getPropertyValue: (name) => (el && String(el.className || '').split(/\s+/).includes('sky-stage') && name in styles ? styles[name] : ''),
+    // task 1005087: sky-draw.js resolves a colour token by computing it on a probe
+    // (style.color = 'var(--ink)'); `styles` answers it with the computed colour.
+    get color() { const m = /var\((--[\w-]+)\)/.exec(String((el && el.style && el.style.color) || '')); return (m && styles[m[1]]) || ''; },
+  });
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
   for (const [name, src] of SKY_SRC) vm.runInContext(src, sandbox, { filename: name });
@@ -1355,3 +1360,22 @@ export async function insertTestBuilders(db, rows, { onConflict = 'ON CONFLICT (
   );
   return out;
 }
+
+// The governor city's iso palette moved onto the pack's tokens (task 1005087): city-draw.js
+// writes var(--bg-card), var(--accent) and color-mix()es of --ink / --sea / --accent where
+// docs/design/mocks/governor-city/Street.dc.html (the design of record) has the neutral pack's
+// literals. Mapping the prototype's output through the same substitution keeps the "draws
+// exactly the prototype's paths" tests honest: every path, every other colour, unchanged.
+export function cityTokens(x) {
+  const pct = (a) => `${Math.round(parseFloat(a) * 1000) / 10}%`;
+  const one = (s) => s
+    .replace(/^rgba\(23,24,26,([.\d]+)\)$/, (m, a) => `color-mix(in srgb, var(--ink) ${pct(a)}, transparent)`)
+    .replace(/^rgba\(91,111,208,([.\d]+)\)$/, (m, a) => `color-mix(in srgb, var(--sea) ${pct(a)}, transparent)`)
+    .replace(/^rgba\(251,149,105,([.\d]+)\)$/, (m, a) => `color-mix(in srgb, var(--accent) ${pct(a)}, transparent)`)
+    .replace(/^#fbfafc$/, 'var(--bg-card)')
+    .replace(/^#fb9569$/, 'var(--accent)');
+  if (typeof x === 'string') return one(x);
+  if (Array.isArray(x)) return x.map(cityTokens);
+  if (x && typeof x === 'object') return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, cityTokens(v)]));
+  return x;
+}

package/tests/welcome_boot.mjs

@@ -62,7 +62,7 @@ test('both paintings ship, as WebP, in the one shape the motion is laid out for'
 
 test('every light sits inside the painting, and every pulse climbs inside its tower', () => {
   const inside = ([x, y]) => x >= 0 && x <= W.AW && y >= 0 && y <= W.AH;
-  for (const b of W.BEACONS) assert.ok(inside(b), 'beacon ' + b);
+  assert.equal(W.BEACONS, undefined, 'the blinking mast lights are gone (task 1005087)');
   for (const t of W.TOWERS) assert.ok(inside([t.x, t.y]) && inside([t.x + t.w, t.y + t.h]), 'tower inside the painting');
   const runs = W.pulseRuns(W.TOWERS, 3, 7);
   assert.equal(runs.length, W.TOWERS.length * 3);

package/tests/welcome_boot_browser.mjs

@@ -264,7 +264,7 @@ const look = (page) => page.evaluate(() => {
 test('by day the day painting opens from a white veil; by night the night one from black, with its lights', { skip }, async () => {
   for (const [time, want] of [
     [new Date(2026, 9, 23, 10, 0), { day: true, night: false, veil: 'rgb(255, 255, 255)', art: '/builders/welcome-day.webp', beacons: 0 }],
-    [new Date(2026, 9, 23, 22, 0), { day: false, night: true, veil: 'rgb(0, 0, 0)', art: '/builders/welcome-night.webp', beacons: 4 }],
+    [new Date(2026, 9, 23, 22, 0), { day: false, night: true, veil: 'rgb(0, 0, 0)', art: '/builders/welcome-night.webp', beacons: 0 }], // task 1005087 took the beacons out
   ]) {
     const ctx = await hall({ time });
     const { page } = await open(ctx);