@bongos/core 1.21.105 → 1.21.106

package/tests/github_pick_up.mjs

@@ -13,7 +13,7 @@
 //   2. the runner — a stopped sign-in is re-asked with the keys already placed and becomes
 //      'done'; a placement that throws after GitHub's conversion is a SPENT code (never
 //      re-queued); GitHub's 404 on a conversion drops the dead code.
-//   3. the REAL status route's answer run into the REAL page (seedSetup + the step renderers):
+//   3. the REAL status route's answer run into the REAL page (seedSetup + part 03's facts, task 1004683):
 //      every reachable state draws a sentence and an action, none a chore or "contact us".
 //   4. the page's own actions: pick-up posts to the pick-up route and watches again, Reopen
 //      GitHub goes through the mint route (which hands back the SAME state), and "Send it to
@@ -184,29 +184,29 @@ const express = require('express');
 const app = express();
 app.use('/api/bongos', require(path.join(ROOT, 'modules', 'provisioning', 'routes', 'github-setup.js'))());
 
-const RS = SCRIPT.indexOf('    /* The four GitHub steps of part 03');
-const RE = SCRIPT.indexOf('    var STEP_RENDERERS = {', RS);
+// part 03's facts (task 1004683): the pure half of the facts region, the seed, and the actions
+const FS = SCRIPT.indexOf('    function ghStep(key) {');
+const FE = SCRIPT.indexOf('    /* ── drawing it: nodes and textContent only', FS);
 const SS = SCRIPT.indexOf('    /* the checklist the server derived (task 1004649)');
 const SE = SCRIPT.indexOf('    function setupOpen() {', SS);
 const AS = SCRIPT.indexOf('    /* ── Pick up where it stopped (task 1004652).');
 const AE = SCRIPT.indexOf('    function startManifest(btn) {', AS);
 
 test('the page regions are findable (a rename must fail loudly)', () => {
-  assert.ok(RS > 0 && RE > RS && SS > 0 && SE > SS && AS > 0 && AE > AS);
+  assert.ok(FS > 0 && FE > FS && SS > 0 && SE > SS && AS > 0 && AE > AS);
 });
 
-const esc = (x) => String(x).replace(/[&<>"']/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[ch]));
 function page(extra = {}) {
+  const now = new Date().toISOString();
   const sandbox = {
-    live: { manifest: null, manifestMsg: '', manifestCode: '', manifestFailure: null, appSlug: null, appOrg: null, setup: null, installUrl: null, instStatus: 'active', addrReady: true, pickUp: null, verifying: false, askedPlatform: false },
-    state: { name: 'Mercury', slug: 'mercury', owner: 'acme', repo: 'mercury' }, autoOpenArmed: false,
-    resolvedDomain: () => 'mercury.example.com', apexBase: () => 'example.com', esc,
-    GH_ICON: '', manualOauthDetails: () => '<details>manual</details>', projectPageLink: (t) => t, autoOpenTick: () => '',
-    progressMarkup: (a, b, note) => `<prog>${note}</prog>`, encodeURIComponent, JSON,
+    live: { manifest: null, manifestMsg: '', manifestCode: '', manifestFailure: null, appSlug: null, appOrg: null, setup: null, installUrl: null, instStatus: 'active', addrReady: true, pickUp: null, verifying: false, askedPlatform: false,
+      inst: { id: 42, status: 'active', domain: 'mercury.example.com', dns_resolves: true, last_verified_up: true, last_verified_at: now, created_at: now, provisioned_at: now, open_intent: null }, readAt: Date.now(), gone: '', repo: null },
+    state: { name: 'Mercury', slug: 'mercury', owner: 'acme', repo: 'mercury' },
+    resolvedDomain: () => 'mercury.example.com', apexBase: () => 'example.com', addressReady: () => true, API: '/api/bongos',
     ...extra,
   };
   vm.createContext(sandbox);
-  vm.runInContext(`${SCRIPT.slice(RS, RE)}\n${SCRIPT.slice(SS, SE)}\n${SCRIPT.slice(AS, AE)}`, sandbox);
+  vm.runInContext(`${SCRIPT.slice(FS, FE)}\n${SCRIPT.slice(SS, SE)}\n${SCRIPT.slice(AS, AE)}`, sandbox);
   return sandbox;
 }
 // what the page's poll does with one answer (pollManifest's tick, minus the timer)
@@ -216,7 +216,12 @@ function seedFrom(sb, d) {
   sb.live.manifest = d.ready ? 'done' : d.status;
   sb.live.manifestFailure = d.failure || null;
 }
-const ROWS = ['renderStepOauthApp', 'renderStepAppInstall', 'renderStepFirstSignIn', 'renderStepDeviceFlow'];
+// the GitHub facts and the one sentence, as the founder reads them (vm-born values through JSON)
+function facts(sb) {
+  return JSON.parse(JSON.stringify(vm.runInContext('(function () { var n = Date.now(), h = homeFacts(live.inst, n), g = ghFacts(n); return { gh: g, said: setupSentence(h, g) }; })()', sb)));
+}
+const words = (r) => [r.title, [].concat(r.sub || []).map((p) => (typeof p === 'string' ? p : p.t)).join('')].join(' ');
+const acts = (r) => [].concat(r.act || []);
 const CHORE = /\/contact|Contact us|delete it|Developer settings → GitHub Apps\) so|Try again anyway|Start the setup again|by hand/;
 
 // every shape the status derivation can reach, as rows the real route reads
@@ -256,31 +261,37 @@ test('every state the setup can reach: the REAL status answer draws a sentence a
     assert.equal(d.ok, true, name);
     const sb = page();
     seedFrom(sb, d);
-    const html = ROWS.map((f) => vm.runInContext(`${f}()`, sb)).join('\n');
-    seen[name] = { pick: d.pick_up, html };
-    assert.doesNotMatch(html, CHORE, `${name}: no manual chore and no "contact us"`);
-    // a stopped step always carries the action that fixes it
-    for (const li of html.split('\n').filter((x) => /class="sstopped/.test(x))) {
-      assert.match(li, /data-action="(pick-up|manifest-start|ask-platform)"/, `${name}: a stopped step has its button — ${li.slice(0, 120)}`);
+    const f = facts(sb);
+    const all = f.gh.map(words).join('\n') + '\n' + f.said.map((p) => p.t).join('');
+    const allActs = f.gh.flatMap(acts);
+    seen[name] = { pick: d.pick_up, f, all, allActs };
+    assert.doesNotMatch(all, CHORE, `${name}: no manual chore and no "contact us"`);
+    // a stopped fact always carries the action that fixes it
+    for (const r of f.gh.filter((x) => x.state === 'bad')) {
+      assert.ok(acts(r).some((a) => /^(pick-up|pick-up-link|connect|ask-platform|manage)$/.test(a)), `${name}: the stopped "${r.title}" has its button`);
+    }
+    // a pick-up the server offers is on the page, once
+    if (d.pick_up === 'check' || d.pick_up === 'convert') {
+      assert.equal(allActs.filter((a) => /^pick-up/.test(a) || a === 'check-again').length, 1, `${name}: ${d.pick_up} is offered once`);
     }
-    // a pick-up the server offers is on the page
-    if (d.pick_up === 'check' || d.pick_up === 'convert') assert.match(html, /data-action="pick-up"/, `${name}: ${d.pick_up} is offered`);
-    if (d.pick_up === 'operator') assert.match(html, /data-action="ask-platform"/, `${name}: the platform team is one click away`);
-    if (d.pick_up === 'reopen') assert.match(html, /data-action="reopen-github"/, `${name}: the same link can be reopened`);
+    if (d.pick_up === 'operator') assert.ok(allActs.includes('ask-platform'), `${name}: the platform team is one click away`);
+    if (d.pick_up === 'reopen') assert.ok(allActs.includes('reopen'), `${name}: the same link can be reopened`);
     // a new link is offered ONLY where nothing was made on GitHub
-    if (/data-action="manifest-start"/.test(html)) assert.ok(d.pick_up === 'fresh', `${name}: Connect GitHub is offered only when no app exists (pick_up=${d.pick_up})`);
+    if (allActs.includes('connect')) assert.ok(d.pick_up === 'fresh', `${name}: Connect GitHub is offered only when no app exists (pick_up=${d.pick_up})`);
   }
   assert.equal(seen['waiting on GitHub'].pick, 'reopen');
   assert.equal(seen['link lapsed'].pick, 'fresh');
   assert.equal(seen['conversion stopped, code young'].pick, 'convert');
   assert.equal(seen['conversion stopped, code spent'].pick, 'operator');
   assert.equal(seen['sign-in unconfirmed, re-asking'].pick, null);
-  assert.match(seen['sign-in unconfirmed, re-asking'].html, /We’re asking it again/);
+  assert.match(seen['sign-in unconfirmed, re-asking'].all, /Asking your project again, with the app GitHub already made\./);
   assert.equal(seen['sign-in unconfirmed, window over'].pick, 'check');
-  assert.match(seen['signed in, install never confirmed, window over'].html, /GitHub stopped before the app was installed on your repo\. Nothing is lost, and no second app will be made\./, 'the mockup\'s sentence, from the real read');
-  assert.match(seen['installed, device flow off, window over'].html, /Turned it on\? Check again/);
+  const never = seen['signed in, install never confirmed, window over'];
+  assert.equal(never.f.gh[1].sub, 'GitHub stopped before the app was on acme/mercury.', 'the mockup\'s sentence, from the real read');
+  assert.equal(never.f.said.map((p) => p.t).join(''), 'One step stopped. Nothing is lost, and no second app will be made.', 'said once, in the sentence');
+  assert.ok(seen['installed, device flow off, window over'].allActs.includes('check-again'));
   assert.equal(seen['all four ticked'].pick, null);
-  assert.doesNotMatch(seen['all four ticked'].html, /sstopped|data-action="pick-up"/);
+  assert.ok(!seen['all four ticked'].f.gh.some((r) => r.state === 'bad') && !seen['all four ticked'].allActs.some((a) => /^pick-up/.test(a)));
   t.diagnostic(Object.entries(seen).map(([k, v]) => `${k}: ${v.pick}`).join(' · '));
 });
 
@@ -289,13 +300,13 @@ test('every state the setup can reach: the REAL status answer draws a sentence a
 function actions({ pickUp, answer, manifestState = null, blockerStatus = 201 }) {
   const calls = { fetched: [], polled: [], progress: [], started: 0, renders: 0 };
   const sb = page({
-    API: '/api/bongos', instanceId: 42, manifestState, pollTimer: null, lastStepsHtml: 'x', manifestStartedAt: 1700000000000, ghTab: null,
+    instanceId: 42, manifestState, pollTimer: null, manifestStartedAt: 1700000000000, ghTab: null,
     fetch: async (url, init) => {
       calls.fetched.push({ url, init });
       if (/\/blockers$/.test(url)) return { ok: blockerStatus < 300, status: blockerStatus, json: async () => ({}) };
       return { ok: true, status: 200, json: async () => answer };
     },
-    rememberManifest: () => {}, renderSteps: () => { calls.renders++; },
+    rememberManifest: () => {}, repaintFacts: () => { calls.renders++; }, paintFacts: () => { calls.renders++; },
     pollManifest: (s) => calls.polled.push(s), startProgress: (id) => calls.progress.push(id),
     startManifest: () => { calls.started++; },
   });

package/tests/onboard.mjs

@@ -193,11 +193,12 @@ test('every render surface carries the terminal hall step (task 1002703)', () =>
   const cli = read('scripts/gds/onboard.js');
   assert.match(cli, /builders hall/i, 'the CLI walkthrough ends at the hall');
   assert.match(cli, /bongos dev/, 'the CLI offers the local-hall one-liner when no domain');
+  // the one page (task 1004683): the hall is entered through the Enter Genesis door, the
+  // hall's founding mode, once every required fact of part 03 is done
   const hubHtml = read('modules/public-landing/public/projects.html');
-  const enterHall = hubHtml.match(/data-onboard-step="enter-hall"[^]*?<\/li>/g) || [];
-  assert.ok(enterHall.length >= 1, 'the ?view=new wizard tags the enter-hall step');
-  assert.match(enterHall.join(''), /\/builders/, 'the wizard points at the hall address');
-  assert.match(enterHall.join(''), /bongos dev/, 'the wizard offers the local hall when no domain');
+  assert.match(hubHtml, /<a class="btn" id="enterGenesis" data-onboard-step="enter-hall" target="_blank" rel="noopener">Enter Genesis<\/a>/,
+    'the ?view=new wizard tags the enter-hall step on its Enter Genesis door');
+  assert.match(hubHtml, /\$\('enterGenesis'\)\.setAttribute\('href', 'https:\/\/' \+ inst\.domain\);/, 'which opens the project\'s own address');
 });
 
 test('the wizard done panel is plan-driven, manifest-driven, and owner-honest (task 1002694)', () => {
@@ -206,8 +207,10 @@ test('the wizard done panel is plan-driven, manifest-driven, and owner-honest (t
   const { readFileSync } = require('node:fs');
   const path = require('node:path');
   const src = readFileSync(path.join(import.meta.dirname, '..', 'modules/public-landing/public/projects.html'), 'utf8');
-  // gap 2 (idea 1000675): the checklist renders FROM the canonical plan endpoint
-  assert.match(src, /provisioning\/onboard-plan/, 'the done panel fetches the canonical plan');
+  // gap 2 (idea 1000675): the checklist follows the canonical plan. Since task 1004683 part
+  // 03 is a fixed list of facts the server checks, each GitHub fact named by the plan step
+  // it is (FACT_PLAN_STEP); the drift guard below holds that set equal to the plan's.
+  assert.match(src, /var FACT_PLAN_STEP = \{ approve: 'oauth-app', install: 'app-install', sign_in: 'first-sign-in', device_flow: 'device-flow' \};/, 'the facts name their plan steps');
   // gap 3 (idea 1000676): the ADR 0133 one-click manifest flow has a UI caller again
   assert.match(src, /\/github-app/, 'the done panel drives the GitHub-App manifest flow');
   assert.match(src, /github-app\/status/, 'and polls its progress to reflect live state');
@@ -305,7 +308,10 @@ test('the web form (?view=new) declares EXACTLY the canonical human steps — dr
     // keys are kebab-case literals; the charset excludes the page's DYNAMIC fallback
     // tag (data-onboard-step="' + esc(s.key) + '"), which renders unknown plan steps
     // at runtime and has no literal key to pin here (task 1002694).
-    const found = [...src.matchAll(/data-onboard-step="([a-z0-9-]+)"/g)].map((m) => m[1]);
+    // …plus the plan step each of part 03's facts is (task 1004683), set from one map
+    const facts = (src.match(/var FACT_PLAN_STEP = \{([^}]*)\};/) || [, ''])[1];
+    const found = [...src.matchAll(/data-onboard-step="([a-z0-9-]+)"/g)].map((m) => m[1])
+      .concat([...facts.matchAll(/: '([a-z0-9-]+)'/g)].map((m) => m[1]));
     const uniq = [...new Set(found)].sort();
     assert.deepEqual(uniq, humanKeys, `${name} (${rel}) must tag exactly the canonical human steps [${humanKeys}], found [${uniq}]`);
   }

package/tests/project_invite_ui.mjs

@@ -523,7 +523,9 @@ function bootGate({ me = { github_login: 'kestrel' }, created = { id: 7, slug: '
 test('the wizard opens the invite step only once the hall is up, and only for a signed-in owner of a project that exists (tasks 1002346, 1004503)', () => {
   assert.ok(gateSlice().includes('function paintInviteGate(live)'), 'the gate slice is found');
   assert.match(SCRIPT, /function renderDone\(\) \{[\s\S]*?paintInviteGate\(false\);/, 'the done panel paints the gate shut');
-  assert.match(SCRIPT, /if \(inst\.last_verified_up\) \{[\s\S]{0,400}paintInviteGate\(true\);/, 'and opens it only on the verified Live');
+  // since task 1004683: "is alive" — and with it the invite — opens once every required fact
+  // of part 03 is done, which includes the hall answering (last_verified_up)
+  assert.match(SCRIPT, /var on = !!\(ready && inst && hostOk\(inst\.domain\) && addressReady\(inst\) && inst\.last_verified_up === true\);[\s\S]{0,900}paintInviteGate\(on\);/, 'and opens it only on the verified Live');
   assert.equal((SCRIPT.match(/setInviteSlug\('wizInvite'/g) || []).length, 2, 'the gate is the only caller: shut, or open on Live');
 
   const before = bootGate();
@@ -577,8 +579,9 @@ test('the wizard’s invite step ships as real markup in part 03, with the alive
   assert.match(panel, /data-invite-send="wizInvite"/, 'the sender');
   assert.match(panel, /data-invite-skip="wizInvite"/, 'and the skip is a CONTROL, not "leave it and move on"');
   assert.match(panel, /Optional/, 'the panel says so before it asks');
-  assert.ok(panel.indexOf('id="humanSteps"') < panel.indexOf('id="done-h"') && panel.indexOf('id="done-h"') < panel.indexOf('id="wizInvite"'),
-    'the mockup\'s order: the checklist, then "is alive", then the invite (task 1004648)');
+  assert.ok(panel.indexOf('id="ghFacts"') > 0 && panel.indexOf('id="ghFacts"') < panel.indexOf('id="done-h"') && panel.indexOf('id="done-h"') < panel.indexOf('id="wizInvite"') &&
+    panel.indexOf('id="wizInvite"') < panel.indexOf('id="enterGenesis"'),
+    'the mockup\'s order: the facts, then "is alive", then the invite, then the Enter Genesis door (tasks 1004648, 1004683)');
   assert.match(panel, /Invite your first builders\. They become founding builders\./, 'in the mockup\'s words');
   assert.match(panel, /<p class="samePath" id="wizInviteLater"><\/p>/, 'and the way back afterwards is a slot beside the modules one');
   assert.match(SCRIPT, /\$\('wizInviteLater'\)\.innerHTML = 'You can invite builders any time from ' \+ projectPageLink\('the project’s own page'\) \+ '\.';/,

package/tests/project_modules_ui.mjs

@@ -299,10 +299,10 @@ test('the catalog is read ONCE however often the section repaints', async () =>
 
 test('the wizard’s done panel points at the project’s settings for its extras', () => {
   assert.match(HUB, /<p class="samePath" id="doneModules"><\/p>/, 'the panel carries the slot');
-  assert.match(SCRIPT, /\$\('doneModules'\)\.innerHTML = 'Add or remove modules later in ' \+ projectPageLink\('the project’s settings'\) \+ '\.';/,
-    'and renderDone fills it with one sentence pointing at the manage page');
+  assert.match(SCRIPT, /var mods = \$\('doneModules'\);\n\s*mods\.textContent = '';\n\s*partsInto\(mods, \['Add or remove modules later in ', \{ t: 'the project’s settings', href: manageHref\(\) \}, '\.'\]\);/,
+    'and renderDone fills it with one sentence pointing at the manage page, drawn from nodes (task 1004683)');
   assert.equal((SCRIPT.match(/doneModules/g) || []).length, 1, 'one line, written in one place');
-  assert.match(SCRIPT, /function projectPageLink\(label\) \{\s*return '<a href="' \+ \(instanceId \? '\?view=manage&id=' \+ encodeURIComponent\(instanceId\)/,
+  assert.match(SCRIPT, /function manageHref\(\) \{\s*return instanceId \? '\?view=manage&id=' \+ encodeURIComponent\(instanceId\)/,
     'and the link names the instance just created, not the list');
 });
 

package/tests/projects_hub.mjs

@@ -2190,7 +2190,7 @@ test('the wizard folds at one width: no rail fold is left, and no 900px rule is
   assert.match(STYLE, /@media \(max-width:560px\)\{\s*\.setRow\{grid-template-columns:minmax\(0,1fr\) auto;grid-template-areas:"k acts" "v v";/, 'part 02\'s rows stack under 560, Change beside the label');
 });
 
-test('the wizard\'s own structures wear the world: hairline fields, cells of one band, the review as a ledger, the human steps as a numbered ledger, the standup strip as the rail (task 1003346)', () => {
+test('the wizard\'s own structures wear the world: hairline fields, cells of one band, part 02\'s rows, part 03\'s checked facts (tasks 1003346, 1004683)', () => {
   const at = STYLE.indexOf('the create wizard (task 1002763');
   assert.ok(at > -1, 'the wizard block is still the page\'s own');
   const block = STYLE.slice(at);
@@ -2204,13 +2204,12 @@ test('the wizard\'s own structures wear the world: hairline fields, cells of one
   assert.match(block, /\.setRows\{margin:14px 0 0;border-top:1px solid var\(--rule\);\}/, 'part 02\'s rows hang from one hairline');
   assert.match(block, /\.setRow\{display:grid;grid-template-columns:108px minmax\(0,1fr\) auto;[^}]*border-bottom:1px solid var\(--rule\);\}/, 'each row is label · value · Change on its own hairline');
   assert.doesNotMatch(block, /\.review( li)?\{/, 'the ledger\'s rules are gone with renderReview');
-  assert.match(block, /\.humanSteps>li\{\s*display:grid;grid-template-columns:44px 1fr;/, 'the human steps keep the ledger grid');
-  assert.match(block, /#panel-done \.humanSteps>li\{grid-template-columns:24px 1fr;/, 'which part 03 draws as the mockup\'s checklist: a dot, then the step');
-  assert.match(block, /\.humanSteps>li>\*\{grid-column:2;/, 'every child of a step sits in the text column, never under the counter (the sheet\'s bug)');
-  assert.match(block, /#panel-done \.humanSteps>li\.sdone::before\{content:"✓";/, 'a verified step wears the tick in the ok ink');
-  assert.match(block, /\.prog\{background:none;border:0;border-radius:0;padding:0;/, 'the standup strip is drawn as the rail');
-  assert.match(block, /\.prog \.stages li\.now \.sdot::after\{content:none;animation:none;\}/, 'no pulse on the rail');
-  assert.match(block, /\.doneHead \.tick\{display:none;\}/, 'the tick leaves; the rail says filed');
+  // task 1004683 (docs/design/mocks/day-night-rooms/setup-status.html): part 03 is one list
+  // of facts on hairlines — a dot, the fact, when it was checked — and no stage strip at all
+  assert.match(block, /\.setFact\{display:grid;grid-template-columns:24px minmax\(0,1fr\) auto;[^}]*border-top:1px solid var\(--rule\);\}/, 'each fact is dot · fact · when, on its own hairline');
+  assert.match(block, /\.setFact\.done \.d\{background:color-mix\(in srgb,var\(--ok\) 12%,transparent\);color:var\(--ok\);border-color:var\(--ok\);\}/, 'a verified fact wears the tick in the ok ink');
+  assert.match(block, /\.setFact\.bad \.d\{[^}]*color:var\(--err\);/, 'a stopped fact wears the error ink');
+  assert.doesNotMatch(block, /\.prog\b|\.humanSteps|\.doneHead|\.stepsHead|\.ghbtn/, 'the standup strip, the old checklist and their sheet are gone');
   assert.match(block, /\.addrBig code\{display:block;font-family:var\(--font-display\);/, 'the address stands in the display voice');
   assert.doesNotMatch(block, /linear-gradient/, 'no tinted plates');
   // the one exception is drawn, not chrome: the night room's moon glows in the window
@@ -2221,7 +2220,7 @@ test('the wizard\'s own structures wear the world: hairline fields, cells of one
   assert.doesNotMatch(HUB, /data-back="|id="wizBack"/, 'no back door is left');
   assert.match(HUB, /<div class="wizTop">\s*<span class="wizEyebrow" id="wizEyebrow">New project<\/span>\s*<\/div>/, 'the eyebrow alone in the top row');
   assert.match(HUB, /<div class="createBar">\s*<button type="button" class="btn big" id="doCreate">Create my project<\/button>\s*<span class="wizRecap" id="wizRecap"><\/span>/, 'Create, with the one-line recap beside it');
-  assert.match(HUB, /<h2 id="done-part-h"><span class="n">03<\/span>Connect GitHub <span class="state" id="ghState">opens once your project exists<\/span><\/h2>/, 'part 03 names itself and where it is');
+  assert.match(HUB, /<h2 id="done-part-h"><span class="n">03<\/span><span id="donePartT">Connect GitHub<\/span> <span class="state" id="ghState">opens once your project exists<\/span><\/h2>/, 'part 03 names itself and where it is');
   // what is enqueued is unchanged (ADR 0111): the filing body the control plane reads
   assert.match(SCRIPT, /body: JSON\.stringify\(\{\s*slug: state\.slug,/, 'the filing still carries the slug first');
   assert.match(SCRIPT, /hosting_shape: 'cloud-host',/, 'the shape is unchanged');

package/tests/projects_hub_cloud_hop.mjs

@@ -1,21 +1,21 @@
 // tests/projects_hub_cloud_hop.mjs
 //
-// The create wizard's done panel in two moments (task 1004578, from idea 1001205):
-// WAIT — one status line, a thin bar and the cloud hop, a little game with one
-// cloud per PUBLIC project on the platform — then ARRIVE — the steps only the
-// founder can play, all on show as one checklist (part 03, task 1004648). The owner set the game's rules on a played
-// prototype, and the nausea ones are the ones a refactor would quietly lose: the
-// clouds stand still, the sky stands still, the view does not follow a jump.
+// The cloud hop (task 1004578, from idea 1001205): a little game with one cloud per
+// PUBLIC project on the platform, played while a project is being set up. Since task
+// 1004683 (the design of record docs/design/mocks/day-night-rooms/setup-status.html) it
+// waits behind a "Play cloud hop while you wait" link and opens in place only when
+// asked: the wait never depends on it, and nothing on a timer stands in for a fact. The
+// owner set the game's rules on a played prototype, and the nausea ones are the ones a
+// refactor would quietly lose: the clouds stand still, the sky stands still, the view
+// does not follow a jump.
 //
-// EXECUTED by the vm-slice idiom: momentFor/setMoment ride the same region the DNS
-// test runs (renderProgress); the physics (hopStep), the score line (hopScore),
-// the status sync (hopSync) and the checklist's state line (stepsPaint) are sliced function by
-// function and run under narrow stubs. Every slice is asserted to exist, so a
-// rename fails loudly instead of testing nothing. vm-born values are compared as
-// primitives or through JSON.
+// EXECUTED by the vm-slice idiom: the link (hopOpen), the arrival (hopArrive), the
+// physics (hopStep) and the score line (hopScore) are sliced function by function and
+// run under narrow stubs. Every slice is asserted to exist, so a rename fails loudly
+// instead of testing nothing. vm-born values are compared as primitives or through JSON.
+// Part 03's facts themselves are tests/setup_status_facts.mjs.
 //
 // Run:  node --test tests/projects_hub_cloud_hop.mjs
-
 import { test } from 'node:test';
 import { strict as assert } from 'node:assert';
 import fs from 'node:fs';
@@ -47,69 +47,71 @@ const HOP_CONSTS = (SCRIPT.match(/\n {4}var HOP_GAP = [^\n]*\n/) || [''])[0];
 assert.ok(HOP_CONSTS.includes('HOP_JUMP'), 'the hop constants line must be findable');
 const HOP_REGION = between('/* ══ THE CLOUD HOP (task 1004578)', '/* ── the hub\'s three doors ── */');
 
-// ── the moment ──────────────────────────────────────────────────────────────────
-const PROGRESS = between('var PROG_FLOWS = {', 'function startProgress(');
-const OVERLAY = between('function verifiedAt(inst)', 'function chipMarkup(');
 
-function bootMoment() {
-  const attrs = {};
-  const panel = { setAttribute: (k, v) => { attrs[k] = v; } };
+// ── behind its link (task 1004683) ──────────────────────────────────────────────
+// The wait never depends on the game: it opens in place only when asked, and puts
+// itself away (after the curtain, if it was running) once every required fact is done.
+function bootLink({ reduced = false, running = false, since = 0 } = {}) {
+  const box = { hidden: true, classList: { remove() {}, add() {} } };
+  const link = { textContent: 'Play cloud hop while you wait', attrs: {}, setAttribute(k, v) { this.attrs[k] = v; } };
+  const calls = { start: 0, stop: 0, curtain: 0, raf: 0, done: null };
   const sandbox = {
-    $: (id) => (id === 'panel-done' ? panel : null),
-    esc: (s) => String(s), projectPageLink: (l) => l, relTime: () => 'now', canRestart: () => false,
-    FRESH_MS: 1, LIVE_MOMENT_MS: 1, state: {}, paintInviteGate() {}, lastProgHtml: '',
+    $: (id) => ({ hop: box, hopLink: link })[id] || null, REDUCED: reduced,
+    performance: { now: () => 10000 },
+    hopStart: () => { calls.start += 1; }, hopStop: () => { calls.stop += 1; },
+    hopCurtain: (done) => { calls.curtain += 1; calls.done = done; }, hopFrame() {},
+    requestAnimationFrame: () => { calls.raf += 1; return 1; }, cancelAnimationFrame() {},
   };
   vm.createContext(sandbox);
-  vm.runInContext(PROGRESS + '\n' + OVERLAY, sandbox);
-  return { sandbox, attrs };
+  vm.runInContext(`var hop = { target: '', raf: ${running ? 1 : 0}, since: ${since}, tr: 0 };\n${fn('hopOpen')}\n${fn('hopArrive')}`, sandbox);
+  return { sandbox, box, link, calls };
 }
-const NOW = () => new Date().toISOString();
-const live = { status: 'active', domain: 'mercury.cloudbongos.com', dns_resolves: true, last_verified_up: true, last_verified_at: NOW(), open_intent: null };
-
-test('the moment follows the same branches renderProgress speaks', () => {
-  const { sandbox } = bootMoment();
-  const m = (inst) => sandbox.momentFor(inst);
-  assert.equal(m({ status: 'requested' }), 'wait', 'filed: the hop');
-  assert.equal(m({ status: 'provisioning' }), 'wait', 'standing up: the hop');
-  assert.equal(m({ ...live, dns_resolves: false, last_verified_up: null }), 'wait', 'address still being set up: keep playing');
-  assert.equal(m({ ...live, last_verified_up: null }), 'wait', 'standing, not checked yet: keep playing');
-  assert.equal(m({ ...live, last_verified_up: false }), 'wait', 'not answering right now: keep playing');
-  assert.equal(m(live), 'arrive', 'answering on a resolved address: arrive');
-  assert.equal(m({ ...live, open_intent: { action: 'standup', state: 'running' } }), 'arrive',
-    'an intent renderProgress does not speak for (a running standup) falls through to the status');
-  assert.equal(m({ ...live, open_intent: { action: 'provision' } }), 'wait', 'a queued standup is still a wait');
-  assert.equal(m({ status: 'torn_down', open_intent: { action: 'provision' } }), 'wait', 'a queued revive is a wait');
-});
 
-test('a snag, an ending, a settings change or an addressless project keeps the plain panel', () => {
-  const { sandbox } = bootMoment();
-  const m = (inst) => sandbox.momentFor(inst);
-  assert.equal(m({ status: 'error' }), 'plain');
-  assert.equal(m({ status: 'tearing_down' }), 'plain');
-  assert.equal(m({ status: 'torn_down' }), 'plain');
-  assert.equal(m({ ...live, open_intent: { action: 'teardown' } }), 'plain');
-  assert.equal(m({ ...live, open_intent: { action: 'settings-apply', state: 'running' } }), 'plain');
-  assert.equal(m({ ...live, domain: null }), 'plain', 'no address will never answer — nothing to arrive at');
+test('the game opens in place only when asked, and its link says so', () => {
+  const h = bootLink();
+  h.sandbox.hopOpen(true);
+  assert.equal(h.box.hidden, false);
+  assert.equal(h.link.attrs['aria-expanded'], 'true');
+  assert.equal(h.sandbox.hop.target, 'wait', 'only an opened game may run (hopRunning reads it)');
+  assert.equal(h.calls.start, 1);
+  h.sandbox.hopOpen(false);
+  assert.equal(h.box.hidden, true);
+  assert.equal(h.link.attrs['aria-expanded'], 'false');
+  assert.equal(h.link.textContent, 'Play cloud hop while you wait');
+  assert.equal(h.sandbox.hop.target, '');
+  assert.equal(h.calls.stop, 1);
+  assert.match(HUB, /<button type="button" class="hopLink" id="hopLink" aria-expanded="false" aria-controls="hop">Play cloud hop while you wait<\/button>\s*<div class="hop" id="hop" hidden>/,
+    'baked shut, behind the mockup\'s link');
+  assert.match(SCRIPT, /\$\('hopLink'\)\.addEventListener\('click', function \(\) \{ hopOpen\(\$\('hop'\)\.hidden\); \}\);/, 'the link is the only way in');
+  assert.match(fn('hopStart'), /if \(!hop \|\| !hopEl \|\| hopEl\.hidden\) return;/, 'a closed game never starts, not on a resize nor a tab coming back');
 });
 
-test('renderProgress sets the moment before it writes the strip, and only for a real read', () => {
-  const { sandbox, attrs } = bootMoment();
-  const nodes = { liveProgress: { innerHTML: '', querySelector: () => null }, 'done-h': { textContent: '' }, doneLede: { innerHTML: '' } };
-  sandbox.$ = ((orig) => (id) => nodes[id] || orig(id))(sandbox.$);
-  sandbox.renderProgress({ status: 'provisioning' });
-  assert.equal(attrs['data-moment'], 'wait');
-  sandbox.renderProgress(live);
-  assert.equal(attrs['data-moment'], 'arrive');
-  const body = fn('renderProgress');
-  assert.ok(body.indexOf('setMoment(momentFor(inst))') < body.indexOf('setProgress('), 'the moment is decided first');
-  assert.match(body, /if \(inst\) setMoment\(momentFor\(inst\)\);/, 'a null read never moves the panel');
+test('every required fact done: a running game gets the curtain, then puts itself away; a closed one stays away', () => {
+  const run = bootLink({ running: true, since: 1000 });
+  run.box.hidden = false;
+  run.sandbox.hopArrive();
+  assert.equal(run.calls.curtain, 1, 'the curtain plays from a running game');
+  assert.equal(run.box.hidden, false, 'and the game stays until the curtain lands');
+  run.calls.done();
+  assert.equal(run.box.hidden, true, 'then it is put away');
+  const shut = bootLink();
+  shut.sandbox.hopArrive();
+  assert.equal(shut.calls.curtain, 0, 'a game nobody opened plays nothing');
+  assert.equal(shut.box.hidden, true);
+  const still = bootLink({ reduced: true, running: true, since: 1000 });
+  still.box.hidden = false;
+  still.sandbox.hopArrive();
+  assert.equal(still.calls.curtain, 0, 'reduced motion: no curtain');
+  assert.equal(still.box.hidden, true);
+  assert.match(fn('paintAlive'), /if \(on\) hopArrive\(\);/, 'the facts decide the arrival, never the game');
 });
 
-test('the panel leaves the hop on a stopped watch and starts on it at renderDone', () => {
-  const sp = between('function startProgress(', 'function resetForNewProject(');
-  assert.equal((sp.match(/setMoment\('plain'\);/g) || []).length, 2, 'the ~33-minute hand-off and a gone instance both drop to plain');
-  assert.match(fn('renderDone'), /setMoment\('wait'\);/, 'a fresh done panel opens on the hop');
+test('nothing on a timer stands in for a fact: no tick counter, no moment, no bar', () => {
+  assert.doesNotMatch(SCRIPT, /ticks > 400|ticks \+= 1/, 'the ~33-minute tick counter is gone');
+  assert.doesNotMatch(SCRIPT, /setMoment|momentFor|data-moment|hopMoment|hopSync/, 'no moment switch');
+  assert.doesNotMatch(HUB, /hopBar|id="hopStatus"/, 'no bar and no second status line');
   assert.match(fn('resetForNewProject'), /hopReset\(\);/, 'a second project starts with a fresh hop');
+  assert.match(fn('renderDone'), /hopOpen\(false\);/, 'a fresh part 03 opens with the game put away');
 });
 
 // ── the physics — the owner's rules ─────────────────────────────────────────────
@@ -199,7 +201,7 @@ test('the loop never runs under reduced motion; the rest frame is a full still s
     'the start, the frame (playing and curtain) and the curtain\'s kick-off — no other loop');
   assert.match(fn('hopFrame'), /if \(!hopRunning\(\)\) \{ hopDraw\(now\); return; \}/,
     'every frame re-asks the gate, so turning reduced motion on stops it');
-  assert.match(fn('hopMoment'), /!REDUCED && hop\.raf/, 'the curtain plays only from a running game');
+  assert.match(fn('hopArrive'), /!REDUCED && hop\.raf/, 'the curtain plays only from a running game');
   assert.match(STYLE, /\.hop\.isStill \.hopRow\{display:none;\}/, 'reduced motion has nothing to steer');
 });
 
@@ -213,67 +215,17 @@ test('the game reads its colours off the page tokens — no literal but white or
   assert.match(fn('hopColors'), /hopRead\('var\(--' \+ nm \+ '\)'\)/, 'every colour resolves from a token');
 });
 
-// ── the status line and the arrival pager ───────────────────────────────────────
-function el(cls = []) {
-  const set = new Set(cls);
-  const attrs = {};
-  return {
-    classList: { contains: (c) => set.has(c), toggle: (c, on) => (on ? set.add(c) : set.delete(c)), add: (c) => set.add(c), remove: (c) => set.delete(c) },
-    setAttribute: (k, v) => { attrs[k] = v; }, getAttribute: (k) => attrs[k], attrs, hidden: false, textContent: '', style: {},
-  };
-}
-
-test('the status line and the bar read what the strip says', () => {
-  const st = { textContent: '' }, fill = { style: {} };
-  const sandbox = { $: (id) => ({ hopStatus: st, hopBarFill: fill })[id] || null, Math };
-  vm.createContext(sandbox);
-  vm.runInContext(fn('hopSync'), sandbox);
-  const strip = {
-    querySelector: (q) => (q === '.pnote' ? { textContent: 'Raising the server, database, and address — nothing needed from you.' } : q === '.stages li.now' ? {} : null),
-    querySelectorAll: (q) => ({ length: q === '.stages li' ? 3 : 1 }),
-  };
-  sandbox.hopSync(strip);
-  assert.equal(st.textContent, 'Raising the server, database, and address — nothing needed from you.');
-  assert.equal(fill.style.width, '50%', 'one done and one under way of three');
-  assert.match(fn('setProgress'), /hopSync\(el\)/, 'every strip write syncs the line');
-});
-
-// ── part 03's checklist (task 1004648): every step on show, the state line from it ──
-function bootSteps(items, { step = 2, inFlight = false } = {}) {
-  const list = { children: items };
-  const ghState = { textContent: '' };
-  const sandbox = { $: (id) => ({ humanSteps: list, ghState })[id] || null, Array, state: { step }, manifestInFlight: () => inFlight };
-  vm.createContext(sandbox);
-  vm.runInContext(fn('stepsPaint'), sandbox);
-  sandbox.stepsPaint();
-  return ghState.textContent;
-}
-function li(key, cls = []) { const e = el(cls); e.key = key; return e; }
-
-test('part 03\'s state line reads the checklist: ready, how many done, waiting on GitHub, connected', () => {
-  assert.equal(bootSteps([li('github-repo'), li('oauth-app')], { step: 1 }), 'opens once your project exists', 'before Create');
-  assert.equal(bootSteps([li('github-repo'), li('oauth-app')]), 'ready');
-  assert.equal(bootSteps([li('github-repo', ['sdone']), li('oauth-app'), li('enter-hall', ['slocked'])]), '1 of 3 done');
-  assert.equal(bootSteps([li('github-repo', ['sdone']), li('oauth-app')], { inFlight: true }), 'waiting on GitHub…', 'a GitHub leg in flight says so');
-  assert.equal(bootSteps([li('github-repo', ['sdone']), li('oauth-app', ['sdone'])]), 'connected ✓');
-  assert.doesNotMatch(fn('stepsPaint'), /innerHTML|\.cur|data-n/, 'no paging, and no markup from strings');
-});
-
-// ── the markup and the sheet ────────────────────────────────────────────────────
-test('the wait stands the strip and the later lines down, the checklist stays on show, and nothing is paged', () => {
-  for (const id of ['hop', 'hopStatus', 'hopBarFill', 'hopCanvas', 'hopLeft', 'hopJump', 'hopRight', 'hopScore', 'humanSteps', 'ghState']) {
+// ── the markup ──────────────────────────────────────────────────────────────────
+test('the hop is baked into part 03 below the facts and above "is alive"; the old wait is gone', () => {
+  for (const id of ['hop', 'hopLink', 'hopCanvas', 'hopLeft', 'hopJump', 'hopRight', 'hopScore']) {
     assert.ok(HUB.includes(`id="${id}"`), `#${id} is baked into part 03`);
   }
-  for (const id of ['hopWhile', 'hopSignin', 'stepPager', 'stepCount', 'stepBack', 'stepNext']) {
-    assert.ok(!HUB.includes(`id="${id}"`), `#${id} is gone: the checklist is on show the whole time (task 1004648)`);
+  for (const id of ['hopWhile', 'hopSignin', 'stepPager', 'stepCount', 'stepBack', 'stepNext', 'hopStatus', 'hopBarFill', 'humanSteps', 'liveProgress']) {
+    assert.ok(!HUB.includes(`id="${id}"`), `#${id} is gone (tasks 1004648, 1004683)`);
   }
   const panel = HUB.slice(HUB.indexOf('id="panel-done"'), HUB.indexOf('</section>', HUB.indexOf('id="panel-done"')));
-  assert.ok(panel.indexOf('id="humanSteps"') < panel.indexOf('id="hop"') && panel.indexOf('id="hop"') < panel.indexOf('id="wizInvite"'),
-    'the checklist first, then the hop, then the invite');
-  assert.match(panel, /id="hopStatus" role="status" aria-live="polite"/, 'the line is the live region while the strip is hidden');
-  assert.match(STYLE, /#panel-done\[data-moment="wait"\] #liveProgress,/);
-  assert.doesNotMatch(STYLE, /#panel-done\[data-moment="wait"\][^{]*#humanSteps\{display:none;\}/, 'the wait no longer hides the checklist');
-  assert.doesNotMatch(STYLE, /humanSteps>li:not\(\.cur\)/, 'and the arrival does not page it');
-  assert.match(STYLE, /#panel-done\[data-moment="arrive"\] #liveProgress \.stages\{display:none;\}/, 'the arrival keeps the note with the address, not the dots');
-  assert.match(STYLE, /#panel-done \.humanSteps>li\.sdone::before\{content:"✓";/, 'a verified step wears the tick');
+  assert.ok(panel.indexOf('id="ghFacts"') < panel.indexOf('id="hopLink"') && panel.indexOf('id="hop"') < panel.indexOf('id="doneAlive"'),
+    'the facts first, then the game behind its link, then "is alive"');
+  assert.doesNotMatch(panel, /id="hopScore"[^>]*aria-live/, 'the score is not a live region: part 03 speaks through one');
+  assert.match(STYLE, /\.hop\[hidden\]\{display:none;\}/, 'the game stays out of the layout until asked');
 });