@bongos/core 1.24.30 → 1.24.32

package/tests/hall_builders_page_pass.mjs

@@ -117,42 +117,33 @@ function renderLandingHtml(joinability) {
   return html();
 }
 
-test('A: the apply door gives signing in a real button, not a footnote link', () => {
+// The sign-in redesign made the sign-in button the card's one primary control
+// in EVERY mode; only the door beneath it depends on joinability.
+const SIGNIN = /class="landing__btn landing__btn--block" id="landing-signin" href="\/api\/bongos\/auth\/web\/start"/;
+const signInCount = (html) => (html.match(/href="\/api\/bongos\/auth\/web\/start"/g) || []).length;
+
+test('A: the apply door leads with sign-in and folds the request form under it', () => {
   const html = renderLandingHtml('apply');
-  assert.match(html, /landing__returning/, 'the apply door renders a returning-builder block');
-  assert.match(
-    html,
-    /class="landing__btn landing__btn--quiet" href="\/api\/bongos\/auth\/web\/start"/,
-    'that block carries a real sign-in control in the quiet fill',
-  );
-  // The whole point of the change: the footnote link is GONE from this door, so
-  // there is exactly one sign-in path and it is the button.
-  assert.ok(
-    !/Already a member\? <a /.test(html),
-    'the apply door no longer repeats sign-in as a prose link under the form',
-  );
-  assert.match(html, /We store only your GitHub login/, 'the privacy sentence survives the note');
-  // Two controls total: request access, and sign in. Not three.
-  assert.equal(countButtons(html), 2, 'the apply door carries the request button and the sign-in button');
+  assert.match(html, SIGNIN, 'sign-in is a real primary button');
+  assert.equal(signInCount(html), 1, 'exactly one sign-in path — never a second prose link');
+  assert.match(html, /<details class="landing__disclosure">[\s\S]*id="access-request-form"/, 'the request form sits behind a disclosure');
+  assert.ok(html.indexOf('landing-signin') < html.indexOf('access-request-form'), 'sign-in comes first');
+  assert.equal(countButtons(html), 2, 'two controls: sign in, and request access');
 });
 
-test('A: the two doors that already had a sign-in button do not grow a second', () => {
+test('A: the open and invite-only doors carry one sign-in control and no form', () => {
   for (const mode of ['open', 'invite_only']) {
     const html = renderLandingHtml(mode);
-    assert.ok(
-      !/landing__returning/.test(html),
-      `the ${mode} door does not add a returning block — its primary door already signs you in`,
-    );
-    assert.equal(countButtons(html), 1, `the ${mode} door carries exactly one sign-in control`);
-    assert.match(html, /Already a member\? <a /, `the ${mode} door keeps its prose note for returning builders`);
+    assert.match(html, SIGNIN, `the ${mode} door signs in with the same button`);
+    assert.equal(signInCount(html), 1, `the ${mode} door has exactly one sign-in path`);
+    assert.ok(!/access-request-form/.test(html), `the ${mode} door has nothing to apply with`);
+    assert.equal(countButtons(html), 1, `the ${mode} door carries exactly one control`);
   }
 });
 
 test('A: an older branding pack with no joinability falls back to the apply door', () => {
-  // joinabilityMode() treats anything but open/invite_only as 'apply', so the
-  // button must follow that fallback — not sit behind a field an older pack
-  // never sent.
-  assert.match(renderLandingHtml(null), /landing__returning/);
+  // joinabilityMode() treats anything but open/invite_only as 'apply'.
+  assert.match(renderLandingHtml(null), /id="access-request-form"/);
 });
 
 test('A: the quiet fill is a defined variant, not an inline colour', () => {

package/tests/hall_loading.mjs

@@ -83,7 +83,7 @@ test('the page loaders step aside by themselves, and never show without :has()',
   assert.match(STYLE, /\.hall-loading--wait, \.hall-loading--zones \{ display: none; \}/);
   assert.match(STYLE, /@supports selector\(:has\(a\)\) \{\s*\.hall-loading--wait:not\(:has\(~ :not\(\[hidden\], script, template, style\)\)\) \{ display: flex; \}\s*\.hall-loading--zones:not\(:has\(~ :not\(\[hidden\]\) > :not\(\[hidden\], script, template, style\)\)\) \{ display: flex; \}\s*\}/);
   // A page whose sections all start [hidden] carries the --wait loader FIRST in its main.
-  for (const page of ['board-room', 'deploy', 'fleet', 'gate', 'government', 'market-watch-settings', 'project-settings', 'sessions']) {
+  for (const page of ['board-room', 'deploy', 'fleet', 'gate', 'government', 'project-settings', 'sessions']) {
     const html = read(`${page}.html`);
     const main = html.slice(html.indexOf('<main id="hall-main">'));
     const first = main.replace(/<main id="hall-main">\s*(<!--[\s\S]*?-->\s*)*/, '');

package/tests/hall_nav.mjs

@@ -321,9 +321,16 @@ test('sidebar groups read by audience, in order', () => {
   // the steering surfaces because that is what it is — the owner's third release gate.
   // 'fleet' (task 1001949) follows it at the metic floor of `provisioning.fleet.manage`:
   // what each hosted project costs is an operator surface, like the rest of this group.
-  // 'market-watch-settings' (task 1004938) is the owner's Market Watch switch and AI cap,
-  // archon like its four routes, and dropped where the market-watch module is off.
-  assert.deepEqual(nav[4].items.map((i) => i.id), ['watch', 'gate', 'sessions', 'project-settings', 'deploy', 'fleet', 'market-watch-settings', 'government']);
+  // 'market-watch-settings' (task 1004938) LEFT the group in task 1005045: the owner saw
+  // "Market Watch" twice and had to guess which was which (owner decision 2026-11-03,
+  // idea 1001310). The settings are an owner-only Settings tab on /market-watch now.
+  assert.deepEqual(nav[4].items.map((i) => i.id), ['watch', 'gate', 'sessions', 'project-settings', 'deploy', 'fleet', 'government']);
+  // task 1005045: and no label is left twice anywhere in the sidebar, so the next pair
+  // fails here instead of in front of the owner.
+  const labels = [...boot().sidebarHtml.matchAll(/<a class="nav-item" [^>]*>[\s\S]*?<span class="nav-item__label">([^<]*)<\/span>/g)].map((m) => m[1]);
+  assert.ok(labels.includes('Market Watch'), 'the labels were actually read');
+  assert.deepEqual(labels.filter((l, i) => labels.indexOf(l) !== i), [], 'every sidebar label is said once');
+  assert.ok(!nav.flatMap((g) => g.items).some((i) => i.href === '/market-watch-settings'), 'no item points at the retired settings page');
 });
 
 test('Economy lives in Docs and points at the reward-schedule page', () => {
@@ -755,7 +762,7 @@ test('no glyph path data reads as an IP address to the release leak scan', () =>
 // block (task 1004713). These drive the real shell and the real gov-positions.js.
 
 const tick = () => new Promise((resolve) => setImmediate(resolve));
-const GOVERNING = ['board-room', 'city', 'watch', 'gate', 'sessions', 'project-settings', 'deploy', 'fleet', 'market-watch-settings', 'government'];
+const GOVERNING = ['board-room', 'city', 'watch', 'gate', 'sessions', 'project-settings', 'deploy', 'fleet', 'government'];
 const lead = (building, title) => ({ kind: 'lead', seat: 'lead:' + building, building, title });
 const block = (held) => ({ held, title: held.length ? held[0].title : null, has_position: held.length > 0 });
 

package/tests/hall_page_gate_map.mjs

@@ -56,10 +56,11 @@ const ORACLE = {
   // settings. Every read behind it is the viewer's own (GET /me, /me/* prefs,
   // /specialities) and requireBuilder, so sign-in is the whole gate.
   '/builders/my-agents': 'requireBuilderPage',
-  // task 1004938: the owner's Market Watch settings. Its read and writes are
-  // owner-only (atom + owner seat) (tests/market_watch_settings.mjs proves the 403s), and the
-  // shell carries no data, so sign-in is the page tier and the routes are the wall.
-  '/builders/market-watch-settings': 'requireBuilderPage',
+  // Gone (task 1005045, owner decision 2026-11-03): the owner's Market Watch settings
+  // (task 1004938) are an owner-only Settings tab on /market-watch now, and the old URL
+  // 302s to /market-watch#settings before any gate runs. A redirect is not a page; the
+  // four settings routes keep their own owner-only wall (tests/market_watch_settings.mjs).
+  '/builders/market-watch-settings': null,
   // task 1004939: the Market Watch home and tracked-item pages. Every member of the
   // project reads them; both reads are requireBuilder, so sign-in is the whole gate.
   '/builders/market-watch': 'requireBuilderPage',
@@ -347,6 +348,8 @@ const GONE_PAGES = {
   // Task 1003444 — the owner deleted the hall's cross-project directory; the hub
   // community page (task 1003363) is its home, and /people redirects to /roster.
   '/builders/people': 'task 1003444 — the hall has no cross-project directory; /people redirects to /roster',
+  // Task 1005045 — one sidebar item for Market Watch: its settings are a tab on the page.
+  '/builders/market-watch-settings': 'task 1005045 — the settings are the Settings tab on /market-watch; the old URL redirects there',
 };
 
 test('a row that is null because the page left the hall serves no page', () => {

package/tests/home_city.mjs

@@ -20,6 +20,7 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 process.env.NODE_ENV = 'test';
 const city = require(path.join(ROOT, 'modules/lifecycle/home-city.js'));
 const Draw = require(path.join(ROOT, 'modules/hall-ui/public/home-city-draw.js'));
+const Gov = require(path.join(ROOT, 'modules/hall-ui/public/city-draw.js'));
 const FIXTURE = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/home__city.json'), 'utf8'));
 
 const { test, summary } = makeRunner();
@@ -127,12 +128,12 @@ function fakePool({ tables = {} } = {}) {
 }
 
 await test('every read is bounded by the window, the areas or a LIMIT, and never selects a task body', async () => {
-  const pool = fakePool({ tables: { government_board_votes: true, autonomy_runner_heartbeat: true, government_asks: true } });
+  const pool = fakePool({ tables: { government_board_votes: true, autonomy_runner_heartbeat: true, government_asks: true, ideas_votes: true } });
   await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'archon' } }, { pool, getFocusVersionId: async () => null });
   const data = pool.seen.filter((q) => !/to_regclass|date_trunc\('week'|FROM versions/.test(q.sql));
   assert.ok(data.length >= 8, 'the summary reads areas, weeks, leads, people, ideas, govern, sites and waiting');
   for (const q of data) {
-    const bounded = /LIMIT \d+/.test(q.sql) || /goal_id = ANY\(\$1::bigint\[\]\)/.test(q.sql) || /(shipped_at|captured_at|cast_at|resolved_at) >= \$1/.test(q.sql) || /b\.id = ANY/.test(q.sql);
+    const bounded = /LIMIT \d+/.test(q.sql) || /goal_id = ANY\(\$1::bigint\[\]\)/.test(q.sql) || /(shipped_at|captured_at|cast_at|resolved_at|recorded_at) >= \$1/.test(q.sql) || /b\.id = ANY/.test(q.sql);
     assert.ok(bounded, `unbounded read:\n${q.sql}`);
     assert.doesNotMatch(q.sql, /description|body_md|value_summary/, 'the city never downloads prose it does not draw');
   }
@@ -320,8 +321,20 @@ await test('the fixture is a shape the drawing accepts, and the tallest areas st
   assert.equal(m.W, 10);
   assert.ok(m.areas.length > 5);
   assert.ok(m.areas[0].total >= m.areas[m.areas.length - 1].total);
-  assert.equal(m.areas[0].y, 0.8, 'the tallest tower is in the back row');
-  assert.ok(m.areas.slice(5).every((a) => a.y > 0.8), 'the shorter half stands in front');
+  const back = (a) => a.x + a.y;
+  assert.deepEqual([m.areas[0].x, m.areas[0].y], Draw.RING[0], 'the tallest tower takes the back corner');
+  assert.ok(m.areas.every((a, n) => n === 0 || back(a) >= back(m.areas[n - 1])), 'each shorter area stands no farther back than a taller one');
+});
+
+await test('the ring of plots stays off the civic core and the museum, and no two plots overlap (v16)', () => {
+  const F = 1.8, C = Draw.CORE, MUSEUM = { x0: 4.6, y0: 10.9, x1: 11.4, y1: 19.2 };
+  const hit = (a, b) => a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
+  const plots = Draw.RING.map(([x, y]) => ({ x0: x, y0: y, x1: x + F, y1: y + F }));
+  plots.forEach((p, n) => {
+    assert.ok(!hit(p, C), `plot ${n} stands clear of the civic plaza`);
+    assert.ok(!hit(p, MUSEUM), `plot ${n} stands clear of the museum and its garden`);
+    plots.slice(n + 1).forEach((q) => assert.ok(!hit(p, q), 'plots do not overlap'));
+  });
 });
 
 await test('more areas than the ground holds are reported, not drawn', () => {
@@ -370,16 +383,198 @@ await test('ledger text is never markup: titles and names travel as attribute va
     people: [{ id: '9', name: '"><script>x</script>', build: [1], art: [0], idea: [0], gov: [0] }],
     ideas: [{ id: '3', week: 0, by: '9', title: '<b>idea</b>' }], now: { sites: [{ goal_id: '1', builder_id: '9' }] } };
   const ns = all(Draw.citySvg(Draw.cityModel(hostile), 0, { mode: 'light' }).nodes);
-  const SHAPES = new Set(['defs', 'radialGradient', 'stop', 'path', 'line', 'circle', 'g', 'rect', 'text', 'clipPath', 'image']);
+  const SHAPES = new Set(['defs', 'radialGradient', 'stop', 'path', 'line', 'circle', 'ellipse', 'g', 'a', 'rect', 'text', 'clipPath', 'image']);
   assert.deepEqual([...new Set(ns.map((n) => n.tag))].filter((t) => !SHAPES.has(t)), [], 'only SVG shapes, whatever a title says');
   assert.ok(ns.some((n) => n.attrs['data-tip'] === '<img src=x onerror=alert(1)>'), 'the title rides as an attribute value, set with setAttribute');
   assert.ok(ns.some((n) => n.tag === 'text' && n.text === '"'), 'a name\'s initial is a text node');
 });
 
+// v16 (task 1005058): one city for every craft, its districts as doors
+const linksOf = (ns) => ns.filter((n) => n.tag === 'a');
+await test('the civic core is drawn by city-draw.js itself, and the whole district is ONE door to the street', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const ns = all(Draw.citySvg(m, m.W - 1, { mode: 'dark', gov: Gov }).nodes);
+  const core = linksOf(ns).filter((n) => /\bhc-core\b/.test(n.attrs.class));
+  assert.equal(core.length, 1, 'one link for the nine buildings, not nine');
+  assert.equal(core[0].attrs.href, Gov.STREET_HREF);
+  // the same paths city-draw.js's recipe draws for the Charter, in its own palette
+  const k = Gov.isoKit(50, 25, 0, 0, 0.82, Gov.isoTheme('dark'), true), charter = [];
+  Gov.isoInstitution(charter, k, 'charter', 0, 0, {});
+  const fills = new Set(all([core[0]]).map((n) => n.attrs.fill));
+  charter.forEach((p) => assert.ok(fills.has(p.f), 'the core wears the Governor City\'s own faces'));
+  assert.ok(all([core[0]]).filter((n) => n.tag === 'path').length > 9 * 3, 'all nine buildings, not a placeholder');
+  const bare = all(Draw.citySvg(m, m.W - 1, { mode: 'dark' }).nodes);
+  assert.ok(!linksOf(bare).some((n) => /hc-core/.test(n.attrs.class)), 'without city-draw.js loaded the city still draws, just without its core');
+});
+
+await test('on the builder\'s Home the core and the museum are faded; a craft\'s own district stays in colour', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const cls = (focus, key) => linksOf(all(Draw.citySvg(m, m.W - 1, { mode: 'light', gov: Gov, focus }).nodes)).find((n) => new RegExp(`\\b${key}\\b`).test(n.attrs.class)).attrs.class;
+  assert.match(cls(undefined, 'hc-core'), /hc-quiet/);
+  assert.match(cls(undefined, 'hc-museum'), /hc-quiet/);
+  assert.doesNotMatch(cls('museum', 'hc-museum'), /hc-quiet/);
+  assert.doesNotMatch(cls('core', 'hc-core'), /hc-quiet/);
+  const css = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/home-city.css'), 'utf8');
+  assert.match(css, /\.hc-quiet\s*\{[^}]*opacity:\s*\.3/, 'faded');
+  assert.match(css, /\.hc-quiet:hover,\s*\.hc-svg \.hc-quiet:focus-visible\s*\{[^}]*filter:\s*none/, 'back to colour under the pointer or the keyboard');
+});
+
+await test('a building opens its goal; the museum and the band of stars are doors to the artist\'s and the ideator\'s Home', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const ls = linksOf(all(Draw.citySvg(m, m.W - 1, { mode: 'dark', gov: Gov }).nodes));
+  const towers = ls.filter((n) => n.attrs.class === 'hc-tower');
+  assert.equal(towers.length, m.areas.length);
+  towers.forEach((n) => assert.match(n.attrs.href, /^\/goals#\/goal\/\d+$/));
+  assert.ok(m.areas.every((a) => towers.some((n) => n.attrs.href === `/goals#/goal/${a.id}`)), 'each area links to its own goal');
+  assert.equal(ls.find((n) => /hc-museum/.test(n.attrs.class)).attrs['data-craft-door'], 'artistry');
+  const sky = ls.find((n) => /hc-sky/.test(n.attrs.class));
+  assert.equal(sky.attrs['data-craft-door'], 'ideating');
+  assert.ok(ls.every((n) => n.attrs['aria-label']), 'every door is named for a screen reader');
+  const stars = all([sky]).filter((n) => n.tag === 'circle');
+  const box = Draw.viewBoxOf(m);
+  assert.ok(stars.length > 0 && stars.every((c) => c.attrs.cy < box.OY - 150), 'the stars sit high above the city, apart from it');
+});
+
+await test('a week part-way through grows each tower part-way: the slider glides, it does not jump', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const a = m.areas.find((x) => x.build[4] + x.art[4] > 0);
+  const at = (t) => { const d = Draw.doneAt(a, t); return d.build + d.art; };
+  assert.ok(at(3) < at(3.5) && at(3.5) < at(4), 'half a week in is half of that week\'s work');
+  assert.equal(at(3.5), (at(3) + at(4)) / 2);
+});
+
 await test('both modes draw with their own faces', () => {
   const m = Draw.cityModel(FIXTURE);
   assert.ok(all(Draw.citySvg(m, m.W - 1, { mode: 'dark' }).nodes).some((n) => n.attrs.fill === '#34343a'));
   assert.ok(all(Draw.citySvg(m, m.W - 1, { mode: 'light' }).nodes).some((n) => n.attrs.fill === '#f6f5f8'));
 });
 
+// ---------------------------------------------------------------------------
+// the ideator's sky (task 1005059)
+// ---------------------------------------------------------------------------
+
+await test('an idea carries its area, the week it became work, its votes, and whether it waits on the viewer', () => {
+  const idea = (o) => Object.assign({ id: '1', title: 'T', by: '2', wk: 3, goal_id: null, aim_id: null, became_wk: null, votes: 0, voted: false, status: 'open' }, o);
+  const out = city.shapeCity(raw({
+    ideas: [
+      idea({ id: 'work', goal_id: '10', aim_id: '20', became_wk: 9, votes: 4 }), // became work: its task's goal wins over the aim; the week is clamped to the window
+      idea({ id: 'aim', aim_id: '20', wk: 2 }),                                  // aimed: placed in that area, not yet work
+      idea({ id: 'far', aim_id: '99' }),                                         // aimed outside this version: not placed
+      idea({ id: 'early', goal_id: '10', became_wk: 1, wk: 2 }),                 // a task made before the filing reads as the filing week
+      idea({ id: 'mine', by: '1' }), idea({ id: 'voted', voted: true }), idea({ id: 'old', wk: 1 }), idea({ id: 'shut', status: 'promoted' }),
+    ],
+    ideaVotes: [{ id: '1', wk: 2, n: 3 }, { id: '77', wk: 2, n: 9 }],
+    taskTotal: 50,
+  }), { id: '1', rank: 'metic' });
+  const by = Object.fromEntries(out.ideas.map((x) => [x.id, x]));
+  assert.deepEqual([by.work.area_id, by.work.goal_id, by.work.became, by.work.votes], ['10', '10', 3, 4]);
+  assert.deepEqual([by.aim.area_id, by.aim.became], ['20', null]);
+  assert.equal(by.far.area_id, null);
+  assert.equal(by.early.became, 2);
+  assert.deepEqual(out.ideas.filter((x) => x.waits).map((x) => x.id), ['far'], 'new, open, in no area, not mine, not voted on — and only these two weeks');
+  assert.deepEqual(out.people.find((p) => p.id === '1').vote, [0, 0, 3, 0], 'idea votes per week, known builders only');
+  assert.equal(out.version.tasks, 50);
+  assert.ok(city.shapeCity(raw(), null).ideas.every((x) => !x.waits), 'nothing waits on a signed-out viewer');
+});
+
+await test('the votes are read only where the ideas module keeps them; the viewer id rides only with that read', async () => {
+  const off = fakePool();
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'metic' } }, { pool: off, getFocusVersionId: async () => null });
+  const q = off.seen.find((x) => /FROM idea_inbox i\s+LEFT JOIN/.test(x.sql));
+  assert.doesNotMatch(q.sql, /ideas_votes/);
+  assert.equal(q.params.length, 1);
+  const on = fakePool({ tables: { ideas_votes: true } });
+  await city.readCity({ weeks: 10, viewer: { id: '1', rank: 'metic' } }, { pool: on, getFocusVersionId: async () => null });
+  const q2 = on.seen.find((x) => /FROM idea_inbox i\s+LEFT JOIN/.test(x.sql));
+  assert.match(q2.sql, /LEFT JOIN LATERAL \(SELECT[\s\S]*?FROM ideas_votes v WHERE v\.target_idea_id = i\.id\) iv ON true/); assert.equal(q2.sql.split('FROM ideas_votes').length - 1, 1, 'one look-up per idea, not two'); assert.deepEqual(q2.params.slice(1), ['1']);
+  assert.ok(/LIMIT \d+/.test(q2.sql), 'still the bounded newest-first list');
+});
+
+await test('the skyline IS the city: every building at its own screen x and height, seen from the street', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const t = m.W - 1;
+  const sil = Draw.skylineOf(m, t, Gov);
+  const OX = Draw.viewBoxOf(m).OX, sx = (x, y) => OX + (x - y) * 25;
+  m.areas.forEach((a) => {
+    const s = sil.find((x) => x.k === 'area' && x.id === a.id);
+    const d = Draw.doneAt(a, t);
+    assert.equal(s.l, sx(a.x, a.y + 1.8)); assert.equal(s.r, sx(a.x + 1.8, a.y));
+    assert.equal(s.h, 4 + Math.max(2, (d.build + d.art) * m.px), 'as tall as its tower in the city');
+  });
+  // the tower's own drawing agrees: its body's left and right faces span exactly the silhouette's edges
+  const I = Draw.theme('dark');
+  const xs = (n) => n.attrs.d.slice(1, -1).split('L').map((p) => Number(p.split(' ')[0]));
+  const towers = Draw.citySvg(m, t, { mode: 'dark', gov: Gov }).nodes.filter((n) => n.attrs.class === 'hc-tower');
+  assert.equal(towers.length, sil.filter((s) => s.k === 'area').length);
+  towers.forEach((tw) => {
+    const s = sil.find((x) => tw.attrs.href === `/goals#/goal/${x.id}`);
+    const left = tw.kids.find((k) => k.attrs.fill === I.work.l), right = tw.kids.find((k) => k.attrs.fill === I.work.r);
+    assert.ok(Math.abs(Math.min(...xs(left)) - s.l) <= 0.1 && Math.abs(Math.max(...xs(right)) - s.r) <= 0.1, `${s.id} stands where its tower does`);
+  });
+  const civic = sil.filter((s) => s.k === 'civic');
+  assert.equal(civic.length, Gov.CIVIC_SLOTS.length);
+  civic.forEach((s) => assert.equal(s.h, Gov.ROOF[s.id] * 0.82, 'a civic building at the core\'s own scale'));
+  assert.equal(sil.filter((s) => s.k === 'museum').length, 2, 'the museum block and its atrium');
+  for (let n = 1; n < sil.length; n++) assert.ok(sil[n - 1].depth <= sil[n].depth, 'back to front');
+  // it grows with the slider
+  const tallest = (u) => Math.max(...Draw.skylineOf(m, u, Gov).filter((s) => s.k === 'area').map((s) => s.h));
+  assert.ok(tallest(0) < tallest(t));
+});
+
+await test('outlines never show through a nearer building, and the three doors lie on top', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const ns = all(Draw.skySvg(m, m.W - 1, { mode: 'dark', gov: Gov }).nodes);
+  const sky = ns.find((n) => n.attrs.class === 'hc-skyline').kids;
+  // each silhouette's outline comes straight after its own fill, so every LATER (nearer) fill covers it
+  const fills = sky.filter((n) => n.attrs.class === 'hc-sil');
+  assert.equal(fills.length, Draw.skylineOf(m, m.W - 1, Gov).length);
+  sky.forEach((n, i) => { if (/hc-ol\b/.test(n.attrs.class || '')) assert.equal(sky[i - 1].attrs.d, n.attrs.d); });
+  const hits = ns.filter((n) => n.tag === 'a' && n.attrs.class === 'hc-hit');
+  assert.equal(hits.length, fills.length, 'one hit per silhouette, back to front, so the nearest takes the pointer');
+  const order = ns.indexOf(ns.find((n) => n.attrs.class === 'hc-hits'));
+  assert.ok(order > ns.indexOf(ns.find((n) => n.attrs.class === 'hc-skyline')), 'the hit layer is drawn over the skyline');
+  const group = (k) => hits.filter((h) => h.attrs['data-group'] === k);
+  assert.ok(group('area').every((h) => h.attrs.href === '/goals'), 'Building opens the goals');
+  assert.ok(group('civic').every((h) => h.attrs.href === Gov.STREET_HREF), 'Government opens the street');
+  assert.ok(group('museum').every((h) => h.attrs['data-craft-door'] === 'artistry'), 'Art switches to Artistry');
+  ['area', 'civic', 'museum'].forEach((k) => {
+    const g = group(k);
+    assert.ok(g.length > 0);
+    assert.equal(g.filter((h) => h.attrs.tabindex !== '-1').length, 1, 'one keyboard stop per group');
+    assert.ok(g[0].attrs['aria-label']);
+    g.forEach((h) => { const y = Math.min(...h.kids[0].attrs.d.match(/V(-?[\d.]+)/g).map((v) => Number(v.slice(1)))); assert.ok(Draw.SKY.h - y >= 30, 'a low building still offers a band to point at'); });
+  });
+});
+
+await test('the sky: constellations from real areas, a field for the unplaced, rings only at Live, work falls into its tower', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const ns = all(Draw.skySvg(m, m.W - 1, { mode: 'dark', gov: Gov }).nodes);
+  const consts = ns.filter((n) => n.attrs.class === 'hc-const');
+  const { groups } = Draw.skyPlaces(m);
+  assert.equal(consts.length, groups.length);
+  assert.ok(groups.every((g) => m.areas.includes(g.area)), 'a constellation per working area of this version');
+  assert.ok(ns.some((n) => n.attrs.class === 'hc-loose'));
+  const rings = (u) => all(Draw.skySvg(m, u, { mode: 'dark', gov: Gov }).nodes).filter((n) => n.attrs.class === 'hc-ring').length;
+  assert.equal(rings(m.W - 1), m.ideas.filter((x) => x.waits).length);
+  assert.equal(rings(m.W - 2), 0, 'what waits on you is now, not history');
+  const falls = ns.filter((n) => n.attrs.class === 'hc-fall').length;
+  assert.equal(falls, m.ideas.filter((x) => x.became === m.W - 1 && m.areas.some((a) => a.id === x.goal)).length);
+  const stars = ns.filter((n) => n.attrs.class === 'hc-star');
+  assert.equal(stars.length, m.ideas.filter((x) => !(x.became != null && x.became < m.W - 1)).length, 'an idea that became work earlier lit its window instead');
+  assert.ok(stars.every((s) => s.kids.some((k) => k.attrs.r >= 12)), 'each star offers a 24-unit target for its tip');
+  const built = Draw.versionBuilt(m, m.W - 1);
+  assert.ok(built > 0 && built < 1);
+  assert.ok(Draw.versionBuilt(m, 0) < built, 'the moon waxes with the slider');
+  assert.equal(Draw.versionBuilt(Object.assign({}, m, { version: null }), 1), null);
+});
+
+await test('the ideator\'s ladder ranks ideas, votes and work; the builder\'s ladder is unchanged', () => {
+  const m = Draw.cityModel(FIXTURE);
+  const i = m.W - 1;
+  const rows = Draw.ladderFor(m, i, FIXTURE.viewer.id, 'ideating');
+  rows.forEach((r) => assert.deepEqual(Object.keys(r.v), ['idea', 'vote', 'work']));
+  rows.forEach((r) => assert.equal(r.v.work, m.ideas.filter((x) => x.by === r.id && x.became === i).length));
+  Draw.ladderFor(m, i, FIXTURE.viewer.id).forEach((r) => assert.deepEqual(Object.keys(r.v), ['art', 'build', 'idea', 'gov']));
+});
+
 summary();