@bongos/core 1.21.71 → 1.21.72

package/modules/public-landing/public/projects.probes.json

@@ -167,9 +167,9 @@
     { "name": "the review (tasks 1004504, 1004550): Edit opens a row in place, Done confirms it, and Continue is the one confirmation for the rest", "auth": true, "width": 1440, "url": "/projects?view=new",
       "steps": [["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"team\"] [data-row-chg]"],["wait",200],["click","[data-phys-solo=\"many\"]"],["wait",600],["click","#reviewRows .setRow[data-row=\"team\"] [data-row-chg]"],["wait",200]],
       "expect": {"visible":["#panel-review","#reviewRows .setRow[data-row=\"rewards\"]","#reviewRows .setRow.done[data-row=\"team\"]"]} },
-    { "name": "the wizard driver (tasks 1003346 and 1004504): the fork, what, the checks, every review row confirmed (the stub grants repo access, so the new repository is named from the project; the dotless stub host takes a domain the founder owns), the look, then the filing — the done panel with the standup strip and the human steps", "auth": true, "width": 1440, "url": "/projects?view=new",
+    { "name": "the wizard driver (tasks 1003346 and 1004504): the fork, what, the checks, every review row confirmed (the stub grants repo access, so the new repository is named from the project; the dotless stub host takes a domain the founder owns), the look, then the filing — the done panel waits with the cloud hop and its status line (task 1004578), the strip and the locked checklist standing down", "auth": true, "width": 1440, "url": "/projects?view=new",
       "steps": [["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500]],
-      "expect": {"visible":["#panel-done","#liveProgress .prog","#liveProgress .prog .stages li.now","#humanSteps li"],"hidden":["#panel-look","#panel-review"],"text":[["#done-h","Setting up Mercury"]]} },
+      "expect": {"visible":["#panel-done","#hop","#hopCanvas","#hopStatus","#hopJump"],"hidden":["#panel-look","#panel-review","#liveProgress","#humanSteps"],"text":[["#done-h","Setting up Mercury"],["#hopStatus","Raising the server, database, and address — nothing needed from you."]]} },
     { "name": "the front door at 390: the fork's two doors stack inside one pill", "auth": true, "width": 390, "url": "/projects?view=new",
       "steps": [["wait",600],["click","#termsAck"],["wait",100]],
       "expect": {"visible":["#panel-fork",".doorPill","#wizDemo","#wizStart"]} },

package/modules/public-landing/public/projects.states.json

@@ -57,7 +57,7 @@
     "in-new-review-run": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"run\"] [data-row-chg]"],["wait",300],["click","[data-phys=\"framing\"][data-val=\"hybrid\"]"],["wait",600]],"expect":{"visible":["#physSuite"]}},
     "in-new-review-confirmed": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200]],"expect":{"visible":["#reviewGo","#reviewRows .setRow.done"],"text":[["#reviewGo","Looks right, continue"]]}},
     "in-new-look": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500]],"expect":{"visible":["#panel-look","#wizLook","#wizRecap","#doCreate"],"hidden":["#panel-review"],"attr":[["#wizRoom","data-screen","look"]]}},
-    "in-new-done": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500]],"expect":{"visible":["#panel-done","#liveProgress .prog","#humanSteps li","#wizInviteLater"],"hidden":["#panel-look","#qWrap","#wizBack","#wizInvite"]}},
+    "in-new-done": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500]],"expect":{"visible":["#panel-done","#hop","#hopCanvas","#hopStatus","#hopJump"],"hidden":["#panel-look","#qWrap","#wizBack","#wizInvite","#liveProgress","#humanSteps","#wizInviteLater","#stepPager"]}},
     "in-new-resume-offer": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500],["click","#projTrig"],["wait",350],["click","#menuProjects [data-nav=\"new\"]"],["wait",500]],"expect":{"visible":["#panel-fork","#wizResume","#wizResumeGo"],"hidden":["#panel-done"],"text":[["#wizResumeName","Mercury"]]}},
     "in-new-look-custom": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#wizLook-custom"],["wait",200]],"expect":{"visible":["#panel-look","#wizAccent","#wizAccentNote"],"hidden":["#panel-review"]}},
     "out-new": {"auth":false,"url":"/projects?view=new","expect":{"visible":["#panel-gate","#wizSignin"],"hidden":["#qWrap","#panel-fork"]}},

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.71",
+  "version": "1.21.72",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.71",
+      "version": "1.21.72",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.71",
+  "version": "1.21.72",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -9236,5 +9236,11 @@
     {
       "text": "Hosted projects like Will's now get a working Update button in Settings, instead of being told to run a command on a server they don't have access to."
     }
+  ],
+  "1.21.72": [
+    {
+      "id": "1004578",
+      "text": "While a new project is being set up, founders now get a little cloud-hopping game: each cloud is a public project on the platform, in its own planet colour. When the project goes live, clouds and stars fill the screen and fade"
+    }
   ]
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.71'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.72'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/projects_hub_cloud_hop.mjs

@@ -0,0 +1,303 @@
+// 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, one at a time. 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 pager (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.
+//
+// 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';
+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 LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const SCRIPT = HUB.slice(HUB.lastIndexOf('<script>'), HUB.lastIndexOf('</script>'));
+const STYLE = HUB.slice(HUB.indexOf('<style>'), HUB.indexOf('</style>'));
+const J = (v) => JSON.parse(JSON.stringify(v));
+
+function between(from, to) {
+  const a = SCRIPT.indexOf(from);
+  const b = SCRIPT.indexOf(to, a + 1);
+  assert.ok(a > 0, `slice start must exist: ${from}`);
+  assert.ok(b > a, `slice end must follow it: ${to}`);
+  return SCRIPT.slice(a, b);
+}
+// one wizard-scope function, closed on the first `}` at the wizard's four-space indent
+function fn(name) {
+  const m = SCRIPT.match(new RegExp(`\\n {4}function ${name}\\([^)]*\\) \\{[\\s\\S]*?\\n {4}\\}`));
+  assert.ok(m, `function ${name}() must be findable in projects.html`);
+  return m[0];
+}
+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; } };
+  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: '',
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(PROGRESS + '\n' + OVERLAY, sandbox);
+  return { sandbox, attrs };
+}
+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('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('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');
+  assert.match(fn('resetForNewProject'), /hopReset\(\);/, 'a second project starts with a fresh hop');
+});
+
+// ── the physics — the owner's rules ─────────────────────────────────────────────
+function bootHop({ clouds = 3, reduced = false } = {}) {
+  const score = { textContent: '' };
+  const sandbox = { $: (id) => (id === 'hopScore' ? score : null), REDUCED: reduced, Math };
+  vm.createContext(sandbox);
+  vm.runInContext(HOP_CONSTS + 'var hop = { w: 600, feed: [], clouds: [], best: 0, maxed: false, p: null, cam: 0, camT: 0, L: false, R: false };\n' +
+    fn('hopCloudX') + fn('hopCloudW') + fn('hopScore') + fn('hopStep'), sandbox);
+  const hop = sandbox.hop;
+  hop.clouds.push({ i: 0, base: true, y: 0 });
+  // one fixed column of clouds straight up the middle, so a plain jump lands
+  for (let i = 1; i <= clouds; i++) hop.clouds.push({ i, f: 0.5, cw: 100, y: -i * sandbox.HOP_GAP, name: 'P' + i, acc: 'sea' });
+  hop.p = { x: 300, y: -14, vy: 0, on: hop.clouds[0], face: 1 };
+  hop.cam = hop.camT = -340 * 0.8;
+  return { sandbox, hop, score };
+}
+function run(sb, frames) { for (let i = 0; i < frames; i++) sb.hopStep(1); }
+
+test('a jump lands on the cloud above and the best height counts it', () => {
+  const { sandbox, hop, score } = bootHop();
+  const before = J(hop.clouds.map((c) => [c.f, c.y]));
+  hop.p.vy = -sandbox.HOP_JUMP; hop.p.on = null;
+  run(sandbox, 80);
+  assert.equal(hop.p.on && hop.p.on.i, 1, 'landed on the first project cloud');
+  assert.equal(hop.best, 1);
+  assert.equal(score.textContent, 'Best: 1 of 3 projects');
+  assert.deepEqual(J(hop.clouds.map((c) => [c.f, c.y])), before, 'the clouds never move — moving clouds read as nausea');
+});
+
+test('the view holds still during a jump and glides only after the landing', () => {
+  const { sandbox, hop } = bootHop();
+  const cam0 = hop.cam;
+  hop.p.vy = -sandbox.HOP_JUMP; hop.p.on = null;
+  let airborneMoved = false;
+  for (let i = 0; i < 80 && !hop.p.on; i++) { sandbox.hopStep(1); if (!hop.p.on && Math.abs(hop.cam - cam0) > 0.01) airborneMoved = true; }
+  assert.equal(airborneMoved, false, 'no camera motion while the player is in the air');
+  assert.ok(hop.p.on, 'and it did land');
+  run(sandbox, 60);
+  assert.ok(hop.cam < cam0 - 10, 'once landed higher, the view glides up');
+});
+
+test('a miss falls, and the full-width base cloud always catches', () => {
+  const { sandbox, hop } = bootHop();
+  hop.p.on = hop.clouds[2]; hop.p.y = hop.clouds[2].y - 14; hop.best = 2;
+  hop.p.x = 600 - 10;   // walk off the right edge of a centred cloud
+  run(sandbox, 200);
+  assert.equal(hop.p.on && hop.p.on.base, true, 'it fell past the lower clouds and landed on Your planet');
+  assert.equal(hop.best, 2, 'falling never takes the best height away');
+});
+
+test('steering moves the player, held to the stage', () => {
+  const { sandbox, hop } = bootHop();
+  hop.R = true; run(sandbox, 500);
+  assert.equal(hop.p.x, 590, 'right stops 10px from the edge');
+  hop.R = false; hop.L = true; run(sandbox, 500);
+  assert.equal(hop.p.x, 10, 'and left at 10px');
+});
+
+test('past the last cloud: max projects reached, build more to jump more', () => {
+  const { sandbox, hop, score } = bootHop({ clouds: 1 });
+  hop.p.vy = -sandbox.HOP_JUMP; hop.p.on = null;
+  run(sandbox, 80);
+  assert.equal(hop.maxed, true);
+  assert.equal(score.textContent, 'Max projects reached — build more to jump more');
+  const jump = fn('hopJump');
+  assert.match(jump, /!hop\.maxed/, 'and the jumping stops');
+  assert.match(HOP_REGION, /'Max projects reached'/);
+  assert.match(HOP_REGION, /'Build more to jump more'/);
+});
+
+test('the clouds are the public planets only, in the map\'s colours', () => {
+  const feed = fn('hopLoadFeed');
+  assert.match(feed, /p\.orb === 'planet'/, 'never a private star or a stealth black hole');
+  assert.match(feed, /localeCompare\(String\(b\.origin\)\)/, 'the accent walk runs over the origin-sorted catalog, like assignAccents');
+  assert.match(feed, /ORB_ACCENT_NAMES\.indexOf\(p\.planet_accent\) !== -1 \? p\.planet_accent/, 'the owner\'s pick wins');
+  assert.match(fn('hopBuild'), /hop\.clouds\.length === 1/, 'no public project at all reads as max reached');
+});
+
+// ── motion and the world ────────────────────────────────────────────────────────
+test('the loop never runs under reduced motion; the rest frame is a full still sky', () => {
+  assert.match(fn('hopRunning'), /return !REDUCED && !document\.hidden && hop\.target === 'wait'/, 'the gate, like the map\'s skyActive (C9)');
+  const start = fn('hopStart');
+  assert.ok(start.indexOf('hopRunning()') < start.indexOf('requestAnimationFrame'), 'nothing is scheduled before the gate');
+  assert.match(start, /hopDraw\(performance\.now\(\)\)/, 'a stopped hop draws its still frame');
+  assert.equal((HOP_REGION.match(/requestAnimationFrame\(/g) || []).length, 4,
+    '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(STYLE, /\.hop\.isStill \.hopRow\{display:none;\}/, 'reduced motion has nothing to steer');
+});
+
+test('the game reads its colours off the page tokens — no literal but white or black with alpha', () => {
+  const hexes = HOP_REGION.match(/#[0-9a-fA-F]{3,8}\b/g) || [];
+  assert.deepEqual(hexes, [], 'no hex in the hop');
+  // hopCss() is the builder ('rgba(' + a token's channels), not a colour
+  const literals = (HOP_REGION.match(/'rgba?\([^']*'/g) || []).filter((m) => m !== "'rgba('");
+  for (const m of literals) assert.match(m, /^'rgba\(0,0,0,/, `only a black scrim may be literal: ${m}`);
+  assert.match(HOP_REGION, /var HOP_WHITE = \[255, 255, 255\];/, 'white is the one other literal');
+  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');
+});
+
+function bootSteps(items, signin) {
+  const list = { children: items, querySelector: (q) => items.find((li) => q.includes(li.key) || (q === 'li.cur' && li.classList.contains('cur'))) || null };
+  const panel = el(signin ? ['hopSignin'] : []);
+  const nodes = { 'panel-done': panel, humanSteps: list, hopWhile: el(), stepCount: el(), stepBack: el(), stepNext: el() };
+  const sandbox = { $: (id) => nodes[id] || null, Math, Array };
+  vm.createContext(sandbox);
+  vm.runInContext('var stepIdx = -1, stepAuto = true;' + fn('stepsPaint') + fn('stepGo'), sandbox);
+  return { sandbox, nodes };
+}
+function li(key, cls = []) { const e = el(cls); e.key = key; e.focus = () => {}; return e; }
+
+test('the arrival shows one step at a time, opening on the first not yet done', () => {
+  const items = [li('github-repo', ['sdone']), li('oauth-app'), li('device-flow', ['slocked']), li('enter-hall', ['slocked'])];
+  const { sandbox, nodes } = bootSteps(items);
+  sandbox.stepsPaint(true);
+  assert.deepEqual(items.map((i) => i.classList.contains('cur')), [false, true, false, false]);
+  assert.equal(nodes.stepCount.textContent, 'Step 2 of 4');
+  assert.equal(items[1].attrs['data-n'], '02', 'the step on show carries its own number — a hidden step never counts');
+  assert.equal(nodes.stepBack.hidden, false);
+  assert.equal(nodes.stepNext.hidden, false);
+  // the checklist ticks itself: the step on show finishing moves the founder on
+  items[1].classList.add('sdone');
+  sandbox.stepsPaint();
+  assert.equal(nodes.stepCount.textContent, 'Step 3 of 4');
+  // once they page for themselves, their choice holds
+  sandbox.stepGo(-1);
+  items[2].classList.add('sdone');
+  sandbox.stepsPaint();
+  assert.equal(nodes.stepCount.textContent, 'Step 2 of 4');
+  sandbox.stepGo(1); sandbox.stepGo(1);
+  assert.equal(nodes.stepNext.hidden, true, 'no Continue past the last step');
+});
+
+test('while waiting, the sign-in step is offered only when it can be done', () => {
+  const open = bootSteps([li('github-repo'), li('oauth-app')]);
+  open.sandbox.stepsPaint();
+  assert.equal(open.nodes.hopWhile.hidden, false, 'a domain and a public platform: offer it');
+  const locked = bootSteps([li('github-repo'), li('oauth-app', ['slocked'])]);
+  locked.sandbox.stepsPaint();
+  assert.equal(locked.nodes.hopWhile.hidden, true, 'locked: nothing to offer');
+  const done = bootSteps([li('github-repo'), li('oauth-app', ['sdone'])]);
+  done.sandbox.stepsPaint();
+  assert.equal(done.nodes.hopWhile.hidden, true, 'already wired: nothing to offer');
+  const opened = bootSteps([li('github-repo'), li('oauth-app', ['sdone'])], true);
+  opened.sandbox.stepsPaint();
+  assert.equal(opened.nodes.hopWhile.hidden, false, 'but an open one keeps its door so it can be closed');
+});
+
+// ── the markup and the sheet ────────────────────────────────────────────────────
+test('the wait stands the strip, the locked checklist and the later lines down; the arrival pages', () => {
+  for (const id of ['hop', 'hopStatus', 'hopBarFill', 'hopCanvas', 'hopLeft', 'hopJump', 'hopRight', 'hopScore', 'hopWhile', 'hopSignin', 'stepPager', 'stepCount', 'stepBack', 'stepNext']) {
+    assert.ok(HUB.includes(`id="${id}"`), `#${id} is baked into the panel`);
+  }
+  const panel = HUB.slice(HUB.indexOf('id="panel-done"'), HUB.indexOf('</section>', HUB.indexOf('id="panel-done"')));
+  assert.ok(panel.indexOf('id="liveProgress"') < panel.indexOf('id="hop"') && panel.indexOf('id="hop"') < panel.indexOf('id="wizInvite"'),
+    'the hop sits where the strip was, above 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.match(STYLE, /#panel-done\[data-moment="wait"\]:not\(\.hopSignin\) #humanSteps\{display:none;\}/);
+  assert.match(STYLE, /#panel-done\[data-moment="arrive"\] \.humanSteps>li:not\(\.cur\)\{display:none;\}/);
+  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, /@media \(prefers-reduced-motion:no-preference\)\{\n {2}#panel-done\[data-moment="arrive"\] \.humanSteps>li\.cur,/, 'the arrival\'s fade-in is motion-gated');
+});