@bongos/core 1.21.104 → 1.21.106

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');
 });

package/tests/projects_hub_dns_ready.mjs

@@ -7,7 +7,7 @@
 // carries `dns_resolves` (the server's sighting — modules/provisioning/dns-resolves.js)
 // or a verified up probe. The status alone, 'active' included, is never enough.
 //
-// EXECUTED by the vm-slice idiom: the done panel's renderProgress, the card's
+// EXECUTED by the vm-slice idiom: part 03's Its home facts (homeFacts, task 1004683), the card's
 // addressRow and the row's orbFor are sliced verbatim out of projects.html and run
 // under a narrow stub, and the markup they write is read back. Every slice boundary is
 // asserted, so a rename fails loudly instead of testing nothing. vm-born values are
@@ -36,27 +36,23 @@ function slice(from, to) {
   return HUB.slice(a, b);
 }
 
-const PROGRESS = slice('var PROG_FLOWS = {', 'function startProgress(');
+// part 03's Its home (task 1004683): the three facts read off the owner's instance read
+function wizFn(name) {
+  const m = HUB.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 FACTS = ['hostOk', 'whenSaid', 'homeFacts'].map(wizFn).join('\n');
 const OVERLAY = slice('function verifiedAt(inst)', 'function chipMarkup(');
 const ADDRESS = slice('var ADDRESS_SETTING_UP', 'function publishRow(');
 const ORB = slice('function orbFor(', '/* ── progress strips');
-for (const [name, region] of [['renderProgress', PROGRESS], ['addressReady', OVERLAY], ['addressRow', ADDRESS], ['orbFor', ORB]]) {
+for (const [name, region] of [['homeFacts', FACTS], ['addressReady', OVERLAY], ['addressRow', ADDRESS], ['orbFor', ORB]]) {
   assert.ok(region.includes(`function ${name}(`), `the slice must carry ${name}`);
 }
 
 function boot() {
-  const liveProgress = { innerHTML: '' };
-  // the done panel's heading (task 1004504): "Setting up <name>" until the project answers
-  const doneH = { textContent: 'Setting up Lantern' };
-  // and the line under it (task 1004543): renderDone's "setting up" until the project answers
-  const SETTING_UP = 'We’re setting up <strong>Lantern</strong>: its server, database and address.';
-  const doneLede = { innerHTML: SETTING_UP };
-  // the invite step's gate (task 1004503): renderProgress opens it only on a verified answer
-  const gates = [];
   const sandbox = {
-    $: (id) => ({ liveProgress, 'done-h': doneH, doneLede })[id] || null,
-    state: { name: 'Lantern', slug: 'lantern' },
-    paintInviteGate: (live) => gates.push(live),
+    live: { readAt: Date.now() },
     esc: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => (
       { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
     projectPageLink: (label) => '<a href="?view=manage&id=1">' + label + '</a>',
@@ -66,54 +62,47 @@ function boot() {
     planetAttrs: () => '',
     FRESH_MS: 12 * 60 * 1000,
     LIVE_MOMENT_MS: 10 * 60 * 1000,
-    lastProgHtml: '',
   };
   vm.createContext(sandbox);
-  vm.runInContext(PROGRESS + '\n' + OVERLAY + '\n' + ADDRESS + '\n' + ORB, sandbox);
-  return { sandbox, progress: () => liveProgress.innerHTML, heading: () => doneH.textContent, lede: () => doneLede.innerHTML, SETTING_UP, gates };
+  vm.runInContext(OVERLAY + '\n' + ADDRESS + '\n' + ORB + '\n' + FACTS, sandbox);
+  // Its home as the founder sees it: each fact's state and every word it says
+  const home = (inst) => JSON.parse(JSON.stringify(sandbox.homeFacts(inst, Date.now())));
+  const words = (rows) => rows.map((r) => [r.title, [].concat(r.sub || []).map((p) => (typeof p === 'string' ? p : p.t)).join(''), r.right || ''].join(' ')).join('\n');
+  return { sandbox, home, words };
 }
 
 const NOW = () => new Date().toISOString();
-const base = { id: 1, slug: 'lantern', status: 'active', domain: 'lantern.cloudbongos.com', last_verified_at: null, last_verified_up: null, dns_note: null };
 const ADDRESS_LINK = /<a [^>]*href="https:\/\/lantern\.cloudbongos\.com/;
+const base = { id: 1, slug: 'lantern', status: 'active', domain: 'lantern.cloudbongos.com', created_at: NOW(), provisioned_at: NOW(), last_verified_at: null, last_verified_up: null, dns_note: null, open_intent: null };
 
-test('active but not yet resolved: the done panel holds the link, says so, and keeps watching', () => {
+test('active but not yet resolved: part 03 says the address is on its way, never names it, and keeps it a fact under way', () => {
   const h = boot();
-  const terminal = h.sandbox.renderProgress({ ...base, dns_resolves: false });
-  assert.equal(terminal, false, 'the panel keeps polling until the lookup answers');
-  assert.doesNotMatch(h.progress(), ADDRESS_LINK);
-  assert.doesNotMatch(h.progress(), /lantern\.cloudbongos\.com/, 'and does not even name it to be typed');
-  assert.match(h.progress(), /your address is being set up/);
+  const rows = h.home({ ...base, dns_resolves: false });
+  assert.deepEqual(rows.map((r) => r.state), ['done', 'done', 'now'], 'kept, running, not answering yet');
+  assert.equal(rows[2].sub, 'New addresses can take a few minutes to reach everyone.');
+  assert.doesNotMatch(h.words(rows), /lantern\.cloudbongos\.com/, 'a name typed before it resolves is cached as not found: not even named');
 });
 
-test('a down probe on a never-resolved address is still "being set up", never a link', () => {
+test('a down probe on a never-resolved address is still on its way, never named', () => {
   const h = boot();
-  h.sandbox.renderProgress({ ...base, dns_resolves: false, last_verified_up: false, last_verified_at: NOW() });
-  assert.doesNotMatch(h.progress(), ADDRESS_LINK);
-  assert.match(h.progress(), /being set up/);
+  const rows = h.home({ ...base, dns_resolves: false, last_verified_up: false, last_verified_at: NOW() });
+  assert.equal(rows[2].state, 'now');
+  assert.doesNotMatch(h.words(rows), /lantern\.cloudbongos\.com/);
 });
 
-test('once the lookup answers, the done panel links the address', () => {
+test('once the lookup answers, part 03 names the address; only a verified answer ticks "Address answers"', () => {
   const h = boot();
-  const terminal = h.sandbox.renderProgress({ ...base, dns_resolves: true });
-  assert.equal(terminal, false, 'resolving is not yet answering — the panel still waits for the probe');
-  assert.match(h.progress(), ADDRESS_LINK);
-  assert.equal(h.heading(), 'Setting up Lantern', 'and the heading claims nothing yet (task 1004504)');
-  assert.deepEqual(h.gates, [], 'and the invite box stays shut: the hall has not answered (task 1004503)');
-  assert.equal(h.lede(), h.SETTING_UP, 'and the line under it still says it is being set up (task 1004543)');
-  const live = boot();
-  assert.equal(live.sandbox.renderProgress({ ...base, dns_resolves: true, last_verified_up: true, last_verified_at: NOW() }), true);
-  assert.match(live.progress(), ADDRESS_LINK);
-  assert.equal(live.heading(), 'Lantern is alive.', 'the alive moment, only on a verified answer');
-  assert.deepEqual(live.gates, [true], 'and the invite box opens with it (task 1004503)');
-  assert.match(live.lede(), /^Its home is ready\. Watch the rest here, or any time on <a href="\?view=mine">your projects page<\/a>\.$/,
-    'and the line under it stops saying "setting up" (task 1004543)');
-  assert.doesNotMatch(live.lede(), /setting up/i);
-  const down = boot();
-  down.sandbox.renderProgress({ ...base, dns_resolves: true, last_verified_up: false, last_verified_at: NOW() });
-  assert.equal(down.heading(), 'Setting up Lantern', 'a down probe is never "alive"');
-  assert.deepEqual(down.gates, [], 'nor opens the invite box');
-  assert.equal(down.lede(), down.SETTING_UP, 'nor says its home is ready');
+  const resolved = h.home({ ...base, dns_resolves: true });
+  assert.equal(resolved[0].sub, 'lantern.cloudbongos.com', 'named once it resolves');
+  assert.equal(resolved[2].state, 'now', 'resolving is not yet answering');
+  assert.equal(resolved[2].sub, 'Checking that it answers.');
+  const up = h.home({ ...base, dns_resolves: true, last_verified_up: true, last_verified_at: NOW() });
+  assert.equal(up[2].state, 'done');
+  assert.match(up[2].right, /^checked \d+s ago$/, 'when the platform last saw it answer');
+  const down = h.home({ ...base, dns_resolves: true, last_verified_up: false, last_verified_at: NOW() });
+  assert.equal(down[2].state, 'now', 'a down probe is never "answers"');
+  // "is alive" and the Enter Genesis door ask the same two gates
+  assert.match(wizFn('paintAlive'), /var on = !!\(ready && inst && hostOk\(inst\.domain\) && addressReady\(inst\) && inst\.last_verified_up === true\);/);
 });
 
 test('the card and the manage page: no link and no name before the lookup answers, in every pre-live state', () => {
@@ -165,9 +154,11 @@ test('every door to the address on the page asks addressReady', () => {
   const SCRIPT = HUB;
   assert.match(SCRIPT, /inst\.status === 'active' && addressReady\(inst\)\) acts\.push\('<a class="btn small ghost" href="https:\/\/' \+ esc\(inst\.domain\) \+ '" target="_blank" rel="noopener">View<\/a>'\)/, 'the row\'s View');
   assert.match(SCRIPT, /inst\.status === 'active' && addressReady\(inst\)\) acts\.push\('<a class="btn small ghost" href="https:\/\/' \+ esc\(inst\.domain\) \+ '" target="_blank" rel="noopener">Open site →<\/a>'\)/, 'the manage page\'s Open site');
-  // task 1004649: "Builders can sign in" opens its door only on a resolving address
-  assert.match(SCRIPT, /var open = live\.instStatus === 'active' && live\.addrReady;\n\s*return '<li class="sdone" data-onboard-step="first-sign-in">/, 'the sign-in step\'s door waits for the address');
-  assert.match(SCRIPT, /live\.addrReady = addressReady\(inst\); renderSteps\(\);/, 'and unlock on the tick the lookup answers');
+  // part 03 (task 1004683): "Builders can sign in" names the address only once it resolves,
+  // and the Enter Genesis door opens only on a resolved, answering address
+  assert.match(SCRIPT, /signIn\.sub = dom && live\.addrReady \? 'Tested on ' \+ dom : '';/, 'the sign-in fact waits for the address');
+  assert.match(SCRIPT, /if \(inst\) \{ live\.instStatus = inst\.status; live\.addrReady = addressReady\(inst\); \}\n\s*paintFacts\(\);/, 'and the read redraws the facts on the tick the lookup answers');
+  assert.match(SCRIPT, /if \(on\) \$\('enterGenesis'\)\.setAttribute\('href', 'https:\/\/' \+ inst\.domain\);/, 'the Genesis door, behind paintAlive\'s gate');
   assert.equal((SCRIPT.match(/inst\.status !== 'active' \|\| !addressReady\(inst\)\) \{ (vis|join)Runs\(''\); return; \}/g) || []).length, 2,
     'the browser\'s own manifest reads wait for the name too');
   // the only raw address hrefs left are behind one of those gates