@bongos/core 1.19.930 → 1.19.931

package/tests/hall_page_gate_map.mjs

@@ -66,6 +66,11 @@ const ORACLE = {
   // from GET /me, never from the URL), so a rank could protect nothing the
   // session does not already.
   '/builders/thinking': 'requireBuilderPage',
+  // THE SKY (task 1004105 / BV2.R26) — the ambient view over the SAME trail the
+  // room lists, drawn as a map. It reads the same endpoint with the same
+  // viewer-derived id, so it sits on the same tier: a rank floor here would
+  // protect on one page exactly what it admits on the other.
+  '/builders/sky': 'requireBuilderPage',
   '/builders/collab': 'requireBuilderPage',
   // task 1002710: the orientation reading rooms moved DOWN to this tier from a
   // thetes+ gate. They are the onboarding documents, so gating them above xenos

package/tests/hall_sky.mjs

@@ -0,0 +1,458 @@
+// tests/hall_sky.mjs — THE SKY, at the rendered layer
+// (task 1004105 / BV2.R26 of goal 1000095, criterion `ideator-sky-tells-the-truth`).
+//
+// This suite boots the REAL modules/hall-ui/public/sky.js and the REAL
+// modules/hall-ui/public/idea-objects.js in a vm and reads the HTML they write.
+// Nothing here asserts against a projection built by hand: every row goes in
+// shaped the way `GET /inbox/by-builder/:id` shapes one, so a test cannot stay
+// green over a page that reads a field the route does not send.
+//
+// WHAT IT IS ACTUALLY GUARDING, and why it is not tests/hall_thinking_room.mjs
+// again. Everything the sky draws is already correct and already tested: the
+// five states (tests/idea_state.mjs), size (tests/idea_size.mjs), brightness
+// (tests/idea_brightness.mjs), the descent (tests/idea_descent_surface.mjs),
+// and the room proves the WORDS. What is new here is that the answers become
+// GEOMETRY, and a drawing has its own ways of lying that nothing upstream can
+// see:
+//
+//   - a diameter computed from a second curve, so one thought is two sizes on
+//     two pages;
+//   - a remnant drawn small, which destroys the entire two-channel model — the
+//     criterion's own proof (BV2.R27) is "large and dead", and if the glyph
+//     shrinks with brightness there is nothing left to prove;
+//   - an unreadable brightness drawn as a dim star, which states that work was
+//     removed when the only thing that happened is that nobody could look;
+//   - a picture with no words, which is a page a screen reader cannot use;
+//   - a well drawn around a goal that never caught the thought, or rings
+//     claiming a goal has no criteria when the truth is nobody asked.
+//
+// It also holds the one structural promise of spec decision 11: the sky is
+// never the only path to anything it shows.
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner, settle, bootSkyPage } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const readFile = (rel) => fs.readFile(path.join(ROOT, rel), 'utf8');
+
+const { test, summary } = makeRunner();
+
+// The /me read, then a trail page, then the background loop, then /goals and a
+// goal detail each — several awaits deep, so one microtask turn is far short.
+const drain = async (n = 20) => { for (let i = 0; i < n; i += 1) await settle(); };
+
+// A trail row in the shape the route emits. Defaults are the dullest possible
+// thought — filed, nothing came of it, floating — so every case below states
+// only the facts it is actually about.
+function idea(over = {}) {
+  return {
+    id: 1,
+    title: 'A thought',
+    kind: 'feature',
+    status: 'open',
+    captured_at: '2026-09-01T00:00:00.000Z',
+    triage_note: null,
+    promoted_to_task_id: null,
+    promoted_task_title: null,
+    promoted_task_status: null,
+    merged_into_idea_id: null,
+    merged_into_idea_title: null,
+    lineage_tasks: [],
+    descent_tasks: [],
+    size: { credits: 0, payments: 0, scale: 0, historical: false },
+    state: {
+      state: 'protostar', position: 'open-space', wellGoalId: null,
+      awaitingNod: false, brightness: null, hasWork: false, attributable: true,
+    },
+    ...over,
+  };
+}
+const page = (ideas, over = {}) => ({ ideas, total: ideas.length, offset: 0, limit: 100, ...over });
+
+const star = (over = {}) => idea({
+  id: 10, title: 'It ignited', status: 'promoted',
+  lineage_tasks: [{ task_id: 500, origin: 'promote', title: 'The task', status: 'shipped', goal_id: 7 }],
+  size: { credits: 240, payments: 4, scale: 0.86, historical: false },
+  state: { state: 'star', position: 'well', wellGoalId: '7', awaitingNod: false, brightness: 1, hasWork: true, attributable: true },
+  ...over,
+});
+const remnant = (over = {}) => star({
+  id: 11, title: 'It burned, then it went',
+  size: { credits: 180, payments: 5, scale: 0.86, historical: false },
+  state: { state: 'remnant', position: 'well', wellGoalId: '7', awaitingNod: false, brightness: 0, hasWork: true, attributable: true },
+  ...over,
+});
+const coldBody = (over = {}) => idea({
+  id: 12, title: 'It never ignited', status: 'discarded',
+  size: { credits: 0, payments: 0, scale: 0, historical: false },
+  state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true },
+  ...over,
+});
+
+// The diameter a glyph was drawn at, and the object it says it is, pulled off
+// the markup by the idea's own button so a case never has to guess which glyph
+// belongs to which thought.
+function glyphOf(html, ideaId) {
+  const re = new RegExp(`data-idea="${ideaId}"[\\s\\S]*?<span class="sky-glyph"([^>]*)>`);
+  const m = re.exec(html);
+  if (!m) return null;
+  const attrs = m[1];
+  return {
+    object: (/data-object="([^"]+)"/.exec(attrs) || [])[1] || null,
+    d: Number((/--d:(\d+)px/.exec(attrs) || [])[1]),
+    lit: Number((/--lit:([\d.]+)/.exec(attrs) || [])[1]),
+    unknownSize: /data-size="unknown"/.test(attrs),
+  };
+}
+const labelOf = (html, ideaId) => (new RegExp(`data-idea="${ideaId}"[\\s\\S]*?aria-label="([^"]*)"`).exec(html) || [])[1] || '';
+
+// ═══ the five objects, in the shared vocabulary ═════════════════════════════
+
+await test('every one of the five draws its own object, and the word comes from the shared table', async () => {
+  const all = [
+    star(),
+    remnant(),
+    coldBody(),
+    idea({ id: 13, title: 'Folded', status: 'merged', merged_into_idea_id: 999, merged_into_idea_title: 'The host',
+      state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true } }),
+    idea({ id: 14, title: 'Waiting' }),
+  ];
+  const p = bootSkyPage({ pages: [page(all)] });
+  await drain();
+  const html = p.field();
+  const seen = [10, 11, 12, 13, 14].map((id) => glyphOf(html, id).object);
+  assert.deepEqual(seen, ['star', 'remnant', 'cold-body', 'satellite', 'protostar']);
+  // The words are the shared table's, never this page's.
+  const objects = p.objects();
+  for (const id of objects.ORDER) assert.ok(p.legend().includes(objects.objectFor(id).label), `the legend says "${objects.objectFor(id).label}"`);
+});
+
+await test('the legend is built from ORDER, so the page cannot grow a sixth object or lose one', async () => {
+  const p = bootSkyPage({ pages: [page([star()])] });
+  await drain();
+  const marks = [...p.legend().matchAll(/class="sky-glyph" data-object="([^"]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(marks, [...p.objects().ORDER]);
+});
+
+// ═══ size is geometry, and the curve is the server's ════════════════════════
+
+await test('the diameter tracks the server scale, and nothing on this page re-compresses it', async () => {
+  const small = star({ id: 20, size: { credits: 12, payments: 1, scale: 0.1, historical: false } });
+  const big = star({ id: 21, size: { credits: 2400, payments: 40, scale: 1, historical: false } });
+  const p = bootSkyPage({ pages: [page([small, big])] });
+  await drain();
+  const a = glyphOf(p.field(), 20);
+  const b = glyphOf(p.field(), 21);
+  assert.ok(b.d > a.d, 'a bigger scale draws a bigger body');
+  // The mapping is AFFINE in the server's scale — that is the whole claim. A
+  // page taking its own log of an already-compressed figure is how the sky and
+  // the room end up drawing one thought at two sizes, and the only way to catch
+  // it is to check a third point against the line the other two define.
+  const mid = star({ id: 22, size: { credits: 200, payments: 4, scale: 0.55, historical: false } });
+  const q = bootSkyPage({ pages: [page([small, big, mid])] });
+  await drain();
+  const c = glyphOf(q.field(), 22);
+  const expected = a.d + (b.d - a.d) * ((0.55 - 0.1) / (1 - 0.1));
+  assert.ok(Math.abs(c.d - expected) <= 1, `0.55 lands on the line the endpoints define (${c.d} vs ~${expected.toFixed(1)})`);
+});
+
+await test('A LARGE DEAD THOUGHT RENDERS LARGE AND DEAD — it keeps its diameter and loses its fill', async () => {
+  // The criterion's own picture, and the thing BV2.R27 goes on to prove live.
+  // The two rows differ ONLY in what happened to the work: same scale on the
+  // remnant as on the star, nothing at all on the cold body.
+  const p = bootSkyPage({ pages: [page([star(), remnant(), coldBody()])] });
+  await drain();
+  const html = p.field();
+  const alive = glyphOf(html, 10);
+  const dead = glyphOf(html, 11);
+  const never = glyphOf(html, 12);
+  assert.equal(dead.d, alive.d, 'size never falls: the remnant is exactly as big as the star');
+  assert.ok(dead.d > never.d, 'and it is visibly bigger than a thought that never mattered');
+  assert.equal(dead.object, 'remnant');
+  assert.equal(never.object, 'cold-body');
+  // Distinguishable in WORDS too, not only in shape — the picture is not the
+  // only channel a reader has.
+  assert.match(labelOf(html, 11), /burned out/);
+  assert.match(labelOf(html, 11), /none of it still alive/);
+  assert.match(labelOf(html, 12), /declined/);
+});
+
+await test('a size that could not be read draws at the floor and says so, never as a measured zero', async () => {
+  const unreadable = star({ id: 30, size: null });
+  const zero = coldBody({ id: 31 });
+  const p = bootSkyPage({ pages: [page([unreadable, zero])] });
+  await drain();
+  const a = glyphOf(p.field(), 30);
+  const b = glyphOf(p.field(), 31);
+  assert.equal(a.unknownSize, true, 'the unreadable one is marked');
+  assert.equal(b.unknownSize, false, 'a real zero is not');
+  assert.match(labelOf(p.field(), 30), /size unknown/);
+  p.pick(30);
+  assert.match(p.panel(), /unknown/, 'the panel says unknown rather than a number');
+  assert.ok(!/size — the work it caused<\/span><span class="sky-fact__v">0/.test(p.panel()));
+});
+
+await test('a historical size carries its marker wherever the number is shown', async () => {
+  const p = bootSkyPage({ pages: [page([star({ size: { credits: 96, payments: 3, scale: 0.71, historical: true } })])] });
+  await drain();
+  p.pick(10);
+  assert.match(p.panel(), /part historical/);
+  assert.match(p.panel(), /not payouts that were made/);
+});
+
+// ═══ brightness: the three answers stay three ═══════════════════════════════
+
+await test('brightness rides the glyph, and a dimmer star is drawn dimmer', async () => {
+  const full = star({ id: 40 });
+  const half = star({ id: 41, state: { ...star().state, brightness: 0.5 } });
+  const p = bootSkyPage({ pages: [page([full, half])] });
+  await drain();
+  assert.equal(glyphOf(p.field(), 40).lit, 1);
+  assert.equal(glyphOf(p.field(), 41).lit, 0.5);
+  assert.match(labelOf(p.field(), 41), /50% still alive/);
+});
+
+await test('AN UNREADABLE BRIGHTNESS LEAVES THE STAR FULLY LIT and puts the doubt in words', async () => {
+  // idea-state.js step 3, one layer up and one channel over: `attributable:
+  // false` means the removal facts could not be read, and dimming on it would
+  // draw a healthy instance as a field of half-dead stars the moment the
+  // lifecycle module failed to mount.
+  const unknown = star({ id: 50, state: { ...star().state, brightness: null, attributable: false } });
+  const out = star({ id: 51, state: { ...star().state, brightness: 0, attributable: true } });
+  const p = bootSkyPage({ pages: [page([unknown, out])] });
+  await drain();
+  assert.equal(glyphOf(p.field(), 50).lit, 1, 'unreadable is drawn at full');
+  assert.equal(glyphOf(p.field(), 51).lit, 0, 'a confirmed-dead descent is not');
+  assert.match(labelOf(p.field(), 50), /still alive — unknown/);
+});
+
+await test('the panel draws no brightness BAR for a share nobody could measure', async () => {
+  // A bar at zero and a bar that could not be measured look identical, and one
+  // of them is a claim. The words carry it instead.
+  const unknown = star({ id: 60, state: { ...star().state, brightness: null, attributable: false } });
+  const p = bootSkyPage({ pages: [page([unknown])] });
+  await drain();
+  p.pick(60);
+  assert.ok(!/sky-bar/.test(p.panel()), 'no bar on an unreadable share');
+  assert.match(p.panel(), /still alive — unknown/);
+
+  const q = bootSkyPage({ pages: [page([star({ id: 61, state: { ...star().state, brightness: 0 } })])] });
+  await drain();
+  q.pick(61);
+  assert.match(q.panel(), /sky-bar[^>]*data-lit="out"/, 'a measured zero DOES get a bar, drawn out');
+});
+
+await test('a thought with no work yet says there is nothing to be alive, not that it died', async () => {
+  const p = bootSkyPage({ pages: [page([idea({ id: 70 })])] });
+  await drain();
+  p.pick(70);
+  assert.match(p.panel(), /nothing to be alive yet/);
+  assert.ok(!/none of it still alive/.test(p.panel()));
+});
+
+// ═══ gravity: the wells, and the rings inside them ══════════════════════════
+
+await test('a well is the goal that HOLDS the work, and its name comes from the goals read', async () => {
+  const p = bootSkyPage({
+    pages: [page([star(), idea({ id: 80 })])],
+    goals: [{ id: '7', title: 'The catching goal' }],
+  });
+  await drain();
+  assert.match(p.field(), /The catching goal/);
+  // The floating one is not in it.
+  assert.match(p.field(), /Open space/);
+  assert.match(p.field(), /no goal has claimed this one/);
+});
+
+await test('a well whose goal could not be named keeps its id — never a blank label', async () => {
+  const p = bootSkyPage({ pages: [page([star()])], goals: null });
+  await drain();
+  assert.match(p.field(), /Goal 7/);
+});
+
+await test('the rings are the criteria, closing as each is satisfied', async () => {
+  const p = bootSkyPage({
+    pages: [page([star()])],
+    goals: [{ id: '7', title: 'The catching goal' }],
+    criteria: { 7: [{ satisfied: true }, { satisfied: true }, { satisfied: false }] },
+  });
+  await drain();
+  const rings = [...p.field().matchAll(/class="sky-ring"( data-closed="1")?/g)].map((m) => !!m[1]);
+  assert.deepEqual(rings, [true, true, false]);
+  assert.match(p.field(), /2 of 3 criteria met/);
+});
+
+await test('a goal whose criteria were NOT READ draws no rings, and does not claim it has none', async () => {
+  const p = bootSkyPage({
+    pages: [page([star()])],
+    goals: [{ id: '7', title: 'The catching goal' }],
+    criteria: {},
+  });
+  await drain();
+  assert.ok(!/sky-ring/.test(p.field()), 'no rings at all');
+  assert.ok(!/0 of 0 criteria/.test(p.field()), 'and no claim about how many there are');
+  assert.match(p.field(), /1 thought/, 'it falls back to what it does know');
+});
+
+await test('a satellite is drawn ON the thought it was folded into, when that one is in view', async () => {
+  const host = star({ id: 90 });
+  const moon = idea({
+    id: 91, title: 'Folded in', status: 'merged', merged_into_idea_id: 90, merged_into_idea_title: 'It ignited',
+    state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true },
+  });
+  const p = bootSkyPage({ pages: [page([host, moon])], goals: [{ id: '7', title: 'The catching goal' }] });
+  await drain();
+  const html = p.field();
+  // Both in the HOST's well, not one in open space — the satellite's own
+  // wellGoalId is null, so grouping by that alone would separate them.
+  assert.ok(!/Open space/.test(html), 'the satellite did not float off on its own');
+  const pos = (id) => {
+    const m = new RegExp(`data-idea="${id}"[\\s\\S]*?left:([\\d.-]+)%;top:([\\d.-]+)%`).exec(html);
+    return { left: Number(m[1]), top: Number(m[2]) };
+  };
+  const a = pos(90);
+  const b = pos(91);
+  const gap = Math.hypot(a.left - b.left, a.top - b.top);
+  assert.ok(gap > 0 && gap < 12, `it orbits the host rather than taking a slot of its own (gap ${gap.toFixed(1)}%)`);
+});
+
+await test('a protostar in a well says a nod is waiting; one in open space says nobody claimed it', async () => {
+  const waiting = idea({
+    id: 100, title: 'Caught, not lit', status: 'promoted',
+    lineage_tasks: [{ task_id: 7, origin: 'promote', title: 'T', status: 'backlog', goal_id: 7 }],
+    state: { state: 'protostar', position: 'well', wellGoalId: '7', awaitingNod: true, brightness: null, hasWork: false, attributable: true },
+  });
+  const floating = idea({ id: 101, title: 'Nobody caught it' });
+  const p = bootSkyPage({ pages: [page([waiting, floating])], goals: [{ id: '7', title: 'A goal' }] });
+  await drain();
+  assert.match(labelOf(p.field(), 100), /waiting for a nod/);
+  assert.match(labelOf(p.field(), 101), /nothing has claimed it/);
+});
+
+// ═══ never the only path ════════════════════════════════════════════════════
+
+await test('every thought carries its whole sentence, so the picture is readable without seeing it', async () => {
+  const p = bootSkyPage({ pages: [page([star({ id: 110, title: 'A named thought' })])] });
+  await drain();
+  const label = labelOf(p.field(), 110);
+  for (const bit of ['A named thought', 'burning', 'size 240', 'all of it still alive']) {
+    assert.ok(label.includes(bit), `the aria-label says "${bit}" — got "${label}"`);
+  }
+  // And it is a real control, not a div with a handler.
+  assert.match(p.field(), /<button type="button" class="sky-body"/);
+});
+
+await test('the page points at the list before anything is picked, and the panel links out after', async () => {
+  const p = bootSkyPage({ pages: [page([star()])], goals: [{ id: '7', title: 'A goal' }] });
+  await drain();
+  assert.match(p.panel(), /href="\/thinking"/, 'the unpicked panel names the room');
+  p.pick(10);
+  const html = p.panel();
+  assert.match(html, /href="\/idea\/10"/, 'the record');
+  assert.match(html, /href="\/goals#\/goal\/7"/, 'the well');
+  assert.match(html, /href="\/task\/500"/, 'and the work it became');
+});
+
+await test('the shell markup itself carries the way back to the list', async () => {
+  const html = await readFile('modules/hall-ui/public/sky.html');
+  assert.match(html, /href="\/builders\/thinking"/);
+  // …and the room carries the way here, so the pair is reachable both ways.
+  const room = await readFile('modules/hall-ui/public/thinking.html');
+  assert.match(room, /href="\/builders\/sky"/);
+});
+
+// ═══ the read ═══════════════════════════════════════════════════════════════
+
+await test('it reads the VIEWER own trail — the id comes from /me, never from the URL', async () => {
+  const p = bootSkyPage({ pages: [page([star()])], viewer: { id: 4242 } });
+  await drain();
+  assert.ok(p.requests.some((u) => u.includes('/inbox/by-builder/4242')));
+  assert.ok(!p.requests.some((u) => /builder=/.test(u)), 'no builder query parameter anywhere');
+});
+
+await test('the whole trail is read in the background, and the figures count what arrived', async () => {
+  const first = page([star({ id: 200 }), star({ id: 201 })], { total: 3, offset: 0 });
+  const second = page([remnant({ id: 202 })], { total: 3, offset: 2 });
+  const p = bootSkyPage({ pages: [first, second] });
+  await drain(40);
+  assert.equal(p.requests.filter((u) => u.includes('/inbox/by-builder/')).length, 2);
+  assert.match(p.sub(), /2 burning, 1 burned out, 3 in all/);
+});
+
+await test('the wells are read AFTER the field is on screen, so the picture never waits on them', async () => {
+  const p = bootSkyPage({ pages: [page([star()])], goals: [{ id: '7', title: 'A goal' }] });
+  await drain();
+  const trailAt = p.requests.findIndex((u) => u.includes('/inbox/by-builder/'));
+  const goalsAt = p.requests.findIndex((u) => /\/goals$/.test(u));
+  assert.ok(trailAt >= 0 && goalsAt > trailAt, 'the trail is asked for first');
+});
+
+await test('an empty trail says so, and points at the one gesture that fixes it', async () => {
+  const p = bootSkyPage({ pages: [page([])] });
+  await drain();
+  assert.match(p.field(), /nothing in your sky/);
+  assert.match(p.field(), /href="\/ideas"/);
+});
+
+await test('a trail that could not be read says so rather than drawing an empty sky', async () => {
+  const p = bootSkyPage({ pages: [page([star()])], trailStatus: 500 });
+  await drain();
+  assert.match(p.field(), /Could not read your idea trail/);
+  assert.ok(!/sky-body/.test(p.field()));
+});
+
+// ═══ it derives nothing the server already answered ═════════════════════════
+
+await test('when the status and the resolved state disagree, the page draws the STATE', async () => {
+  // The room's rule, and it matters more here: a state decided twice is two
+  // states, and the sky is the surface most tempted to guess because it draws
+  // rather than lists. `status` may only be read for what a thought BECAME.
+  //
+  // A GREP CANNOT ASK THIS. `headline()` legitimately counts `state === 'star'`
+  // — the server's own vocabulary, used as the server emitted it — so banning
+  // the five words from the source would fail a correct page while still
+  // passing one that re-derived the object from something else entirely. So the
+  // question is put as a disagreement the page has to resolve: a row whose
+  // `status` says it was discarded and whose resolver says it is a burning
+  // star. Anything reading the status draws a cold body.
+  const liar = star({
+    id: 300, title: 'Discarded, and still burning', status: 'discarded', triage_note: 'a duplicate',
+  });
+  const p = bootSkyPage({ pages: [page([liar])] });
+  await drain();
+  assert.equal(glyphOf(p.field(), 300).object, 'star', 'the resolver wins');
+  assert.match(labelOf(p.field(), 300), /burning/);
+  assert.ok(!/declined/.test(labelOf(p.field(), 300)));
+  // …and the other direction: a row the resolver calls a cold body draws one
+  // however alive its own columns look.
+  const other = star({
+    id: 301, title: 'Promoted, and never lit', status: 'promoted',
+    state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true },
+  });
+  const q = bootSkyPage({ pages: [page([other])] });
+  await drain();
+  assert.equal(glyphOf(q.field(), 301).object, 'cold-body');
+});
+
+await test('a state the page has never heard of is drawn through, not swallowed', async () => {
+  // idea-objects.js passes an unknown state through rather than defaulting it,
+  // because a sixth object would be a real answer the server gave. Drawing it
+  // unstyled beats drawing nothing, and beats drawing it as a protostar.
+  const sixth = star({ id: 310, state: { ...star().state, state: 'pulsar' } });
+  const p = bootSkyPage({ pages: [page([sixth])] });
+  await drain();
+  assert.equal(glyphOf(p.field(), 310).object, 'pulsar');
+  assert.match(labelOf(p.field(), 310), /pulsar/);
+});
+
+await test('it computes no brightness and no compression of its own', async () => {
+  const src = await readFile('modules/hall-ui/public/sky.js');
+  const code = src.split('\n').filter((l) => !/^\s*\/\//.test(l)).join('\n');
+  assert.ok(!/Math\.log/.test(code), 'no second compression curve');
+  assert.ok(!/descent_tasks\s*\.\s*length\s*\/\s*/.test(code), 'no brightness computed from a descent length');
+});
+
+summary();

package/tests/helpers.mjs

@@ -855,3 +855,124 @@ export function bootThinkingPage({ pages = [], viewer = { id: 95 }, meStatus = 2
     filter: (id) => { tabState.active = id; if (tabState.onChange) tabState.onChange(id); },
   };
 }
+
+// bootSkyPage — boot the REAL modules/hall-ui/public/sky.js in a vm against a
+// stub DOM, and hand back the field, the panel and the legend it wrote plus
+// every request it made.
+//
+// The fourth sibling of bootProfilePage / bootIdeaPage / bootThinkingPage, and
+// here for the reason the third one is: THE SKY (task 1004105 / BV2.R26) is a
+// DRAWING of facts that are all correct upstream, and the only place it can go
+// wrong is the last step. A glyph is geometry, so the questions this can ask
+// that no server test can are: does a remnant keep its diameter and lose its
+// fill, does an unreadable brightness leave a star lit, does the page draw a
+// second compression curve of its own, and does every thought carry its whole
+// sentence for a reader who cannot see the picture.
+//
+// THE REAL idea-objects.js IS LOADED INTO THE SAME SANDBOX, never stubbed —
+// the same rule bootThinkingPage keeps, and for the sharper reason here: the
+// pair exists so the sky and the room cannot call one object two names, and a
+// suite that stubbed the vocabulary would assert the sky says whatever the
+// suite told it to.
+const SKY_JS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/sky.js'), 'utf8');
+export function bootSkyPage({
+  pages = [], viewer = { id: 95 }, meStatus = 200, trailStatus = 200,
+  goals = null, criteria = {},
+} = {}) {
+  const els = new Map();
+  const listeners = new Map();
+  const makeEl = (id) => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; },
+    addEventListener(type, fn) { listeners.set(`${id}:${type}`, fn); },
+    querySelector() { return null; }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  const documentObj = {
+    title: '',
+    body: { dataset: { page: 'sky' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl(id)); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl('new'); },
+    addEventListener() {},
+  };
+
+  const requests = [];
+  const client = {
+    request: async (method, url) => {
+      requests.push(url);
+      if (/\/me$/.test(url)) {
+        return meStatus === 200
+          ? { status: 200, ok: true, data: { builder: viewer } }
+          : { status: meStatus, ok: false, data: null };
+      }
+      // The two well reads. `goals: null` is a route that could not be read at
+      // all, which must leave the wells named by their id rather than blank;
+      // `criteria` absent for a goal is "not read", which must leave that well
+      // with no rings rather than zero of them.
+      const one = /\/goals\/(\d+)$/.exec(url);
+      if (one) {
+        const list = criteria[one[1]];
+        return list === undefined
+          ? { status: 404, ok: false, data: null }
+          : { status: 200, ok: true, data: { goal: { id: one[1] }, criteria: list } };
+      }
+      if (/\/goals$/.test(url)) {
+        return goals === null
+          ? { status: 500, ok: false, data: null }
+          : { status: 200, ok: true, data: { goals } };
+      }
+      if (trailStatus !== 200) return { status: trailStatus, ok: false, data: null };
+      const offset = Number((/offset=(\d+)/.exec(url) || [])[1] || 0);
+      const page = pages.find((p) => Number(p.offset || 0) === offset) || { ideas: [], total: 0 };
+      return { status: 200, ok: true, data: page };
+    },
+  };
+
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    CSS: { escape: (s) => String(s) },
+    OTB: {
+      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+      $: (sel) => documentObj.querySelector(sel),
+      fmtDate: (iso) => String(iso ?? '').slice(0, 10),
+      toast() {},
+    },
+    location: { hostname: 'builders.cloudbongos.com', search: '', pathname: '/sky', hash: '', assign() {} },
+    localStorage: { getItem: () => null, setItem() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    console, setTimeout, clearTimeout, URLSearchParams, Math, Number,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(IDEA_OBJECTS_JS, sandbox, { filename: 'idea-objects.js' });
+  vm.runInContext(SKY_JS, sandbox, { filename: 'sky.js' });
+
+  return {
+    requests,
+    objects: () => windowObj.OTBIdeaObjects,
+    field: () => documentObj.getElementById('sky-map').innerHTML,
+    panel: () => documentObj.getElementById('sky-panel').innerHTML,
+    legend: () => documentObj.getElementById('sky-legend').innerHTML,
+    sub: () => documentObj.getElementById('sky-sub').textContent,
+    foot: () => documentObj.getElementById('sky-foot'),
+    // Picking is the page's only control, and it is DELEGATED — one listener on
+    // the field for a trail of 300 bodies — so the suite drives it the way a
+    // click does rather than by calling an internal the page does not export.
+    pick: (ideaId) => {
+      const fn = listeners.get('sky-map:click');
+      if (!fn) throw new Error('the field wired no click listener');
+      fn({ target: { closest: (sel) => (sel === '[data-idea]'
+        ? { getAttribute: () => String(ideaId) }
+        : null) } });
+    },
+  };
+}