@bongos/core 1.24.29 → 1.24.31

package/tests/home_city_widget.mjs

@@ -0,0 +1,260 @@
+// tests/home_city_widget.mjs — Home's project city, the real widget in a browser
+// (task 1005054).
+//
+// Runs modules/hall-ui/public/city-draw.js + home-city-draw.js + home-city.js in a
+// real page with the read stubbed by the hall-preview fixture: one bounded read per
+// load; the slider opens at Live and redraws towers and ladder wherever it is sent;
+// the quiet player (v16, task 1005058) rewinds, plays and fast-forwards, gliding
+// through the weeks, and jumps instead under reduced motion; the museum and the star
+// band switch the craft; a refused read leaves Home without an empty plate. Skips
+// where no system Edge or Chrome is installed.
+//
+// Run:  node --test tests/home_city_widget.mjs
+import assert from 'node:assert/strict';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
+const pub = (f) => fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', f), 'utf8');
+const GOV = pub('city-draw.js');
+const DRAW = pub('home-city-draw.js');
+const WIDGET = pub('home-city.js');
+const CSS = pub('home-city.css');
+const FIXTURE = fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'home__city.json'), 'utf8');
+
+let browser = null;
+try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+const skip = !browser && 'no system Edge or Chrome';
+
+const stubs = (status, craft) => `
+  window.__asked = [];
+  window.__CITY = ${FIXTURE};
+  window.BongosClient = { createClient: () => ({ request: async (m, p) => {
+    window.__asked.push(m + ' ' + p);
+    if (${status} !== 200) return { ok: false, status: ${status}, data: null };
+    return p.startsWith('/api/bongos/home/city') ? { ok: true, status: 200, data: window.__CITY } : { ok: false, status: 404, data: null };
+  } }) };
+  window.__chosen = [];
+  window.__craft = ${JSON.stringify(craft || null)};
+  window.OTBCraftMode = { iconHtml: (k, cls) => '<svg class="' + cls + '" data-icon="' + k + '"></svg>', choose: (m) => window.__chosen.push(m), current: () => window.__craft };
+  window.OTB = { contributeHallWidget(w) { window.__widget = w; } };`;
+
+async function boot({ status = 200, width = 1280, still = true, craft = null } = {}) {
+  const ctx = await browser.newContext({ viewport: { width, height: 900 }, reducedMotion: still ? 'reduce' : 'no-preference' });
+  const page = await ctx.newPage();
+  await page.clock.install();
+  await page.setContent(`<!doctype html><html><head><style>${CSS}</style></head><body><section id="home-city" class="scroll home-city" hidden></section></body></html>`);
+  await page.addScriptTag({ content: stubs(status, craft) });
+  await page.addScriptTag({ content: GOV });
+  await page.addScriptTag({ content: DRAW });
+  await page.addScriptTag({ content: WIDGET });
+  await page.evaluate(() => window.__widget.mount(document.getElementById('home-city')));
+  return { ctx, page };
+}
+
+// The installed clock still flows in real time; a glide test pauses it once the city is up,
+// so a busy machine (CI runs files in parallel) cannot advance the glide between two reads.
+const freeze = async (page) => page.clock.pauseAt(await page.evaluate(() => Date.now() + 1000));
+
+const state = (page) => page.evaluate(() => ({
+  hidden: document.getElementById('home-city').hidden,
+  asked: window.__asked,
+  week: document.querySelector('.hc-slider').getAttribute('aria-valuetext'),
+  t: Number(document.querySelector('.hc-slider').value),
+  live: document.querySelector('.hc-live').textContent,
+  svgLen: document.querySelector('.hc-svg').innerHTML.length,
+  rungs: [...document.querySelectorAll('.hc-rung:not([hidden])')].sort((a, b) => parseFloat(a.style.top) - parseFloat(b.style.top)).map((r) => ({ me: r.classList.contains('hc-rung--me'), line: r.querySelector('.hc-line').textContent })),
+}));
+
+test('one bounded read; the city, its ladder and the slider appear at Live', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const s = await state(page);
+  const core = await page.evaluate(() => document.querySelectorAll('.hc-svg a.hc-core path').length);
+  await ctx.close();
+  assert.deepEqual(s.asked, ['GET /api/bongos/home/city?weeks=10'], 'Home asks for the summary once and nothing else');
+  assert.equal(s.hidden, false);
+  assert.equal(s.week, 'Live');
+  assert.equal(s.live, 'Live');
+  assert.ok(core > 27, 'the civic core is drawn from city-draw.js');
+  assert.ok(s.rungs.length >= 5);
+  assert.ok(s.rungs.some((r) => r.me), 'the viewer\'s row is marked');
+});
+
+test('the slider redraws the towers and re-ranks the ladder wherever it is sent; Back to live returns', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const now = await state(page);
+  await page.evaluate(() => { const s = document.querySelector('.hc-slider'); s.value = '0'; s.dispatchEvent(new Event('input', { bubbles: true })); });
+  const first = await state(page);
+  assert.equal(first.week, '31 Aug');
+  assert.equal(first.live, 'Back to live');
+  assert.notEqual(first.svgLen, now.svgLen, 'the scene was redrawn');
+  assert.notDeepEqual(first.rungs, now.rungs, 'the ladder is the first week\'s, not this week\'s');
+  await page.click('.hc-live');
+  const back = await state(page);
+  await ctx.close();
+  assert.equal(back.week, 'Live');
+});
+
+test('the player glides: rewind runs back through the weeks to the start, then stops; fast forward runs to Live', { skip }, async () => {
+  const { ctx, page } = await boot({ still: false });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  await freeze(page);
+  await page.click('.hc-p-rw');
+  await page.clock.runFor(1000);
+  const mid = await state(page);
+  assert.ok(mid.t > 0.5 && mid.t < 8.5, `part-way back, not a jump (t=${mid.t})`);
+  assert.ok(!Number.isInteger(mid.t), 'between weeks: the city is drawn at a fractional week');
+  assert.equal(await page.evaluate(() => document.querySelector('.hc-p-rw').getAttribute('aria-pressed')), 'true');
+  await page.clock.runFor(8000);
+  const start = await state(page);
+  assert.equal(start.t, 0);
+  assert.equal(await page.evaluate(() => document.querySelector('.hc-p-rw').getAttribute('aria-pressed')), 'false', 'stops at the start');
+  await page.click('.hc-p-ff');
+  await page.clock.runFor(8000);
+  const end = await state(page);
+  await ctx.close();
+  assert.equal(end.week, 'Live');
+});
+
+test('play runs forward at a walk and pauses on a second press', { skip }, async () => {
+  const { ctx, page } = await boot({ still: false });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  await freeze(page);
+  await page.click('.hc-p-play');
+  assert.equal((await state(page)).t, 0, 'from Live, play starts from the beginning');
+  await page.clock.runFor(1600);
+  const a = await state(page);
+  assert.ok(a.t > 0.5 && a.t < 1.6, `about a week in 1.6 s (t=${a.t})`);
+  await page.click('.hc-p-play');
+  const held = (await state(page)).t;
+  await page.clock.runFor(1600);
+  const b = await state(page);
+  await ctx.close();
+  assert.equal(b.t, held, 'paused');
+});
+
+test('with reduced motion nothing glides: every control jumps straight to where it was going', { skip }, async () => {
+  const { ctx, page } = await boot({ still: true });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  await freeze(page);
+  await page.click('.hc-p-rw');
+  const s = await state(page);
+  await ctx.close();
+  assert.equal(s.t, 0);
+});
+
+test('the museum and the band of stars switch the craft; the core and a building are plain links', { skip }, async () => {
+  const { ctx, page } = await boot();
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  await page.evaluate(() => { document.querySelector('.hc-svg a.hc-museum').dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })); document.querySelector('.hc-svg a.hc-sky').dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })); });
+  const r = await page.evaluate(() => ({ chosen: window.__chosen, core: document.querySelector('.hc-svg a.hc-core').getAttribute('href'), tower: document.querySelector('.hc-svg a.hc-tower').getAttribute('href') }));
+  await ctx.close();
+  assert.deepEqual(r.chosen, ['artistry', 'ideating']);
+  assert.equal(r.core, '/builders/street');
+  assert.match(r.tower, /^\/goals#\/goal\/\d+$/);
+});
+
+test('a refused read leaves the section hidden: never an empty plate', { skip }, async () => {
+  const { ctx, page } = await boot({ status: 401 });
+  await page.evaluate(() => new Promise((r) => setTimeout(r, 0)));
+  await page.clock.runFor(50);
+  const s = await state(page);
+  await ctx.close();
+  assert.equal(s.hidden, true);
+  assert.equal(s.rungs.length, 0);
+});
+
+test('a phone width scrolls nothing sideways', { skip }, async () => {
+  const { ctx, page } = await boot({ width: 390 });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const over = await page.evaluate(() => document.documentElement.scrollWidth - document.documentElement.clientWidth);
+  await ctx.close();
+  assert.equal(over, 0);
+});
+
+// ---- the ideator's sky (task 1005059) ----
+
+// a point inside the hit group that the group itself takes (a nearer building may cover part of it)
+const pointOf = (page, group) => page.evaluate((g) => {
+  for (const h of document.querySelectorAll('.hc-hit[data-group="' + g + '"]')) {
+    const r = h.getBoundingClientRect();
+    for (let fy = 0.95; fy > 0.05; fy -= 0.1) for (let fx = 0.1; fx < 0.95; fx += 0.1) {
+      const x = r.left + r.width * fx, y = r.top + r.height * fy, top = document.elementFromPoint(x, y);
+      if (top && top.closest('.hc-hit') && top.closest('.hc-hit').dataset.group === g) return { x, y };
+    }
+  }
+  return null;
+}, group);
+const lit = (page) => page.evaluate(() => Object.fromEntries(['area', 'civic', 'museum'].map((g) => [g, [...document.querySelectorAll('.hc-ol-' + g)].every((o) => Number(getComputedStyle(o).strokeOpacity) > 0.5)])));
+
+test('in Ideating, Home draws the sky over the skyline from the same one read, and the ladder ranks ideators', { skip }, async () => {
+  const { ctx, page } = await boot({ craft: 'ideating' });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const r = await page.evaluate(() => ({
+    asked: window.__asked, sky: document.getElementById('home-city').classList.contains('hc-is-sky'),
+    hits: document.querySelectorAll('.hc-hit').length, towers: document.querySelectorAll('.hc-tower').length,
+    label: document.querySelector('.hc-svg').getAttribute('aria-label'), icons: [...document.querySelectorAll('.hc-rung .hc-ico')].length,
+  }));
+  await ctx.close();
+  assert.deepEqual(r.asked, ['GET /api/bongos/home/city?weeks=10']);
+  assert.equal(r.sky, true); assert.ok(r.hits > 0); assert.equal(r.towers, 0);
+  assert.match(r.label, /night sky/);
+  assert.ok(r.icons > 0);
+});
+
+test('hovering the skyline outlines exactly one whole group: Building, Government or Art', { skip }, async () => {
+  const { ctx, page } = await boot({ craft: 'ideating' });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-hit').length > 0);
+  const seen = {};
+  for (const g of ['area', 'civic', 'museum']) {
+    const p = await pointOf(page, g);
+    assert.ok(p, g + ' has a point it takes');
+    await page.mouse.move(p.x, p.y);
+    await page.waitForTimeout(400);
+    seen[g] = await lit(page);
+  }
+  await page.mouse.move(2, 2);
+  await page.waitForTimeout(400);
+  const rest = await lit(page);
+  await ctx.close();
+  assert.deepEqual(seen.area, { area: true, civic: false, museum: false });
+  assert.deepEqual(seen.civic, { area: false, civic: true, museum: false });
+  assert.deepEqual(seen.museum, { area: false, civic: false, museum: true });
+  assert.deepEqual(rest, { area: false, civic: false, museum: false });
+});
+
+test('each group is one door: the goals, the street, and the artist\'s Home', { skip }, async () => {
+  const { ctx, page } = await boot({ craft: 'ideating' });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-hit').length > 0);
+  await page.evaluate(() => document.querySelector('.hc-hit[data-group="museum"]').dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })));
+  const r = await page.evaluate(() => ({
+    chosen: window.__chosen,
+    area: [...new Set([...document.querySelectorAll('.hc-hit[data-group="area"]')].map((a) => a.getAttribute('href')))],
+    civic: [...new Set([...document.querySelectorAll('.hc-hit[data-group="civic"]')].map((a) => a.getAttribute('href')))],
+    stops: [...document.querySelectorAll('.hc-hit')].filter((a) => a.getAttribute('tabindex') !== '-1').map((a) => a.dataset.group),
+    small: [...document.querySelectorAll('.hc-hit')].map((a) => a.getBoundingClientRect()).filter((b) => b.height < 24).length,
+  }));
+  await ctx.close();
+  assert.deepEqual(r.chosen, ['artistry']);
+  assert.deepEqual(r.area, ['/goals']);
+  assert.deepEqual(r.civic, ['/builders/street']);
+  assert.deepEqual(r.stops.sort(), ['area', 'civic', 'museum']);
+  assert.equal(r.small, 0, 'every hit clears the 24px floor at 1280');
+});
+
+test('switching the craft swaps the sky and the city in place, with no second read', { skip }, async () => {
+  const { ctx, page } = await boot({ craft: 'ideating' });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-hit').length > 0);
+  await page.evaluate(() => { window.__craft = 'building'; document.dispatchEvent(new CustomEvent('otb:craft', { detail: { mode: 'building' } })); });
+  const r = await page.evaluate(() => ({ asked: window.__asked.length, sky: document.getElementById('home-city').classList.contains('hc-is-sky'), towers: document.querySelectorAll('.hc-tower').length, hits: document.querySelectorAll('.hc-hit').length }));
+  await ctx.close();
+  assert.deepEqual(r, { asked: 1, sky: false, towers: 10, hits: 0 });
+});

package/tests/home_gallery.mjs

@@ -0,0 +1,255 @@
+// tests/home_gallery.mjs — the artist's Home, the gallery (task 1005060, Home v16 step 3).
+//
+// The server half (modules/lifecycle/home-gallery.js) with no database: the shaping of a
+// work, the bounded read against a recording fake pool (one query, LIMIT, Most popular
+// orders by hearts, a private goal and a security-sensitive task stay off the wall, a
+// missing table answers a wall with no hearts, a picture whose file is gone is not hung),
+// the heart (once per builder, revocable, refused for anything the wall would not hang)
+// and both handlers. The page's pure label words (modules/hall-ui/public/home-gallery.js)
+// run in node. The real widget in a browser is tests/home_gallery_widget.mjs.
+//
+// Run:  node tests/home_gallery.mjs
+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';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+process.env.NODE_ENV = 'test';
+const G = require(path.join(ROOT, 'modules/lifecycle/home-gallery.js'));
+const Lib = require(path.join(ROOT, 'modules/hall-ui/public/home-gallery.js'));
+const FIXTURE = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/home__gallery.json'), 'utf8'));
+const MIGRATION = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/migrations/lifecycle_020_work_appreciations.sql'), 'utf8');
+const MANIFEST = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules/lifecycle/module.json'), 'utf8'));
+
+const { test, summary } = makeRunner();
+
+const PIC = (id, hex) => `/api/bongos/task-visuals/task-${id}-${hex}.jpg`;
+function row(over = {}) {
+  return Object.assign({
+    id: '7', title: 'Tweak: Studio (builders:studio)', value_summary: 'The studio reads calmer.', shipped_at: new Date('2026-10-21T10:00:00Z'),
+    source: 'page-tweak', source_ref: 'page-tweak/builders:studio/r1', visual_url: null, visual_alt: null,
+    light: PIC(7, 'aaaaaaaaaaaaaaaa'), dark: PIC(7, 'bbbbbbbbbbbbbbbb'), goal_title: null,
+    artist_id: '2', display_name: 'Sana Okafor', github_login: 'sana', artist_since: new Date('2026-03-02T00:00:00Z'),
+    hearts: 3, mine: false, total: 1,
+  }, over);
+}
+
+// A recording pool: answers to_regclass, the wall, the heart's checks and writes.
+function fakePool({ table = true, wall = [], isWork = true, after = { hearts: 1, mine: true } } = {}) {
+  const calls = [];
+  return {
+    calls,
+    async query(sql, params) {
+      calls.push({ sql, params });
+      if (/to_regclass/.test(sql)) return { rows: [{ ok: table }] };
+      if (/count\(\*\) OVER/.test(sql)) return { rows: wall };
+      if (/WHERE t\.id = \$4/.test(sql)) return { rows: isWork ? [{ id: String(params[3]) }] : [] };
+      if (/^INSERT|^DELETE/.test(sql.trim())) return { rows: [] };
+      if (/bool_or/.test(sql)) return { rows: [after] };
+      throw new Error('unexpected query: ' + sql.slice(0, 80));
+    },
+  };
+}
+const always = () => true;
+
+// ---------------------------------------------------------------------------
+// 1. the shaping (pure)
+// ---------------------------------------------------------------------------
+
+await test('a page tweak hangs as its page: the title, the round, where it hangs, both renders', () => {
+  const w = G.shapeWork(row({ source_ref: 'page-tweak/builders:studio/r2' }));
+  assert.equal(w.title, 'Studio');
+  assert.equal(w.medium, 'A page tweak, round 2');
+  assert.equal(w.place, 'The builders’ hall');
+  assert.deepEqual(w.art, { light: PIC(7, 'aaaaaaaaaaaaaaaa'), dark: PIC(7, 'bbbbbbbbbbbbbbbb'), alt: null });
+  assert.deepEqual(w.artist, { id: '2', name: 'Sana Okafor', login: 'sana', since: '2026-03-02' });
+  assert.equal(w.shipped, '2026-10-21');
+  assert.equal(G.shapeWork(row()).medium, 'A page tweak', 'a first round says no round number');
+});
+
+await test('any other art ship hangs its one ship-time picture in both modes, under its goal', () => {
+  const w = G.shapeWork(row({ source: 'task-cli', source_ref: null, title: 'WA6.RP04 · The profile leads with the work', light: null, dark: null, visual_url: PIC(9, 'cccccccccccccccc'), visual_alt: 'The profile', goal_title: 'Profiles' }));
+  assert.equal(w.title, 'The profile leads with the work', 'the plan code is not part of a wall label');
+  assert.equal(w.medium, 'Page design');
+  assert.equal(w.place, 'Profiles');
+  assert.deepEqual(w.art, { light: PIC(9, 'cccccccccccccccc'), dark: PIC(9, 'cccccccccccccccc'), alt: 'The profile' });
+});
+
+await test('a heart count is never negative and mine is strictly true', () => {
+  const w = G.shapeWork(row({ hearts: -4, mine: 't' }));
+  assert.equal(w.hearts, 0);
+  assert.equal(w.mine, false);
+});
+
+// ---------------------------------------------------------------------------
+// 2. the wall's read
+// ---------------------------------------------------------------------------
+
+await test('one bounded query: shipped art with a picture, LIMIT 60, Most popular orders by hearts first', async () => {
+  const pool = fakePool({ wall: [row()] });
+  const raw = await G.readGallery({ order: 'popular', viewer: { id: 5, rank: 'metic' } }, { pool, exists: always });
+  const q = pool.calls.find((c) => /count\(\*\) OVER/.test(c.sql));
+  assert.ok(q, 'the wall is one query');
+  assert.match(q.sql, /LIMIT 60\b/);
+  assert.match(q.sql, /ORDER BY hearts DESC, t\.shipped_at DESC, t\.id DESC/);
+  assert.match(q.sql, /t\.status = 'shipped'/);
+  assert.match(q.sql, /t\.security_sensitive IS NOT TRUE/, 'a security-sensitive picture never hangs');
+  assert.match(q.sql, /g\.visibility IS DISTINCT FROM 'private' OR \$2::boolean\s+OR EXISTS \(SELECT 1 FROM goal_members/, 'a private goal hangs only for its members and an Archon');
+  assert.match(q.sql, /t\.visual_url IS NOT NULL OR sl\.light IS NOT NULL OR sl\.dark IS NOT NULL/);
+  assert.match(q.sql, /system_role IS NULL/, 'a machine principal is never an artist');
+  assert.deepEqual(q.params, [['artist', 'ui'], false, '5'], 'visibility comes from the signed-in viewer');
+  assert.equal(raw.order, 'popular');
+});
+
+await test('Latest orders by the ship date alone; an unknown order is Most popular', async () => {
+  const pool = fakePool({ wall: [] });
+  await G.readGallery({ order: 'latest', viewer: { id: 1, rank: 'archon' } }, { pool, exists: always });
+  const q = pool.calls.find((c) => /count\(\*\) OVER/.test(c.sql));
+  assert.match(q.sql, /ORDER BY t\.shipped_at DESC, t\.id DESC/);
+  assert.doesNotMatch(q.sql, /hearts DESC/);
+  assert.equal(q.params[1], true, 'an Archon sees every goal');
+  assert.equal(G.cleanOrder('loudest'), 'popular');
+});
+
+await test('with the hearts table absent the wall still hangs, with no hearts', async () => {
+  const pool = fakePool({ table: false, wall: [row({ hearts: 0 })] });
+  assert.equal(G.shapeGallery({ order: 'popular', rows: [] }).total, 0);
+  const raw = await G.readGallery({ order: 'popular', viewer: { id: 1 } }, { pool, exists: always });
+  const q = pool.calls.find((c) => /count\(\*\) OVER/.test(c.sql));
+  assert.doesNotMatch(q.sql, /lifecycle_work_appreciations/);
+  assert.equal(raw.rows.length, 1);
+});
+
+await test('a picture whose file is gone is dropped, and a work left with none is not hung', async () => {
+  const gone = new Set([PIC(7, 'aaaaaaaaaaaaaaaa'), PIC(8, 'dddddddddddddddd')]);
+  const asked = [];
+  const out = await G.keepHung([
+    row({ total: 3 }),
+    row({ id: '8', light: PIC(8, 'dddddddddddddddd'), dark: null, total: 3 }),
+    row({ id: '9', light: null, dark: null, visual_url: PIC(9, 'cccccccccccccccc'), total: 3 }),
+  ], async (u) => { asked.push(u); return !gone.has(u); });
+  assert.deepEqual(out.map((r) => r.id), ['7', '9']);
+  assert.equal(asked.length, new Set(asked).size, 'each picture is checked once, however many works share it');
+  assert.equal(out[0].light, null);
+  assert.equal(out[0].dark, PIC(7, 'bbbbbbbbbbbbbbbb'));
+  assert.equal(out[0].total, 2, 'the wall\'s size counts only what hangs');
+  assert.equal(G.shapeWork(out[0]).art.light, PIC(7, 'bbbbbbbbbbbbbbbb'), 'a mode with no render shows the other');
+});
+
+// ---------------------------------------------------------------------------
+// 3. the heart: appreciation, once per builder, revocable
+// ---------------------------------------------------------------------------
+
+await test('a heart is one row per (work, builder): given with ON CONFLICT DO NOTHING, taken back with a delete', async () => {
+  const pool = fakePool({ after: { hearts: 4, mine: true } });
+  const on = await G.setHeart({ taskId: 7, on: true, viewer: { id: 5, rank: 'thetes' } }, { pool });
+  assert.deepEqual(on, { ok: true, id: '7', hearts: 4, mine: true });
+  const ins = pool.calls.find((c) => /^INSERT/.test(c.sql.trim()));
+  assert.match(ins.sql, /ON CONFLICT DO NOTHING/);
+  assert.deepEqual(ins.params, [7, '5'], 'the builder is the caller');
+  const pool2 = fakePool({ after: { hearts: 3, mine: null } });
+  const off = await G.setHeart({ taskId: 7, on: false, viewer: { id: 5 } }, { pool: pool2 });
+  assert.deepEqual(off, { ok: true, id: '7', hearts: 3, mine: false });
+  assert.ok(pool2.calls.some((c) => /^DELETE FROM lifecycle_work_appreciations WHERE task_id = \$1::bigint AND builder_id = \$2::bigint/.test(c.sql.trim())));
+});
+
+await test('a heart is refused for anything the viewer\'s wall would not hang, with the wall\'s own rule', async () => {
+  const pool = fakePool({ isWork: false });
+  const out = await G.setHeart({ taskId: 99, on: true, viewer: { id: 5 } }, { pool });
+  assert.deepEqual(out, { ok: false, code: 'not_a_work', status: 404 });
+  const check = pool.calls.find((c) => /WHERE t\.id = \$4/.test(c.sql));
+  assert.match(check.sql, /t\.security_sensitive IS NOT TRUE/);
+  assert.match(check.sql, /goal_members/);
+  assert.ok(!pool.calls.some((c) => /^INSERT/.test(c.sql.trim())), 'nothing is written');
+  const none = await G.setHeart({ taskId: 7, on: true, viewer: { id: 5 } }, { pool: fakePool({ table: false }) });
+  assert.equal(none.code, 'gallery_unavailable');
+});
+
+await test('the schema: one heart per (work, builder), going with the work and the builder', () => {
+  assert.match(MIGRATION, /CREATE TABLE IF NOT EXISTS lifecycle_work_appreciations/);
+  assert.match(MIGRATION, /PRIMARY KEY \(task_id, builder_id\)/);
+  assert.match(MIGRATION, /task_id\s+bigint\s+NOT NULL REFERENCES tasks\(id\) ON DELETE CASCADE/);
+  assert.match(MIGRATION, /builder_id bigint\s+NOT NULL REFERENCES builders\(id\) ON DELETE CASCADE/);
+  assert.ok(MANIFEST.contributes.routes.includes('home-gallery'), 'the routes are mounted');
+});
+
+// ---------------------------------------------------------------------------
+// 4. the handlers
+// ---------------------------------------------------------------------------
+
+function fakeRes() {
+  const r = { code: 200, body: null, headers: {} };
+  r.set = (k, v) => { r.headers[k] = v; return r; };
+  r.json = (b) => { r.body = b; return r; };
+  r.fail = (code, o) => { r.code = o.status; r.body = { error: { code, message: o.message } }; return r; };
+  return r;
+}
+
+await test('GET /home/gallery passes the order and the signed-in viewer, never a query viewer', async () => {
+  let asked = null;
+  const h = G.galleryHandler({ read: async (a) => { asked = a; return { order: 'latest', rows: [row({ total: 5 })] }; } });
+  const res = fakeRes();
+  await h({ query: { order: 'latest', viewer: '1' }, builder: { id: 5, rank: 'metic' } }, res);
+  assert.deepEqual(asked, { order: 'latest', viewer: { id: 5, rank: 'metic' } });
+  assert.equal(res.body.total, 5);
+  assert.equal(res.body.works[0].title, 'Studio');
+  assert.equal(res.headers['Cache-Control'], 'private, no-store');
+});
+
+await test('PUT /home/gallery/:id/heart wants { on: boolean } and a positive id; a refusal keeps its status', async () => {
+  const seen = [];
+  const h = G.heartHandler({ write: async (a) => { seen.push(a); return a.taskId === 404 ? { ok: false, code: 'not_a_work', status: 404 } : { ok: true, id: String(a.taskId), hearts: 2, mine: a.on }; } });
+  let res = fakeRes(); await h({ params: { id: 'x' }, body: { on: true }, builder: { id: 5 } }, res);
+  assert.equal(res.code, 400);
+  res = fakeRes(); await h({ params: { id: '7' }, body: { on: 'yes' }, builder: { id: 5 } }, res);
+  assert.equal(res.code, 400);
+  res = fakeRes(); await h({ params: { id: '7' }, body: { on: true, builder_id: 1 }, builder: { id: 5, rank: 'xenos' } }, res);
+  assert.deepEqual(res.body, { id: '7', hearts: 2, mine: true });
+  assert.deepEqual(seen[0].viewer, { id: 5, rank: 'xenos' }, 'the heart is the caller\'s, never the body\'s');
+  res = fakeRes(); await h({ params: { id: '404' }, body: { on: true }, builder: { id: 5 } }, res);
+  assert.equal(res.code, 404);
+});
+
+// ---------------------------------------------------------------------------
+// 5. the wall label's words (the page's pure half)
+// ---------------------------------------------------------------------------
+
+await test('a museum label: the signature, the bio, the credit line', () => {
+  assert.equal(Lib.signature('Sana Okafor', '2026-11-03'), 'Sana O. ’26');
+  assert.equal(Lib.signature('octocat', '2025-01-01'), 'octocat ’25');
+  assert.equal(Lib.bio('2026-03-02'), 'On this project since March 2026');
+  assert.equal(Lib.bio(null), 'On this project');
+  assert.equal(Lib.credit({ shipped: '2026-11-04', hearts: 1 }), 'Gift of the artist to the project. Shipped 4 November 2026. Appreciated by 1 builder.');
+  assert.equal(Lib.credit({ shipped: '2026-11-04', hearts: 31 }).endsWith('Appreciated by 31 builders.'), true);
+});
+
+await test('a page title\'s branding holes are filled, and an empty hole leaves no dangling dash', () => {
+  assert.equal(Lib.fillHoles('{{productName}}: {{tagline}}', { productName: 'Cloud Bongos' }), 'Cloud Bongos');
+  assert.equal(Lib.fillHoles('{{productName}} — Contact', {}), 'Contact');
+  assert.equal(Lib.fillHoles('Studio', {}), 'Studio');
+});
+
+await test('a picture is shown only from the hall\'s own task-visuals route, in the mode asked', () => {
+  const w = { art: { light: PIC(7, 'aaaaaaaaaaaaaaaa'), dark: PIC(7, 'bbbbbbbbbbbbbbbb') } };
+  assert.equal(Lib.artFor(w, 'dark'), PIC(7, 'bbbbbbbbbbbbbbbb'));
+  assert.equal(Lib.artFor(w, 'light'), PIC(7, 'aaaaaaaaaaaaaaaa'));
+  assert.equal(Lib.artFor({ art: { light: 'https://evil.example/x.png' } }, 'light'), null);
+  assert.equal(Lib.artFor({ art: { light: '/api/bongos/task-visuals/../../etc/passwd' } }, 'light'), null);
+  assert.equal(Lib.artFor({ art: { dark: PIC(3, 'cccccccccccccccc') } }, 'light'), PIC(3, 'cccccccccccccccc'), 'a mode with no render shows the other');
+});
+
+await test('the preview fixture is the server\'s own shape, every picture on the hall\'s route', () => {
+  assert.ok(FIXTURE.works.length >= 8);
+  FIXTURE.works.forEach((w) => {
+    assert.ok(Lib.artFor(w, 'light') && Lib.artFor(w, 'dark'), `work ${w.id} has a picture in both modes`);
+    assert.deepEqual(Object.keys(w).sort(), ['art', 'artist', 'hearts', 'id', 'medium', 'mine', 'page', 'place', 'shipped', 'title', 'words']);
+  });
+  const hearts = FIXTURE.works.map((w) => w.hearts);
+  assert.deepEqual(hearts, [...hearts].sort((a, b) => b - a), 'Most popular is the fixture\'s order');
+});
+
+summary();