@bongos/core 1.19.928 → 1.19.929

package/tests/hall_thinking_room.mjs

@@ -0,0 +1,366 @@
+// tests/hall_thinking_room.mjs — THE ROOM, at the rendered layer
+// (task 1004098 / BV2.R03 of goal 1000095, criterion `ideator-nothing-is-lost`).
+//
+// This suite boots the REAL modules/hall-ui/public/thinking.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. Every number this page draws is computed and
+// tested server-side already — the five states (tests/idea_state.mjs), size
+// (tests/idea_size.mjs), brightness (tests/idea_brightness.mjs), the descent
+// (tests/idea_descent_surface.mjs). What none of those can see is the last
+// step, where a correct answer is turned into a sentence: a renderer that
+// collapses "we could not read the removal facts" into "none of it survived",
+// or that computes its own compression curve, or that counts its figures over
+// one window while labelling them as a life's work, fails nothing upstream. So
+// the cases below are mostly about the THREE ANSWERS staying three, and about
+// the page never deriving what the server already decided.
+
+import { makeRunner, settle } from './helpers.mjs';
+import { bootThinkingPage } from './helpers.mjs';
+
+const { test, summary } = makeRunner();
+
+// Several awaits deep (the /me read, then a page, then the background loop),
+// so one microtask turn is not enough. Ten is comfortably past the longest
+// chain any case below sets up.
+const drain = async (n = 10) => { 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 — 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.81, historical: false },
+  state: { state: 'remnant', position: 'well', wellGoalId: 7, awaitingNod: false, brightness: 0, hasWork: true, attributable: true },
+  ...over,
+});
+
+// ---------------------------------------------------------------------------
+// The five objects reach the reader as the design's words
+
+await test('every one of the five objects renders its own label from the shared table', async () => {
+  const rows = [
+    star(),
+    idea({ id: 2, state: { state: 'protostar', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: true } }),
+    idea({ id: 3, status: 'merged', merged_into_idea_id: 9, merged_into_idea_title: 'The other one', state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true } }),
+    remnant(),
+    idea({ id: 5, status: 'discarded', state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: false } }),
+  ];
+  const p = bootThinkingPage({ pages: [page(rows)] });
+  await drain();
+  const html = p.rows();
+  const objects = p.objects();
+  for (const key of objects.ORDER) {
+    const label = objects.objectFor(key).label;
+    if (!html.includes(`data-object="${key}"`)) throw new Error(`no row marked ${key}`);
+    if (!html.includes(`>${label}<`)) throw new Error(`${key} never says "${label}"`);
+  }
+});
+
+await test('the page does not re-derive the object — the server\'s state wins over the row\'s status', async () => {
+  // A discarded row the resolver nevertheless called a star. That combination
+  // is REAL (idea-state.js step 2: work beats a discard, because triage can
+  // decline a duplicate whose twin already routed and paid), and a page that
+  // switched on `status` instead of `state` would draw it as a cold body.
+  const p = bootThinkingPage({ pages: [page([star({ status: 'discarded' })])] });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('data-object="star"')) throw new Error('the status overrode the state');
+  if (html.includes('cold-body')) throw new Error('drew a cold body over a star');
+});
+
+// ---------------------------------------------------------------------------
+// Size and brightness are two channels — the whole reason the model has two
+
+await test('a remnant renders LARGE and DEAD: full size, no colour, and it says so', async () => {
+  const p = bootThinkingPage({ pages: [page([remnant()])] });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('180')) throw new Error('lost the true figure');
+  if (!html.includes('--w:81%')) throw new Error('the bar did not keep its size');
+  if (!html.includes('data-lit="out"')) throw new Error('the bar kept its colour');
+  if (!html.includes('none of it still alive')) throw new Error('never said the work is gone');
+});
+
+await test('a thought that never mattered is distinguishable from a large dead one at a glance', async () => {
+  // The failure the two-channel model exists to prevent: one number would draw
+  // these two the same. The proof task (BV2.R21) demonstrates it live; this is
+  // the pin under it.
+  const p = bootThinkingPage({ pages: [page([remnant(), idea({ id: 20, title: 'Nothing came of it' })])] });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('--w:81%')) throw new Error('the dead thought lost its size');
+  // The unignited one has no bar at all, only the dash.
+  const bars = html.match(/tr-size__bar/g) || [];
+  if (bars.length !== 1) throw new Error(`expected exactly one bar, got ${bars.length}`);
+});
+
+await test('an UNREADABLE brightness is not a dead one', async () => {
+  // attributable:false with work — the lifecycle module could not be asked.
+  // idea-state.js is emphatic that this is not `share === 0`, and a renderer
+  // that dimmed the bar or said "none of it still alive" would state, in a
+  // sentence a person reads, something nobody checked.
+  const p = bootThinkingPage({
+    pages: [page([star({ state: { state: 'star', position: 'well', wellGoalId: 7, awaitingNod: false, brightness: null, hasWork: true, attributable: false } })])],
+  });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('still alive — unknown')) throw new Error('did not say the share is unknown');
+  if (html.includes('none of it still alive')) throw new Error('called an unreadable share a dead one');
+  if (html.includes('data-lit="out"')) throw new Error('greyed a bar on a share nobody could read');
+});
+
+await test('a graded brightness reaches the reader as a percentage', async () => {
+  const p = bootThinkingPage({
+    pages: [page([star({ state: { state: 'star', position: 'well', wellGoalId: 7, awaitingNod: false, brightness: 0.67, hasWork: true, attributable: true } })])],
+  });
+  await drain();
+  if (!p.rows().includes('67% still alive')) throw new Error('lost the graded share');
+});
+
+await test('`size: null` reads as unknown, never as zero', async () => {
+  // trail-size.js sets null when the reward port could not be asked at all.
+  // Drawing that as a dash would claim the thought earned nothing.
+  const p = bootThinkingPage({ pages: [page([star({ size: null })])] });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('unknown')) throw new Error('did not say the ledger could not be read');
+  if (html.includes('tr-size__bar')) throw new Error('drew a bar over a size nobody could read');
+});
+
+await test('a zero size is a dash, and a historical one carries its marker', async () => {
+  const p = bootThinkingPage({
+    pages: [page([
+      idea({ id: 30 }),
+      star({ id: 31, size: { credits: 96, payments: 3, scale: 0.71, historical: true } }),
+    ])],
+  });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('—')) throw new Error('a zero size drew no dash');
+  if (!html.includes('part historical')) throw new Error('a historical size did not say so');
+});
+
+await test('the bar width is the server\'s compressed scale, not a second curve', async () => {
+  const p = bootThinkingPage({ pages: [page([star({ size: { credits: 9999, payments: 40, scale: 0.42, historical: false } })])] });
+  await drain();
+  if (!p.rows().includes('--w:42%')) throw new Error('the page compressed the number itself');
+});
+
+// ---------------------------------------------------------------------------
+// What a row says it became
+
+await test('a folded thought names the thought that absorbed it, and links to it', async () => {
+  const p = bootThinkingPage({
+    pages: [page([idea({ id: 3, status: 'merged', merged_into_idea_id: 9, merged_into_idea_title: 'The other one', state: { state: 'satellite', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: 1, hasWork: true, attributable: true } })])],
+  });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('folded into')) throw new Error('did not say it was folded');
+  if (!html.includes('/idea/9')) throw new Error('did not link the absorbing thought');
+});
+
+await test('a thought awaiting a nod says so — the one actionable phrase on the page', async () => {
+  const p = bootThinkingPage({
+    pages: [page([idea({
+      id: 4, status: 'open',
+      lineage_tasks: [{ task_id: 77, origin: 'route', title: 'The routed task', status: 'backlog', goal_id: 12 }],
+      state: { state: 'protostar', position: 'well', wellGoalId: 12, awaitingNod: true, brightness: null, hasWork: false, attributable: true },
+    })])],
+  });
+  await drain();
+  if (!p.rows().includes('waiting for a nod')) throw new Error('a nod queue nobody can see is a list someone must remember');
+});
+
+await test('a thought that caused nothing says so plainly, and a declined one gives the reason', async () => {
+  const p = bootThinkingPage({
+    pages: [page([
+      idea({ id: 5 }),
+      idea({ id: 6, status: 'discarded', triage_note: 'The digest already exists.', state: { state: 'cold-body', position: 'open-space', wellGoalId: null, awaitingNod: false, brightness: null, hasWork: false, attributable: false } }),
+    ])],
+  });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('nothing yet')) throw new Error('an unignited thought read as an absence');
+  if (!html.includes('The digest already exists.')) throw new Error('lost the triager\'s reason');
+});
+
+await test('the descent below the roots is counted, not folded into the root count', async () => {
+  // attachDescentToTrail deliberately EXCLUDES the roots from descent_tasks, so
+  // a page that read one as the whole would under-report every deep thought.
+  const p = bootThinkingPage({
+    pages: [page([star({
+      lineage_tasks: [
+        { task_id: 500, origin: 'promote', title: 'One', status: 'shipped', goal_id: 7 },
+        { task_id: 501, origin: 'develop', title: 'Two', status: 'shipped', goal_id: 7 },
+      ],
+      descent_tasks: [
+        { task_id: 600, depth: 1, relation: 'split', title: 'Three', status: 'shipped' },
+        { task_id: 601, depth: 2, relation: 'rewrite', title: 'Four', status: 'shipped' },
+      ],
+    })])],
+  });
+  await drain();
+  const html = p.rows();
+  if (!html.includes('2 tasks')) throw new Error('lost a root');
+  if (!html.includes('2 more below them')) throw new Error('lost the descent');
+});
+
+// ---------------------------------------------------------------------------
+// The figures are a claim about a whole trail
+
+await test('the figures count the five states, and "filed" is the server\'s total', async () => {
+  const rows = [star(), star({ id: 12 }), remnant(), idea({ id: 13 })];
+  const p = bootThinkingPage({ pages: [page(rows, { total: 4 })] });
+  await drain();
+  const figs = p.figs();
+  // 4 filed, 3 ignited (two stars + the remnant), 2 burning, 1 burned out.
+  for (const [n, label] of [['4', 'filed'], ['3', 'ignited'], ['2', 'still burning'], ['1', 'burned out']]) {
+    if (!new RegExp(`>${n}</span>\\s*<span class="tr-fig__label">${label}<`).test(figs)) {
+      throw new Error(`figure "${label}" is not ${n}`);
+    }
+  }
+});
+
+await test('the page keeps reading until the trail is exhausted, so the figures cover all of it', async () => {
+  // The defect this is under: figures computed over ONE window look exactly
+  // like figures computed over a life.
+  const p = bootThinkingPage({
+    pages: [
+      page([star(), star({ id: 12 })], { total: 3, offset: 0 }),
+      page([remnant()], { total: 3, offset: 2 }),
+    ],
+  });
+  await drain(20);
+  if (p.requests.filter((u) => /by-builder/.test(u)).length !== 2) throw new Error('stopped after one window');
+  if (!/>3<\/span>\s*<span class="tr-fig__label">filed</.test(p.figs())) throw new Error('lost the total');
+  if (!/>1<\/span>\s*<span class="tr-fig__label">burned out</.test(p.figs())) throw new Error('never counted the second window');
+  if (p.foot().hidden) throw new Error('the foot vanished once loading finished');
+});
+
+await test('a trail longer than the cap says so rather than quietly describing its newest slice', async () => {
+  const big = (offset) => page(
+    Array.from({ length: 100 }, (_, i) => star({ id: offset * 100 + i })),
+    { total: 900, offset: offset * 100 }
+  );
+  const p = bootThinkingPage({ pages: [big(0), big(1), big(2), big(3)] });
+  await drain(40);
+  const foot = p.foot().innerHTML;
+  if (!/newest 300/.test(foot)) throw new Error(`the cap is silent: ${foot}`);
+  if (p.requests.filter((u) => /by-builder/.test(u)).length !== 3) throw new Error('read past the cap');
+});
+
+// ---------------------------------------------------------------------------
+// The filter strip
+
+await test('the filter strip is built from the five states, in the shared order', async () => {
+  const p = bootThinkingPage({ pages: [page([star()])] });
+  await drain();
+  const ids = p.tabs().ids;
+  const expected = ['everything', ...p.objects().ORDER];
+  if (ids.join(',') !== expected.join(',')) throw new Error(`strip is ${ids.join(',')}`);
+});
+
+await test('choosing a filter shows only that object', async () => {
+  const p = bootThinkingPage({ pages: [page([star(), remnant()])] });
+  await drain();
+  p.filter('remnant');
+  const html = p.rows();
+  if (!html.includes('It burned, then it went')) throw new Error('the remnant is missing');
+  if (html.includes('It ignited')) throw new Error('the filter let a star through');
+});
+
+await test('a filter nobody has any of is hidden — but never "everything", and never the active one', async () => {
+  const p = bootThinkingPage({ pages: [page([star()])] });
+  await drain();
+  const t = p.tabs();
+  if (t.hidden.remnant !== true) throw new Error('an empty filter is offered');
+  if (t.hidden.star === true) throw new Error('hid a filter with rows behind it');
+  if (t.hidden.everything === true) throw new Error('hid the way back to everything');
+  // Select an empty one, then re-render: the control a reader is looking
+  // through must not disappear out from under them.
+  p.filter('remnant');
+  if (t.hidden.remnant === true) throw new Error('hid the filter the reader is using');
+});
+
+await test('an empty filter says which one is empty, and an empty trail invites a first thought', async () => {
+  const p = bootThinkingPage({ pages: [page([star()])] });
+  await drain();
+  p.filter('remnant');
+  if (!/Nothing of yours is burned out/.test(p.rows())) throw new Error('an empty filter said nothing useful');
+
+  const q = bootThinkingPage({ pages: [page([])] });
+  await drain();
+  if (!/File a thought/.test(q.rows())) throw new Error('an empty trail read as a failure');
+});
+
+// ---------------------------------------------------------------------------
+// It is the AUTHOR'S own view
+
+await test('the trail read is for the viewer\'s own id, taken from /me', async () => {
+  const p = bootThinkingPage({ pages: [page([star()])], viewer: { id: 4242 } });
+  await drain();
+  if (!p.requests.some((u) => u.includes('/inbox/by-builder/4242'))) {
+    throw new Error(`never read the viewer's own trail: ${p.requests.join(' ')}`);
+  }
+});
+
+await test('the table carries five columns and no id column', async () => {
+  // The agreed shape, and the reason: on the one page where every row is yours,
+  // an id is a lookup key with nothing to look up.
+  const p = bootThinkingPage({ pages: [page([star()])] });
+  await drain();
+  const html = p.rows();
+  const heads = html.match(/<th[ >]/g) || [];
+  if (heads.length !== 5) throw new Error(`expected 5 columns, got ${heads.length}`);
+  if (/ledger__num/.test(html)) throw new Error('the id column came back');
+});
+
+await test('a title is escaped before it reaches the page', async () => {
+  const p = bootThinkingPage({ pages: [page([star({ title: '<script>x</script>' })])] });
+  await drain();
+  if (p.rows().includes('<script>')) throw new Error('rendered raw markup from a row');
+});
+
+await test('a failed trail read leaves an honest line, not a blank page', async () => {
+  const p = bootThinkingPage({ pages: [], trailStatus: 500 });
+  await drain();
+  if (!/Could not read your idea trail/.test(p.rows())) throw new Error('failed silently');
+});
+
+summary();

package/tests/helpers.mjs

@@ -731,3 +731,127 @@ export function bootIdeaPage({ idea = null, status = 200, template = null, viewe
 
 // One microtask turn — profile.js boots through a chain of awaits.
 export const settle = () => new Promise((r) => setTimeout(r, 0));
+
+// bootThinkingPage — boot the REAL modules/hall-ui/public/thinking.js in a vm
+// against a stub DOM, and hand back what it wrote into each of the page's four
+// regions plus every request it made.
+//
+// The third sibling of bootProfilePage / bootIdeaPage, and here for the reason
+// the second one is: THE ROOM (task 1004098 / BV2.R03) is asserted at the
+// RENDERED layer. Everything this page shows already has a server-side test —
+// the five states, size, the descent, brightness — and every one of them can
+// still reach a reader wrong, because what a reader is handed is HTML. Testing
+// the read alone is exactly how a renderer bug survives (the first of the three
+// findings inherited from abandoned task 1004054).
+//
+// THE REAL idea-objects.js IS LOADED INTO THE SAME SANDBOX, never stubbed. It
+// is half of the decision this page makes — the server says WHICH object, that
+// file says what the object is CALLED — so a suite that stubbed it would assert
+// the page renders a label the suite itself invented.
+const THINKING_JS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/thinking.js'), 'utf8');
+const IDEA_OBJECTS_JS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/idea-objects.js'), 'utf8');
+export function bootThinkingPage({ pages = [], viewer = { id: 95 }, meStatus = 200, trailStatus = 200 } = {}) {
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; }, addEventListener() {},
+    querySelector() { return null; }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  const documentObj = {
+    title: '',
+    body: { dataset: { page: 'thinking' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {},
+  };
+
+  // The kit's tab strip, reduced to what the page actually uses: the ids it was
+  // built with, a per-id count, a per-id hidden flag and a way to activate one.
+  // `querySelector` here answers a REAL object rather than null, because the
+  // page's "hide a filter nobody has any of" rule is a behaviour the suite must
+  // be able to read — a stub answering null for every selector would make that
+  // rule untestable while looking exactly like a passing one.
+  const tabState = { ids: [], counts: {}, hidden: {}, active: null, onChange: null };
+  const tabsEl = makeEl();
+  tabsEl.querySelector = (sel) => {
+    const m = /\[data-tab="(.+)"\]/.exec(String(sel));
+    if (!m) return null;
+    const id = m[1];
+    if (!tabState.ids.includes(id)) return null;
+    return { set hidden(v) { tabState.hidden[id] = !!v; }, get hidden() { return !!tabState.hidden[id]; } };
+  };
+
+  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 };
+      }
+      if (trailStatus !== 200) return { status: trailStatus, ok: false, data: null };
+      const offset = Number((/offset=(\d+)/.exec(url) || [])[1] || 0);
+      // The caller supplies whole PAGES keyed by offset, so the page's
+      // background paging loop is exercised rather than bypassed — the figures
+      // over the list are a claim about a whole trail, and a stub that always
+      // answered the first window would never let that claim be wrong.
+      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() {},
+    },
+    OTBKit: {
+      makeTabs({ tabs = [], onChange = null }) {
+        tabState.ids = tabs.map((t) => t.id);
+        tabState.labels = tabs.map((t) => t.label);
+        tabState.onChange = onChange;
+        tabState.active = tabs.length ? tabs[0].id : null;
+        return {
+          el: tabsEl,
+          active: () => tabState.active,
+          activate(id) { tabState.active = id; if (onChange) onChange(id); },
+          setCount(id, n) { tabState.counts[id] = n; },
+        };
+      },
+    },
+    location: { hostname: 'builders.cloudbongos.com', search: '', pathname: '/thinking', hash: '', assign() {} },
+    localStorage: { getItem: () => null, setItem() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    console, setTimeout, clearTimeout, URLSearchParams,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(IDEA_OBJECTS_JS, sandbox, { filename: 'idea-objects.js' });
+  vm.runInContext(THINKING_JS, sandbox, { filename: 'thinking.js' });
+
+  return {
+    requests,
+    objects: () => windowObj.OTBIdeaObjects,
+    rows: () => documentObj.getElementById('tr-body').innerHTML,
+    figs: () => documentObj.getElementById('tr-figs').innerHTML,
+    foot: () => documentObj.getElementById('tr-foot'),
+    sub: () => documentObj.getElementById('tr-sub').textContent,
+    tabs: () => tabState,
+    filter: (id) => { tabState.active = id; if (tabState.onChange) tabState.onChange(id); },
+  };
+}

package/tests/nav_permission_atoms.mjs

@@ -87,7 +87,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the file and left the query alone, so a returning browser kept the cached copy —
 // a fix that reaches nobody looks identical to a fix that does not work.
 
-const SHELL_SHA = 'd91b8e5fad83c8e2';
+const SHELL_SHA = '8a93e0b4ca715b9c';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);