@bongos/core 1.19.1051 → 1.19.1053

package/tests/hall_fullscreen.mjs

@@ -0,0 +1,196 @@
+// tests/hall_fullscreen.mjs — the hall's shared full-screen switch (task 1004327,
+// BV2.TW20, goal 1000095; owner decision 2026-09-27).
+//
+// The studio and Your thinking sit in the hall chrome, and each carries ONE
+// switch that hides the sidebar and the top bar so the page fills the window.
+// The switch is the shell's, not a page's: a page opts in with
+// <body data-fullscreen-switch>, and the shell renders the button, keeps the
+// state on html[data-fullscreen="on"], remembers it PER PAGE in localStorage and
+// lets Escape leave. These cases boot the REAL shell.js in a DOM stub and drive
+// it the way a reader does — press the button, reload, press Escape — so a
+// switch that renders but does not remember, or an Escape that fights the sky's
+// own use of the key, fails here. The two source assertions at the end are
+// labelled as such: the CSS half (what "hidden" means) is proven by the kit
+// renders in the ship notes, not by a regex.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const SHELL = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+
+// Boot the shell once — one page load. `store` is the browser's localStorage and
+// is SHARED across boots on purpose: a second boot over the same store is a reload.
+function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = false } = {}) {
+  const els = new Map();
+  const windowListeners = {};
+  const timers = [];
+  const makeEl = (id) => {
+    const attrs = {};
+    return {
+      id, dataset: {}, style: {}, textContent: '', hidden: false, _html: '', title: '',
+      classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+      setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; }, removeAttribute(k) { delete attrs[k]; },
+      addEventListener(ev, fn) { (this._on ||= {})[ev] = fn; },
+      querySelector() { return null; }, querySelectorAll() { return []; },
+      appendChild() {}, focus() {}, click() { if (this._on && this._on.click) this._on.click({ target: this }); },
+      insertAdjacentElement() {}, remove() {},
+      set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+    };
+  };
+  // The topbar's innerHTML is the shell's own markup; an id the shell rendered
+  // into it resolves only if that markup really carries it, so a button the
+  // shell forgot to render cannot be clicked into existence by the stub.
+  const topbar = makeEl('app-topbar');
+  const getElementById = (id) => {
+    if (id === 'app-topbar') return topbar;
+    if (/^(fullscreen-toggle|theme-toggle|zoom-toggle|topbar-menu|topbar-title|topbar-jump)$/.test(id)
+      && !topbar._html.includes(`id="${id}"`)) return null;
+    if (!els.has(id)) els.set(id, makeEl(id));
+    return els.get(id);
+  };
+  const body = {
+    dataset: { page },
+    hasAttribute: (k) => optIn && k === 'data-fullscreen-switch',
+  };
+  const documentObj = {
+    body,
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
+    getElementById,
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(null); },
+    addEventListener() {}, dispatchEvent() {},
+    get cookie() { return ''; }, set cookie(_v) {},
+  };
+  const location = { hostname: 'h', origin: 'https://h', pathname: '/' + page, hash: '', search: '', assign() {}, replace() {} };
+  const localStorage = {
+    getItem: (k) => { if (storageThrows) throw new Error('SecurityError'); return k in store ? store[k] : null; },
+    setItem: (k, v) => { if (storageThrows) throw new Error('SecurityError'); store[k] = String(v); },
+  };
+  let resizes = 0;
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => ({ request: () => new Promise(() => {}) }) },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage, location,
+    requestAnimationFrame() {}, scrollTo() {},
+    addEventListener(type, fn) { (windowListeners[type] ||= []).push(fn); },
+    dispatchEvent(ev) { if (ev && ev.type === 'resize') resizes += 1; return true; },
+    setTimeout: (fn) => { timers.push(fn); return timers.length; },
+  };
+  const sandbox = {
+    window: windowObj, document: documentObj, location, console, clearTimeout() {}, queueMicrotask,
+    setTimeout: windowObj.setTimeout,
+    Event: class { constructor(t) { this.type = t; } },
+    CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } },
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
+  const root = documentObj.documentElement;
+  return {
+    store,
+    button: () => getElementById('fullscreen-toggle'),
+    on: () => root.dataset.fullscreen === 'on',
+    resizes: () => resizes,
+    // Press a key the way the browser dispatches it: every window listener,
+    // then the page may mark the press used, then the queued timers run.
+    press(key, { target = { tagName: 'CANVAS' }, pageUses = false } = {}) {
+      const ev = { key, target, defaultPrevented: false, preventDefault() { this.defaultPrevented = true; } };
+      for (const fn of windowListeners.keydown || []) fn(ev);
+      if (pageUses) ev.preventDefault();
+      while (timers.length) timers.shift()();
+    },
+  };
+}
+
+test('a page that does not opt in gets no switch, and never goes full screen', () => {
+  const store = { 'hall-fullscreen:work': 'on' };
+  const p = boot({ page: 'work', optIn: false, store });
+  assert.equal(p.button(), null, 'no button rendered');
+  assert.equal(p.on(), false, 'a stored value for a page with no switch is ignored');
+});
+
+test('an opted-in page renders ONE switch in the top bar, off by default', () => {
+  const p = boot();
+  const btn = p.button();
+  assert.ok(btn, 'the switch is in the top bar');
+  assert.equal(p.on(), false);
+  assert.equal(btn.getAttribute('aria-pressed'), 'false');
+  assert.equal(btn.getAttribute('aria-label'), 'Full screen');
+});
+
+test('the switch hides the chrome, the same button brings it back', () => {
+  const p = boot();
+  p.button().click();
+  assert.equal(p.on(), true, 'html[data-fullscreen="on"]');
+  assert.equal(p.button().getAttribute('aria-pressed'), 'true');
+  assert.equal(p.button().getAttribute('aria-label'), 'Leave full screen');
+  assert.ok(p.resizes() >= 1, 'a page that sizes to its box is told to re-measure');
+  p.button().click();
+  assert.equal(p.on(), false, 'and back');
+});
+
+test('THE CHOICE SURVIVES A RELOAD — and it is remembered per page', () => {
+  const store = {};
+  boot({ page: 'thinking', store }).button().click();
+  assert.equal(store['hall-fullscreen:thinking'], 'on');
+  assert.equal(boot({ page: 'thinking', store }).on(), true, 'the reload opens in full screen');
+  assert.equal(boot({ page: 'studio', store }).on(), false, 'the studio did not follow the sky');
+  boot({ page: 'thinking', store }).button().click();
+  assert.equal(boot({ page: 'thinking', store }).on(), false, 'leaving is remembered too');
+});
+
+test('Escape leaves full screen', () => {
+  const p = boot({ store: { 'hall-fullscreen:thinking': 'on' } });
+  assert.equal(p.on(), true);
+  p.press('Escape');
+  assert.equal(p.on(), false);
+});
+
+test('an Escape the PAGE used (the sky\'s tour, menu or pick) does not also leave', () => {
+  const p = boot({ store: { 'hall-fullscreen:thinking': 'on' } });
+  p.press('Escape', { pageUses: true });
+  assert.equal(p.on(), true, 'the page marked the press used, after the shell heard it');
+});
+
+test('an Escape inside a text field belongs to the field', () => {
+  const p = boot({ store: { 'hall-fullscreen:thinking': 'on' } });
+  p.press('Escape', { target: { tagName: 'INPUT' } });
+  assert.equal(p.on(), true);
+  p.press('x');
+  assert.equal(p.on(), true, 'other keys are not the switch\'s');
+});
+
+test('storage that throws (a private window) leaves the chrome showing and the switch working', () => {
+  const p = boot({ storageThrows: true });
+  assert.equal(p.on(), false);
+  p.button().click();
+  assert.equal(p.on(), true, 'the switch still works for this page load');
+});
+
+test('the studio and Your thinking opt in, inside the hall chrome; the project sky does not (yet)', () => {
+  for (const f of ['studio.html', 'thinking.html']) {
+    const html = read(f);
+    assert.match(html, /<body[^>]*\bdata-fullscreen-switch\b/, `${f} opts in`);
+    for (const id of ['app-sidebar', 'app-topbar']) assert.match(html, new RegExp(`id="${id}"`), `${f} carries #${id}`);
+    assert.match(html, /<main id="hall-main"/, `${f}: the skip link's target`);
+    assert.equal((html.replace(/<!--[\s\S]*?-->/g, '').match(/<header\b/g) || []).length, 1, `${f}: the top bar is the one <header>`);
+  }
+  assert.doesNotMatch(read('goal-map.html'), /data-fullscreen-switch|shell\.js/, '/goal-map keeps its standalone form');
+});
+
+// SOURCE ASSERTION (the CSS half): full screen hides the sidebar and the foot
+// but keeps the top bar IN the document, collapsed to its switch — so the page
+// keeps one <header> and the way back is where the way in was.
+test('source: full screen hides the sidebar and foot, and collapses the top bar rather than removing it', () => {
+  const css = read('style.css');
+  assert.match(css, /html\[data-fullscreen="on"\] \.app-sidebar,\s*html\[data-fullscreen="on"\] \.app-scrim,\s*html\[data-fullscreen="on"\] \.app-foot \{ display: none; \}/);
+  assert.match(css, /html\[data-fullscreen="on"\] \.topbar-side > :not\(\.fullscreen-toggle\)/);
+  assert.doesNotMatch(css, /html\[data-fullscreen="on"\] \.app-topbar \{ display: none/);
+});

package/tests/hall_sky.mjs

@@ -20,6 +20,7 @@
 // tests/hall_thinking_room.mjs.
 
 import assert from 'node:assert/strict';
+import * as FS from 'node:fs';
 import { makeRunner, settle, bootSkyPage } from './helpers.mjs';
 
 const { test, summary } = makeRunner();
@@ -367,11 +368,38 @@ await test('the bands come from the versions read: building at the centre, shipp
   for (const f of src) assert.doesNotMatch(fs.readFileSync(path.join('modules/hall-ui/public', f), 'utf8'), /BONGOS-V\d|GDS-V\d|PMS-V\d|CB-V\d/, `${f} names no instance version`);
 });
 
-await test('"the whole project" leaves for the project sky at /goal-map', async () => {
-  const p = await boot({ mine: mine(FIVE()) });
-  p.click('lensAll');
-  assert.equal(p.navigated, '/goal-map');
-  assert.equal(p.S().lens, 'mine', 'this page does not switch — part 4 owns that view');
+// ═══ only your thinking (task 1004328, owner decision 2026-09-27) ═══════════
+// The whole-project lens and the project map's features live only on
+// /goal-map (tests/goal_map_page.mjs). Here they are ABSENT from the markup,
+// not merely hidden, and nothing — a button, the tour, a jump, the panel —
+// takes this sky into "the whole project" or leaves for that page.
+
+await test('ONLY YOUR THINKING: no "the whole project" lens, no "my ideas", no explore — absent from the page, not hidden', async () => {
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions() });
+  same(p.S().lenses, ['simple', 'mine']);
+  for (const id of ['lensAll', 'ideasBtn', 'exploreBtn', 'start', 'startOpts']) assert.equal(p.el(id), null, `#${id} is the project map's, not this page's`);
+  for (const id of ['lensSimple', 'lensMine', 'recentBtn', 'claudeBtn', 'influenceBtn', 'rehearse']) assert.ok(p.el(id), `#${id} is your thinking's own tool`);
+  // The markup a person meets — the header comments may explain the split, and do.
+  const html = FS.readFileSync('modules/hall-ui/public/thinking.html', 'utf8').replace(/<!--[\s\S]*?-->/g, '');
+  assert.doesNotMatch(html, /the whole project/, 'the words are gone from the markup too');
+  assert.doesNotMatch(html, /goal-map/, 'and this page never names the project map');
+  assert.doesNotMatch(p.el('legend').innerHTML, /unexplored/, 'the legend does not teach explore, which this sky does not have');
+});
+
+await test('nothing takes /thinking into the whole project: setLens, the panel and the switcher all stay in your sky', async () => {
+  const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions() });
+  p.SKY().setLens('all', true);
+  assert.equal(p.S().lens, 'mine', 'a lens this page does not have is never entered');
+  p.click('lensSimple'); assert.equal(p.S().lens, 'simple');
+  p.click('lensMine'); assert.equal(p.S().lens, 'mine');
+  assert.equal(p.navigated, null, 'no lens leaves for another page');
+  p.SKY().pick({ kind: 'goal', ref: p.S().goals[0] }, false);
+  p.click('descendBtn');
+  assert.equal(p.S().lens, 'mine', 'descending into a well stays in your thinking');
+  p.click('lensSimple'); p.SKY().pick({ kind: 'goal', ref: p.S().goals[0] }, false); p.click('descendBtn');
+  assert.equal(p.S().lens, 'mine', 'from "simple", descending steps up to your thinking — the one lens here that zooms');
+  const src = FS.readFileSync('modules/hall-ui/public/sky-interaction.js', 'utf8');
+  assert.doesNotMatch(src, /location\.assign|'\/goal-map'|'\/thinking'/, 'the switcher has no door to the other page');
 });
 
 // ═══ the words are never markup ══════════════════════════════════════════════
@@ -392,25 +420,34 @@ await test('a title never becomes markup — in the drawer, the panel and the ho
 
 // ═══ the tour, the lenses and the keys ═══════════════════════════════════════
 
-await test('the tour is the template\'s thirteen steps — ? opens it, Escape closes it', async () => {
+await test('the tour is your thinking\'s nine of the template\'s thirteen steps, in order and never in the whole project — ? opens it, Escape closes it', async () => {
   const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions() });
-  const STEPS = p.SKY().STEPS;
-  assert.equal(STEPS.length, 13);
-  same(STEPS.map((s) => s.h), [
+  // The template's thirteen are all still in the list; the four the project map owns are /goal-map's (task 1004328).
+  const template = [
     'This is your sky.', 'A goal is a gravity well.', 'A ring is a criterion.', 'A burning thought is a star.', 'Some thoughts became the structure.',
     'Unclaimed thoughts drift.', 'An alive well glows.', 'Routes run between goals that wait on each other.', 'A settled system is a goal that finished.',
     'The sky has a clock.', 'By default, you explore.', 'Release a thought here.', 'When it is too much, go simple.',
+  ];
+  same(p.SKY().ALL_STEPS.map((s) => s.h).filter((h) => template.includes(h)), template, 'every template step survives, in its order');
+  const STEPS = p.SKY().STEPS;
+  assert.equal(STEPS.length, 9);
+  same(STEPS.map((s) => s.h), [
+    'This is your sky.', 'A goal is a gravity well.', 'A ring is a criterion.', 'A burning thought is a star.', 'Some thoughts became the structure.',
+    'Unclaimed thoughts drift.', 'The sky has a clock.', 'Release a thought here.', 'When it is too much, go simple.',
   ]);
   assert.equal(p.el('tour').hidden, true);
   p.key('?');
   assert.equal(p.el('tour').hidden, false);
-  assert.equal(p.el('tourN').textContent, 'how to read the sky · 1 of 13');
-  for (let n = 0; n < 12; n++) p.click('tourNext');
-  assert.equal(p.el('tourN').textContent, 'how to read the sky · 13 of 13');
+  assert.equal(p.el('tourN').textContent, 'how to read the sky · 1 of 9');
+  const lenses = new Set([p.S().lens]);
+  for (let n = 0; n < 8; n++) { p.click('tourNext'); lenses.add(p.S().lens); }
+  assert.equal(lenses.has('all'), false, 'no step of this tour enters the whole project');
+  assert.equal(p.el('tourN').textContent, 'how to read the sky · 9 of 9');
   assert.equal(p.el('tourNext').textContent, 'start reading');
   p.key('Escape');
   assert.equal(p.el('tour').hidden, true);
   assert.equal(p.S().lens, 'mine', 'the tour hands the sky back to your thinking');
+  assert.equal(p.navigated, null);
 });
 
 await test('the tour opens by itself on a first visit, and only then', async () => {

package/tests/helpers.mjs

@@ -904,7 +904,8 @@ export function bootSkyPage({
   };
 
   // ── the window ───────────────────────────────────────────────────────────
-  const store = { ...(tourSeen ? { 'sky-tour-seen': '4' } : {}), ...storage };
+  // Each page keeps its own tour-seen key (task 1004328); tourSeen marks both.
+  const store = { ...(tourSeen ? { 'sky-tour-seen': '4', 'sky-map-tour-seen': '4' } : {}), ...storage };
   let raf = null;
   const windowObj = {
     __BRANDING__: {}, __MODULES__: { enabled: {} },

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 = '6b28297270d1e1f0';
+const SHELL_SHA = '7f66604d74d544e8';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);