@bongos/core 1.21.91 → 1.21.92

package/tests/wizard_front_door.mjs

@@ -1,21 +1,16 @@
-// tests/wizard_front_door.mjs — the create wizard's front door (task 1004417, BV2.PS05;
-// goal 1000121, docs/design/project-startup-direction.md "Front door").
+// tests/wizard_front_door.mjs — the create page's front door (task 1004417, BV2.PS05; reshaped
+// by task 1004648, the one-page flow — docs/design/project-startup-direction.md "One-page flow").
 //
-// Since the six blended screens (task 1004504, the design of record
-// docs/design/mocks/combined-onboarding/) the front door is ONE screen:
-//   1 · fork — "You’re about to start a digital planet.": the terms as its one tick, recorded
-//       on the project against the terms version the SERVER stamps
-//       (tests/provisioning_terms_ack.mjs holds that half), and the world's door pill, two
-//       equal doors, try the demo / start my project, both waiting for the tick. The demo is
-//       its own route (BV2.PS09). The separate terms screen is gone.
-// The wizard carries no progress rail: an eyebrow names the screen, one Back walks back, and
-// the night room (#wizRoom) stands behind every screen in place of the planet and bongo pair.
-// Sign-in stays where it was: the gate (step 0) comes first.
+// Sign-in stays the gate in front (step 0). After it there is ONE page (step 1) and, once the
+// project exists, the same page with part 03 live (step 2). The fork screen and its two doors are
+// gone: the demo is a small link under the heading, and the terms are one required tick above
+// Create, recorded on the project against the terms version the SERVER stamps
+// (tests/provisioning_terms_ack.mjs holds that half).
 //
 // Most of this RUNS the page's own script, the vm-slice idiom of tests/wizard_draft_resume.mjs:
-// validateStep(), the front door's wiring, and show()'s screen bookkeeping are sliced out of the
-// inline script and executed under a minimal DOM stub. Every slice boundary is asserted, so a
-// rename fails loudly instead of leaving this file quietly testing nothing.
+// the tick's wiring and show()'s bookkeeping are sliced out of the inline script and executed
+// under a minimal DOM stub. Every slice boundary is asserted, so a rename fails loudly instead of
+// leaving this file quietly testing nothing.
 //
 // projects.html is CRLF on a Windows checkout; this file normalises at read time.
 //
@@ -32,238 +27,97 @@ 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 panel = (id) => (HUB.match(new RegExp(`<section class="panel[^"]*" id="${id}"[\\s\\S]*?\\n {10}</section>`)) || [''])[0];
-const FORK = panel('panel-fork');
 const VIEW_NEW = (HUB.match(/<section id="view-new" hidden>[\s\S]*?\n<\/section>/) || [''])[0];
+const PAGE = (VIEW_NEW.match(/<section class="panel on" id="panel-page"[\s\S]*?\n {10}<\/section>/) || [''])[0];
 const MAP = {};
-for (const m of ((SCRIPT.match(/var panels = \{([^}]*)\}/) || [, ''])[1]).matchAll(/(\d+):\s*'([a-z-]+)'/g)) MAP[m[2]] = Number(m[1]);
+for (const m of ((SCRIPT.match(/var panels = \{([^}]*)\}/) || [, ''])[1]).matchAll(/(\d+):\s*'([a-z-]+)'/g)) MAP[Number(m[1])] = m[2];
 
 // ── the order ───────────────────────────────────────────────────────────────────
-test('the front door stands between sign-in and the first question: gate 0, fork 1, what 2', () => {
-  assert.equal(MAP['panel-gate'], 0, 'sign-in stays where it is today, first');
-  assert.equal(MAP['panel-fork'], 1, 'the fork, with the terms as its tick, is the first screen after sign-in');
-  assert.equal(MAP['panel-what'], 2, 'the real-project door goes on to "What are you making?"');
-  assert.equal(MAP['panel-checks'], 3, 'then the quick checks (task 1004504)');
-  assert.equal(MAP['panel-terms'], undefined, 'the separate terms screen is gone — the tick lives on the fork');
-  assert.doesNotMatch(HUB, /id="panel-terms"/, 'and no markup is left for it');
-  assert.ok(HUB.indexOf('id="panel-gate"') < HUB.indexOf('id="panel-fork"')
-    && HUB.indexOf('id="panel-fork"') < HUB.indexOf('id="panel-what"')
-    && HUB.indexOf('id="panel-what"') < HUB.indexOf('id="panel-checks"'), 'the markup reads in the same order');
-  assert.match(FORK, /<form data-next="2">/, 'the fork\'s primary door goes on to the first question');
-  assert.ok(VIEW_NEW, 'the ?view=new section is findable');
-  assert.doesNotMatch(VIEW_NEW, /data-back=/, 'no per-panel Back buttons — one #wizBack walks the screens');
-  assert.equal((VIEW_NEW.match(/id="wizBack"/g) || []).length, 1, 'one Back, in the wizard\'s top row');
-});
-
-test('the numbered rail is gone (task 1004504) — no steps list, no painter, no rule hiding it', () => {
-  const beats = [...HUB.matchAll(/<li[^>]*data-step="(\d+)"/g)].map((m) => Number(m[1]));
-  assert.deepEqual(beats, [], 'no rail beat is left anywhere on the page');
-  assert.doesNotMatch(HUB, /class="steps"/, 'no <ol class="steps"> in the wizard');
-  assert.doesNotMatch(SCRIPT, /paintRail\(/, 'no rail painter, and no call to one');
-  assert.doesNotMatch(STYLE, /\.wizFront \.steps|#view-new \.steps/, 'no rule left styling or hiding a rail');
+test('sign-in stays the gate in front; then the page, which carries the static `on` for a no-script visitor', () => {
+  assert.deepEqual(MAP, { 0: 'panel-gate', 1: 'panel-page', 2: 'panel-page' });
+  assert.ok(VIEW_NEW.indexOf('id="panel-gate"') < VIEW_NEW.indexOf('id="panel-page"'), 'the markup reads in the same order');
+  assert.ok(PAGE, '#panel-page ships as real markup (C7)');
+  assert.doesNotMatch(VIEW_NEW, /id="panel-terms"|id="panel-fork"|id="wizStart"|id="wizBack"/, 'no terms screen, no fork, no doors, no Back');
+  assert.doesNotMatch(HUB, /<li[^>]*data-step="\d+"|class="steps"/, 'and no progress rail');
 });
 
-// ── screen 1 · the fork, with the terms as its one tick ─────────────────────────
-test('screen 1 is the fork: one short lede, one tick that links the terms, one submit door', () => {
-  assert.ok(FORK, '#panel-fork ships as real markup (C7)');
-  assert.match(FORK, /^<section class="panel on" id="panel-fork"/, 'it carries the static `on` — step 1 for a no-script visitor');
-  assert.match(FORK, /<h1 id="fork-h">You’re about to start a digital planet\.<\/h1>/);
-  assert.equal((FORK.match(/<div id="forkIntro">[\s\S]*?<\/form>/)?.[0].match(/<p class="lede">/g) || []).length, 1, 'one short lede paragraph');
-  assert.match(FORK, /<input type="checkbox" id="termsAck" aria-describedby="h-terms">/, 'one checkbox, named by its hint');
-  assert.match(FORK, /<label class="termsAck">\s*<input[^>]*>\s*<span>I can sign for this project, and I accept the <a class="termsRead" href="\/terms" target="_blank" rel="noopener">terms<\/a>\.<\/span>/,
-    'the whole row is its label, so the target is the sentence, not a 20px box — and the terms are the platform\'s own /terms, in a new tab so the draft is not left behind');
-  assert.equal((FORK.match(/type="submit"/g) || []).length, 1, 'one primary door');
-  assert.doesNotMatch(FORK, /\bBongos\b/, 'no product name baked where a child instance would ship it');
+// ── the tick ────────────────────────────────────────────────────────────────────
+test('the terms are one tick above Create: the whole row is the label, and the terms open in a new tab', () => {
+  assert.match(PAGE, /<input type="checkbox" id="termsAck" aria-describedby="h-terms">/, 'one checkbox, named by its hint');
+  assert.match(PAGE, /<label class="termsAck">\s*<input[^>]*>\s*<span>I can sign for this project, and I accept the <a class="termsRead" href="\/terms" target="_blank" rel="noopener">terms<\/a>\.<\/span>/,
+    'the target is the sentence, not an 18px box — and the platform\'s own /terms, in a new tab so the draft is not left behind');
+  assert.ok(PAGE.indexOf('id="termsAck"') < PAGE.indexOf('id="doCreate"'), 'the tick sits above Create');
+  assert.ok(PAGE.indexOf('id="part-run"') < PAGE.indexOf('id="termsAck"'), 'and below the summary');
+  assert.equal((HUB.match(/id="termsAck"/g) || []).length, 1);
 });
 
 test('the page never names a terms version — the server stamps which text was acknowledged', () => {
-  // A version baked here would be a second copy of TERMS_VERSION that drifts, and worse, a
-  // value a caller could send. The create request carries only the tick.
   assert.doesNotMatch(HUB, /terms_version|termsVersion|terms_ack_version/, 'no version travels from the page');
-  assert.doesNotMatch(FORK, /\b20\d\d-\d\d-\d\d\b/, 'and none is printed on the screen');
+  assert.doesNotMatch(PAGE, /\b20\d\d-\d\d-\d\d\b/, 'and none is printed on the screen');
 });
 
-test('the resume offer lives on step 1 — the fork, once', () => {
+test('the resume offer lives at the top of the page, once', () => {
   assert.equal((HUB.match(/id="wizResume"/g) || []).length, 1);
-  assert.ok(FORK.includes('id="wizResume"'), 'a deliberate "New project" lands here, so the offer does too');
-});
-
-// ── the validator, executed ────────────────────────────────────────────────────
-const VALIDATE_RE = /function validateStep\(step\) \{[\s\S]*?\n {4}\}/;
-const validateSlice = (SCRIPT.match(VALIDATE_RE) || [null])[0];
-
-function runValidate(step, termsAck, extra = {}) {
-  const els = {};
-  const $ = (id) => (els[id] = els[id] || { textContent: '', className: '', classList: { add() {} }, focus() {} });
-  const sandbox = { $, state: { termsAck, name: 'Mercury', projType: 'game', demo: null, confirmed: {}, ...extra }, validateRender: () => true, repoAccess: true };
-  sandbox.globalThis = sandbox;
-  vm.createContext(sandbox);
-  vm.runInContext(`${validateSlice}\nvar ok = validateStep(${step});`, sandbox);
-  return { ok: sandbox.ok, hint: els['h-terms'], state: sandbox.state };
-}
-
-test('validateStep is still findable, with the terms clause inside it', () => {
-  assert.ok(validateSlice, 'validateStep() was not found in projects.html');
-  assert.match(validateSlice, /if \(step === 1\) \{\s*if \(!state\.termsAck\)/, 'the clause is part of the slice');
-});
-
-test('Start my project is refused until the box is ticked, and the refusal says why in the hint', () => {
-  const refused = runValidate(1, false);
-  assert.equal(refused.ok, false, 'no tick, no way past the fork');
-  assert.equal(refused.hint.className, 'hint err');
-  assert.match(refused.hint.textContent, /Tick the box to go on/);
-  const given = runValidate(1, true);
-  assert.equal(given.ok, true, 'a tick goes on');
-});
-
-test('Start my project clears a demo started earlier — the submit door is a real project', () => {
-  // task 1004420: "Start my project" is a real project, so a demo the founder
-  // set up and then walked back from must not ride the create
-  const r = runValidate(1, true, { demo: { people: 3, hours_each: 4 }, confirmed: { team: true } });
-  assert.equal(r.ok, true);
-  assert.equal(r.state.demo, null, 'the walked-back demo does not ride the create');
-  assert.deepEqual(JSON.parse(JSON.stringify(r.state.confirmed)), {}, 'and its rows are asked again');
-  assert.equal(runValidate(1, false, { demo: { people: 3 } }).state.demo !== null, true, 'an unticked box changes nothing');
-});
-
-test('"What are you making?" asks a name and a kind (task 1004504)', () => {
-  assert.equal(runValidate(2, true).ok, true, 'a name and a kind go on');
-  assert.equal(runValidate(2, true, { name: '  ' }).ok, false, 'no name, no way on');
-  assert.equal(runValidate(2, true, { projType: null }).ok, false, 'no kind, no way on — Not sure is a fine answer');
+  assert.ok(PAGE.indexOf('id="wizResume"') > -1 && PAGE.indexOf('id="wizResume"') < PAGE.indexOf('id="page-h"'), 'above the heading, where a deliberate "New project" lands');
 });
 
-// ── the wiring, executed ───────────────────────────────────────────────────────
-const WIRE_START = '    function paintDoors() {';
-const WIRE_END = '    /* ── the demo route (task 1004420, BV2.PS09) ──';
-const wireSlice = SCRIPT.includes(WIRE_START) && SCRIPT.includes(WIRE_END) ? SCRIPT.slice(SCRIPT.indexOf(WIRE_START), SCRIPT.indexOf(WIRE_END)) : null;
+// ── the tick's wiring, executed ─────────────────────────────────────────────────
+const WIRE_START = "    $('termsAck').checked = !!state.termsAck;";
+const WIRE_END = '    /* ── the demo route';
+const wireSlice = SCRIPT.includes(WIRE_START) && SCRIPT.indexOf(WIRE_END) > SCRIPT.indexOf(WIRE_START)
+  ? SCRIPT.slice(SCRIPT.indexOf(WIRE_START), SCRIPT.indexOf(WIRE_END)) : null;
 
-function runWiring(initialAck) {
-  const handlers = {};
-  const mk = (id) => ({
-    id, checked: false, hidden: false, disabled: true, textContent: '', className: '', attrs: {},
-    addEventListener(type, fn) { handlers[id + ':' + type] = fn; },
-    setAttribute(k, v) { this.attrs[k] = v; },
+function runWiring(termsAck) {
+  const els = {}, handlers = {};
+  let saves = 0, paints = 0;
+  const $ = (id) => (els[id] = els[id] || {
+    id, checked: false, textContent: '', className: '',
+    addEventListener(type, fn) { handlers[`${id}:${type}`] = fn; },
   });
-  const els = { termsAck: mk('termsAck'), 'h-terms': mk('h-terms'), wizDemo: mk('wizDemo'), wizStart: mk('wizStart') };
-  let saves = 0;
-  const sandbox = { $: (id) => els[id], state: { termsAck: initialAck }, saveDraft: () => { saves += 1; } };
+  const sandbox = { $, state: { termsAck }, saveDraft() { saves += 1; }, paintCreate() { paints += 1; } };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
   vm.runInContext(wireSlice, sandbox);
-  return { els, handlers, sandbox, saves: () => saves };
+  return { els, handlers, sandbox, saves: () => saves, paints: () => paints };
 }
 
-test('the front door\'s wiring is still findable', () => {
+test('the tick\'s wiring is findable', () => {
   assert.ok(wireSlice && wireSlice.length > 100, 'the wiring block was not found in projects.html');
   assert.match(wireSlice, /\$\('termsAck'\)\.addEventListener\('change'/, 'the tick is part of the slice');
-  assert.match(wireSlice, /\$\('wizStart'\)\.disabled = !state\.termsAck;/, 'and so is the door painter');
-});
-
-test('both doors wait for the tick: disabled in the markup, and painted from the answer', () => {
-  assert.match(FORK, /<button type="button" class="btn big ghost" id="wizDemo"[^>]*\bdisabled>/, 'the demo door ships disabled');
-  assert.match(FORK, /<button type="submit" class="btn big" id="wizStart" disabled>/, 'and so does Start my project');
-  const fresh = runWiring(false);
-  assert.equal(fresh.els.wizDemo.disabled, true, 'an unticked draft keeps the demo door shut');
-  assert.equal(fresh.els.wizStart.disabled, true, 'and the real-project door');
-  fresh.els.termsAck.checked = true; fresh.handlers['termsAck:change'].call(fresh.els.termsAck);
-  assert.equal(fresh.els.wizDemo.disabled, false, 'ticking opens both doors');
-  assert.equal(fresh.els.wizStart.disabled, false);
-  fresh.els.termsAck.checked = false; fresh.handlers['termsAck:change'].call(fresh.els.termsAck);
-  assert.ok(fresh.els.wizDemo.disabled && fresh.els.wizStart.disabled, 'unticking shuts them again');
-  const resumed = runWiring(true);
-  assert.ok(!resumed.els.wizDemo.disabled && !resumed.els.wizStart.disabled, 'a draft that ticked comes back with its doors open');
-  assert.match(STYLE, /#view-new \.doorPill \.btn\[disabled\]\{opacity:\.35;cursor:default;\}/, 'a shut door reads as shut');
-  assert.match(SCRIPT, /\$\('wizDemo'\)\.addEventListener\('click', function \(\) \{ if \(state\.termsAck\) demoShow\('setup'\); \}\);/,
-    'and the demo door refuses an unticked box even if the attribute is stripped');
 });
 
-test('the tick mirrors into the draft both ways, and a resumed draft paints its own answer', () => {
-  const { els, handlers, sandbox, saves } = runWiring(true);
+test('the tick mirrors into the draft both ways, repaints Create, and a resumed draft paints its own answer', () => {
+  const { els, handlers, sandbox, saves, paints } = runWiring(true);
   assert.equal(els.termsAck.checked, true, 'a draft that ticked comes back ticked (the GitHub round-trip keeps it)');
   els.termsAck.checked = false; handlers['termsAck:change'].call(els.termsAck);
   assert.equal(sandbox.state.termsAck, false, 'unticking is an answer too');
-  els['h-terms'].className = 'hint err';
+  sandbox.$('h-terms').className = 'hint err';
   els.termsAck.checked = true; handlers['termsAck:change'].call(els.termsAck);
   assert.equal(sandbox.state.termsAck, true);
-  assert.equal(els['h-terms'].className, 'hint', 'ticking clears the refusal');
+  assert.equal(els['h-terms'].className, 'hint', 'ticking clears a refusal');
   assert.equal(saves(), 2, 'each change is saved');
+  assert.equal(paints(), 2, 'and Create repaints with it — it waits for the tick');
+  assert.equal(runWiring(false).els.termsAck.checked, false);
 });
 
-test('the demo door names what it opens: the demo route\'s setup screen (task 1004420; run in tests/wizard_demo.mjs)', () => {
-  assert.match(FORK, /id="wizDemo" aria-controls="demoSetup" aria-expanded="false"/, 'the door names what it opens');
-  assert.match(FORK, /<div id="demoSetup" class="demoView" hidden>/, 'baked markup, hidden at rest, never built by script');
-  assert.doesNotMatch(FORK, /demoSoon|isn’t open yet/, 'the placeholder that said the demo was not open is gone');
-});
-
-// ── the fork's door pill ────────────────────────────────────────────────────────
-test('the fork is the door pill: two equal doors in one object, the accent only on the one that goes on', () => {
-  assert.match(FORK, /<h1 id="fork-h">You’re about to start a digital planet\.<\/h1>/);
-  const pill = (FORK.match(/<div class="doorPill" role="group" aria-label="How to begin">[\s\S]*?<\/div>/) || [''])[0];
-  assert.ok(pill, 'one grouped pill');
-  const doors = [...pill.matchAll(/<button type="(button|submit)" class="([^"]+)"[^>]*>([^<]+)<\/button>/g)];
-  assert.equal(doors.length, 2, 'exactly two doors');
-  assert.deepEqual(doors.map((d) => d[3]), ['Try the demo', 'Start my project']);
-  assert.equal(doors[0][2], 'btn big ghost', 'the demo door is the secondary: transparent at rest');
-  assert.equal(doors[1][2], 'btn big', 'begin carries the accent');
-  assert.equal(doors[1][1], 'submit', 'and is the form\'s one submit, so Enter goes on');
-  assert.match(STYLE, /\.doorPill\{display:inline-grid;grid-template-columns:1fr 1fr;/, 'two EQUAL tracks — the two routes are equal ways in');
-  assert.match(STYLE, /\.doorPill\{[^}]*border-radius:999px;/, 'pill or nothing');
-  assert.match(STYLE, /@media \(max-width:520px\)\{\s*\.doorPill\{display:grid;grid-template-columns:1fr;/, 'at a phone width the two stack, still one object');
-});
-
-test('the night room stands behind every screen — the planet stage and the bongo pair are gone (task 1004504)', () => {
-  assert.match(VIEW_NEW, /<div class="wizRoom" id="wizRoom" data-screen="fork" aria-hidden="true">/, 'decorative, so hidden from a screen reader, and baked at the fork for a no-script visitor');
-  assert.match(VIEW_NEW, /<span class="rmSeed"><img src="\/assets\/world\/r2-chrome-blob-one-cut\.webp" alt=""><\/span>/, 'the seed is a real plate, root-absolute so it is stamped');
-  assert.ok(fs.existsSync(path.join(LANDING, 'assets', 'world', 'r2-chrome-blob-one-cut.webp')), 'and it exists on disk');
-  assert.doesNotMatch(HUB, /id="forkStage"|class="forkSeed"|class="forkRoutes"|bongoCell|id="physStage"/, 'no fork stage, seed orbit, route list, bongo pair or forming planet left in the markup');
-  assert.doesNotMatch(STYLE, /\.forkStage\{|\.forkOrbit\{|\.bongoCell|\.physStage/, 'and no rule left for them');
-  const at = STYLE.indexOf('#view-new .wizRoom{');
-  const end = STYLE.indexOf('/* under 900 the window', at);
-  assert.ok(at > -1 && end > at, 'the night room\'s CSS block is findable');
-  const block = STYLE.slice(at, end);
-  const hexes = [...block.matchAll(/#[0-9a-f]{3,8}\b/gi)].map((m) => m[0].toLowerCase());
-  assert.ok(hexes.length > 0 && hexes.every((h) => h === '#000' || h === '#fff'), `every colour a mix of the fifteen with black or white (${[...new Set(hexes)]})`);
-  for (const m of block.matchAll(/--rm-[a-z0-9-]+:([^;]+);/g)) {
-    assert.match(m[1], /^color-mix\(in srgb,var\(--(sea|accent)\)|^rgba\(255,255,255,/, `a room token is derived, never a new literal: ${m[0]}`);
-  }
-  const motion = block.indexOf('@media (prefers-reduced-motion:no-preference){');
-  assert.ok(motion > -1, 'the room\'s motion sits inside the kill switch');
-  assert.doesNotMatch(block.slice(0, motion), /animation:|transition:/, 'and none outside it: the rest frame is the whole composition');
-  assert.doesNotMatch(block, /:root/, 'room tokens live on the room, never a page :root');
-});
-
-test('the two routes are described honestly for today: the demo is open (task 1004420), creation promises no questions that do not exist yet', () => {
-  const intro = (FORK.match(/<div id="forkIntro">[\s\S]*?<\/form>/) || [''])[0];
-  assert.match(intro, /<p class="lede">Try a small demo first, or start your real project\.<\/p>/);
-  assert.doesNotMatch(FORK, /coming soon/, 'the demo is built, so nothing says it is coming');
-  assert.doesNotMatch(FORK, /seven questions/i, 'the copy promises no question count');
-  assert.doesNotMatch(FORK, /\bBongos\b/, 'no product name baked where a child instance would ship it');
-});
-
-// ── show(): the room, the eyebrow and the one Back, executed ───────────────────
-// The slice runs from the SCREEN map through show(), so eyebrowFor() and prevStep() ride
-// along; both ends are asserted.
+// ── show(), executed ────────────────────────────────────────────────────────────
 const SHOW_START = '    var SCREEN = {';
 const SHOW_RE = /function show\(step, moveFocus\) \{[\s\S]*?\n {4}\}/;
 const showMatch = SCRIPT.match(SHOW_RE);
 const showSlice = showMatch && SCRIPT.includes(SHOW_START) && SCRIPT.indexOf(SHOW_START) < showMatch.index
   ? SCRIPT.slice(SCRIPT.indexOf(SHOW_START), showMatch.index + showMatch[0].length) : null;
 
-function runShow(step, { demo = null, demoOpen = false } = {}) {
-  const cls = (name) => { const set = new Set(); return { name, set, toggle(c, on) { if (on) set.add(c); else set.delete(c); } }; };
+function runShow(step, { demo = null } = {}) {
+  const cls = () => { const set = new Set(); return { set, toggle(c, on) { if (on) set.add(c); else set.delete(c); } }; };
   const els = {};
   const $ = (id) => (els[id] = els[id] || {
-    id, classList: cls(id), hidden: id === 'demoSetup' ? !demoOpen : false, textContent: '', attrs: {},
+    id, classList: cls(), hidden: false, textContent: '', attrs: {},
     setAttribute(k, v) { this.attrs[k] = v; }, querySelector: () => null,
   });
+  let painted = '';
   const sandbox = {
-    $, state: { demo }, panels: Object.fromEntries(Object.entries(MAP).map(([id, n]) => [n, id])),
-    saveDraft() {}, authKnown: false, repoAccess: null,
-    paintDoors() {}, physLoadAccountOnce() {}, paintChecks() {}, physDefaults() {},
-    renderModules() {}, syncHome() {}, ensureRepoAccess() {}, checkSlugAvailable() {}, renderAddrPanel() {},
-    syncAppStep() {}, syncRenderSetup() {}, paintSetup() {}, renderLook() {}, renderRecap() {},
+    $, state: { demo }, panels: MAP, saveDraft() {},
+    paintPage() { painted = 'page'; }, paintCreate() { painted = 'create'; },
   };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
@@ -271,36 +125,34 @@ function runShow(step, { demo = null, demoOpen = false } = {}) {
   return {
     on: Object.keys(els).filter((id) => els[id].classList.set.has('on')),
     screen: els.wizRoom.attrs['data-screen'], eyebrow: els.wizEyebrow.textContent,
-    back: !els.wizBack.hidden, tag: !els.demoTag.hidden,
+    parts: !els.wizParts.hidden, tag: !els.demoTag.hidden, painted,
+    done: [...els['panel-done'].classList.set].sort(),
   };
 }
 
-test('show() turns one screen on, tells the room which screen it is, and names it in the eyebrow', () => {
+test('show() turns the gate or the page on, tells the room where it is, and names it in the eyebrow', () => {
   assert.ok(showSlice, 'the SCREEN map through show() was not found in projects.html');
   assert.match(showSlice, /function eyebrowFor\(step\)/, 'the eyebrow is part of the slice');
-  assert.doesNotMatch(showSlice, /paintRail|wizFront|wizFork|wizDone/, 'show() paints no rail and toggles no front-door or done layout (task 1004504)');
-  const screens = { 0: 'signin', 1: 'fork', 2: 'what', 3: 'checks', 4: 'review', 5: 'look', 6: 'done' };
-  for (const [n, screen] of Object.entries(screens)) {
-    const r = runShow(Number(n));
-    const id = Object.keys(MAP).find((k) => MAP[k] === Number(n));
-    assert.deepEqual(r.on, [id], `step ${n}: only ${id} is on`);
-    assert.equal(r.screen, screen, `step ${n}: the room grows to "${screen}"`);
-  }
-  assert.equal(runShow(1).eyebrow, 'New project');
-  assert.equal(runShow(1, { demoOpen: true }).eyebrow, 'Demo', 'the demo\'s own screen says so');
-  assert.equal(runShow(2, { demo: { people: 3 } }).eyebrow, 'New demo', 'and a demo past the fork stays marked');
-  assert.equal(runShow(6).eyebrow, 'Founding');
-});
-
-test('one Back: hidden at sign-in, on the fork and on done; shown on every screen between', () => {
-  assert.equal(runShow(0).back, false, 'sign-in has nowhere to go back to');
-  assert.equal(runShow(1).back, false, 'the fork is the first screen');
-  assert.equal(runShow(1, { demoOpen: true }).back, true, 'the demo screen walks back to the fork');
-  for (const n of [2, 3, 4, 5]) assert.equal(runShow(n).back, true, `step ${n} walks back`);
-  assert.equal(runShow(6).back, false, 'a created project is not walked back into the wizard');
-  assert.equal(runShow(2).tag, false, 'no demo tag on a real project');
-  assert.equal(runShow(2, { demo: { people: 3 } }).tag, true, 'the demo tag rides every screen of a demo');
-  assert.match(SCRIPT, /function prevStep\(step\) \{\s*if \(step === 4 && state\.demo\) return 2;/, 'a demo, which skipped the checks, walks back past them too');
+  const gate = runShow(0);
+  assert.deepEqual(gate.on, ['panel-gate'], 'signed out: only the gate');
+  assert.equal(gate.screen, 'signin');
+  assert.equal(gate.eyebrow, 'Sign in');
+  const page = runShow(1);
+  assert.deepEqual(page.on, ['panel-page'], 'the page, and part 03 still waiting');
+  assert.equal(page.screen, 'page');
+  assert.equal(page.eyebrow, 'New project');
+  assert.equal(page.parts, true, 'parts 01 and 02 on show');
+  assert.deepEqual(page.done, ['waiting'], 'part 03 waits until the project exists');
+  assert.equal(page.painted, 'page', 'the page paints every control on entry');
+  const made = runShow(2);
+  assert.deepEqual(made.on.sort(), ['panel-done', 'panel-page'], 'created: the same page, part 03 live');
+  assert.deepEqual(made.done, ['live', 'on']);
+  assert.equal(made.parts, false, 'parts 01 and 02 stand down behind the recap');
+  assert.equal(made.screen, 'done');
+  assert.equal(made.eyebrow, 'Founding');
+  assert.equal(runShow(1, { demo: { people: 3 } }).eyebrow, 'New demo', 'a demo is marked');
+  assert.equal(runShow(1, { demo: { people: 3 } }).tag, true, 'and its heading carries the demo tag');
+  assert.equal(runShow(1).tag, false, 'a real project carries none');
 });
 
 // ── the create ──────────────────────────────────────────────────────────────────
@@ -308,34 +160,30 @@ test('the create carries the tick, and is never filed without it', () => {
   const create = SCRIPT.slice(SCRIPT.indexOf("$('doCreate').addEventListener('click'"));
   assert.match(create, /terms_acknowledged: state\.termsAck \? true : undefined,/,
     'a real boolean when ticked, absent otherwise — the route refuses anything but a boolean');
-  const guard = create.indexOf('if (!state.termsAck) { show(1, true); validateStep(1); return; }');
-  assert.ok(guard > -1, 'an unticked draft is sent back to the fork\'s tick');
+  const guard = create.indexOf('if (createWhy()) {');
+  assert.ok(guard > -1, 'an unticked page is refused, with its reason said in place');
   assert.ok(guard < create.indexOf('ensureFreshRepo()'), 'BEFORE anything is created — the repo included');
+  assert.match(SCRIPT, /if \(!state\.termsAck\) return 'Tick the terms to create your project\.';/);
 });
 
 test('the tick is part of the draft and of the reset, and the draft key moved with the renumbering', () => {
-  assert.match(SCRIPT, /var state = \{ step: 0,[^}]*termsAck: false, confirmed: \{\} \};/, 'the initial state declares it');
-  assert.match(SCRIPT, /state = \{ step: 1,[^}]*termsAck: false, confirmed: \{\} \};/, 'and "start another project" clears it — each project records its own');
-  assert.match(SCRIPT, /\$\('termsAck'\)\.checked = false; paintDoors\(\);/, 'and the reset shuts the doors with it');
-  assert.match(SCRIPT, /var DRAFT_KEY = 'cb-create-draft-v9';/, 'a draft saved under the old numbering is ignored, not replayed onto the wrong screen');
+  assert.match(SCRIPT, /var state = \{ step: 0,[^}]*termsAck: false \};/, 'the initial state declares it');
+  assert.match(SCRIPT, /state = \{ step: 1,[^}]*termsAck: false \};/, 'and "start another project" clears it — each project records its own');
+  assert.match(SCRIPT, /\$\('termsAck'\)\.checked = false; demoShow\(false\); checksShow\('main'\);/, 'and the reset unticks the box');
+  assert.match(SCRIPT, /var DRAFT_KEY = 'cb-create-draft-v10';/, 'a draft saved under the old numbering is ignored, not replayed');
 });
 
 // ── the look-before-you-ship kit walks it ─────────────────────────────────────
-// Every walk past the fork opens the way a founder does: the tick, then a door — Start my
-// project, or the demo door and the demo screen's Continue.
-test('every kit walk past the fork ticks first, then takes a door', () => {
+test('every kit walk that creates a project ticks the terms before it presses Create', () => {
   const states = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.states.json'), 'utf8')).states;
   assert.ok(states['in-new'], 'the in-new state exists');
-  for (const sel of ['#panel-fork', '#termsAck']) assert.ok((states['in-new'].expect.visible || []).includes(sel), `arriving at ?view=new pictures the fork and its tick (${sel})`);
-  const REAL = ['#termsAck', '#wizStart'];
-  const DEMO = ['#termsAck', '#wizDemo', '#demoStart'];
+  for (const sel of ['#panel-page', '#termsAck', '#doCreate']) assert.ok((states['in-new'].expect.visible || []).includes(sel), `arriving at ?view=new pictures the page (${sel})`);
   const probes = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.probes.json'), 'utf8')).probes;
   const walks = [...Object.entries(states).map(([k, v]) => [k, v.actions || []]), ...probes.map((p) => [p.name, p.steps])]
-    .filter(([, steps]) => steps.some((st) => st[1] === '#newName'));
-  assert.ok(walks.length >= 12, `every wizard walk is found (${walks.length})`);
+    .filter(([, steps]) => steps.some((st) => st[0] === 'click' && st[1] === '#doCreate'));
+  assert.ok(walks.length >= 2, `every creating walk is found (${walks.length})`);
   for (const [name, steps] of walks) {
     const clicks = steps.filter((st) => st[0] === 'click').map((st) => st[1]);
-    const door = clicks[1] === '#wizDemo' ? DEMO : REAL;
-    assert.deepEqual(clicks.slice(0, door.length), door, `${name}: the tick, then a door, come first`);
+    assert.ok(clicks.indexOf('#termsAck') > -1 && clicks.indexOf('#termsAck') < clicks.indexOf('#doCreate'), `${name}: the tick comes before Create`);
   }
 });

package/tests/wizard_intent_resume.mjs

@@ -59,8 +59,8 @@ test('both slices are still findable (a rename must fail loudly, not silently pa
   assert.ok(offerSlice, 'paintResumeOffer() was not found in projects.html');
   assert.match(enterSlice, /if \(focus && !resumeIntent\) \{/, 'the intent branch is part of the slice');
   assert.match(enterSlice, /startProgress\(created\.id\);/, 'so is the resume branch it guards');
-  assert.match(enterSlice, /draft\.step >= 1 && draft\.step <= 5 \?/,
-    'the STORED draft\'s step decides, not state.step — state.step is 6 for the whole life of a finished standup');
+  assert.match(enterSlice, /if \(!\(draft && draft\.step === 1\)\) resetForNewProject\(\);/,
+    'the STORED draft\'s step decides, not state.step — state.step is 2 for the whole life of a finished standup');
   // since task 1004549 a second draft in flight keeps its place on a non-deliberate
   // arrival (tests/wizard_draft_resume.mjs slice 4); a deliberate nav still comes here
   assert.match(SCRIPT, /if \(created && created\.id && \(focus \|\| !draftInFlight \|\| resumeIntent\)\) \{ enterCreated\(created, !!focus\); return; \}/,
@@ -76,7 +76,7 @@ function runEnter({ focus, resumeIntent = false, draft = null, record, handbackS
   const calls = { show: [], resets: 0, offer: [], done: 0, progress: [], polls: 0, focused: 0, remembered: [] };
   // state.step is the DONE step for the whole life of a finished standup — the value
   // a draft-blind reading would have trusted
-  const state = { step: draft ? draft.step : 6, name: 'Mercury', slug: 'mercury', domain: '', mode: 'greenfield', noAddress: false, modules: null };
+  const state = { step: draft ? draft.step : 2, name: 'Mercury', slug: 'mercury', domain: '', mode: 'greenfield', noAddress: false, modules: null };
   const sandbox = {
     record, focus, resumeIntent, state,
     DRAFT_KEY: 'draft',
@@ -104,7 +104,7 @@ const REC = { id: 'inst-1', name: 'Acme', slug: 'acme', domain: 'acme.example',
 
 test('a reload / Back / identity settle (focus false) still resumes the done panel, watch and all', () => {
   const { calls, state } = runEnter({ focus: false, record: REC });
-  assert.deepEqual(calls.show, [[6, false]], 'the done panel, and no focus steal on a non-deliberate arrival');
+  assert.deepEqual(calls.show, [[2, false]], 'the created page, part 03 live, and no focus steal on a non-deliberate arrival');
   assert.equal(calls.resets, 0, 'nothing is reset — this is the same standup continuing');
   assert.equal(calls.done, 1, 'the checklist is re-rendered');
   assert.deepEqual(calls.progress, ['inst-1'], 'the progress watch is restarted from the record');
@@ -115,7 +115,7 @@ test('a reload / Back / identity settle (focus false) still resumes the done pan
 
 test('a hand-back from the GitHub callback page resumes watching THAT attempt (task 1004548)', () => {
   const { calls, sandbox } = runEnter({ focus: false, record: { ...REC }, handbackState: 'ab'.repeat(32) });
-  assert.deepEqual(calls.show, [[6, false]], 'the founder lands on their checklist');
+  assert.deepEqual(calls.show, [[2, false]], 'the founder lands on their checklist');
   assert.equal(sandbox.manifestState, 'ab'.repeat(32), 'the sign-in step polls the attempt GitHub just approved');
   assert.equal(sandbox.manifestPending, true, 'and the poll is queued for resumePolls()');
   assert.equal(sandbox.live.manifest, 'code_received', 'it shows the wait, not "Set up GitHub sign-in" again');
@@ -126,13 +126,13 @@ test('a hand-back from the GitHub callback page resumes watching THAT attempt (t
   assert.equal(done.sandbox.manifestPending, false, 'and nothing is polled for it');
 });
 
-test('a deliberate "New project" click after a finished standup opens a FRESH step 1', () => {
+test('a deliberate "New project" click after a finished standup opens a FRESH page', () => {
   const { calls, state } = runEnter({ focus: true, record: REC });
   assert.equal(calls.done, 0, 'the previous project\'s done panel is not painted');
   assert.equal(calls.progress.length, 0, 'and its watch is not restarted');
   assert.equal(calls.resets, 1, 'with no second draft to lose, the wizard forgets the finished project');
-  assert.deepEqual(calls.show, [[1, false]], 'step 1, and step 1 does not take the heading focus');
-  assert.equal(calls.focused, 1, 'its first control, the fork\'s terms tick, does — the deliberate-nav rule enter() already applies');
+  assert.deepEqual(calls.show, [[1, false]], 'the page, and it does not take the heading focus');
+  assert.equal(calls.focused, 1, 'its first control, the name, does — the deliberate-nav rule enter() already applies');
   assert.equal(state.name, '', 'the old name is gone from the form');
 });
 
@@ -145,7 +145,7 @@ test('…and the standup stays one click away, named, on the resume link', () =>
 
 test('the resume link gets the done panel back — the record was never cleared', () => {
   const { calls, sandbox } = runEnter({ focus: true, resumeIntent: true, record: REC });
-  assert.deepEqual(calls.show, [[6, true]], 'a deliberate resume moves focus to the done panel');
+  assert.deepEqual(calls.show, [[2, true]], 'a deliberate resume moves focus to part 03');
   assert.deepEqual(calls.progress, ['inst-1'], 'the watch comes back with it');
   assert.equal(sandbox.resumeIntent, false, 'the flag is ONE-SHOT — the next plain nav click must mean "new" again');
   assert.deepEqual(calls.offer, [null], 'and the offer comes down behind it');
@@ -155,47 +155,27 @@ test('a second draft already under way is NOT wiped by navigating back to the wi
   // The regression this guards: with the reset unconditional, typing a name, stepping
   // away to "Your projects" and clicking "New project" again would blank the draft —
   // trading the reported bug for a worse one.
-  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 3 } });
+  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 1 } });
   assert.equal(calls.resets, 0, 'a live draft is never reset');
-  assert.deepEqual(calls.show, [[3, true]], 'the second draft resumes where it was left, heading focused');
-  assert.equal(state.step, 3);
+  assert.deepEqual(calls.show, [[1, false]], 'the second draft resumes on the page');
+  assert.equal(state.step, 1);
+  assert.equal(state.name, 'Mercury', 'with what was typed');
   assert.deepEqual(calls.offer, ['Acme'], 'the offer stays up beside it');
 });
 
-test('the done panel\'s own saved step is NOT a second draft — it must not block the reset', () => {
-  // Caught in a render, not in a unit test: show(6) calls saveDraft(), so DRAFT_KEY is
+test('the created page\'s own saved step is NOT a second draft — it must not block the reset', () => {
+  // Caught in a render, not in a unit test: show(2) calls saveDraft(), so DRAFT_KEY is
   // non-empty again the moment a create lands. Reading "is there a draft?" left the
   // finished project's name in the fresh form, under a line offering to resume it.
-  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 6, name: 'Mercury' } });
-  assert.equal(calls.resets, 1, 'the done step is bookkeeping, not a project being typed');
-  assert.deepEqual(calls.show, [[1, false]], 'out-of-range steps land on step 1, the front door');
+  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 2, name: 'Mercury' } });
+  assert.equal(calls.resets, 1, 'the created step is bookkeeping, not a project being typed');
+  assert.deepEqual(calls.show, [[1, false]], 'a fresh page');
   assert.equal(state.name, '', 'and the finished project\'s name does not survive into it');
-  assert.equal(calls.done, 0, 'never back onto the done panel');
+  assert.equal(calls.done, 0, 'never back onto the finished project\'s part 03');
 });
 
-test('a draft on the checks, the review or the look is live too — the last three screens (tasks 1004351, 1004504)', () => {
-  // Every renumbering has moved the review: 7 to 8 for the app step, 10 for the front door
-  // (task 1004417), 11 for the Look step (task 1004421), 4 for the six blended screens
-  // (task 1004504). A guard left behind would reset a second project sitting on its
-  // review, silently wiping it.
-  for (const step of [3, 4, 5]) {
-    const { calls, state } = runEnter({ focus: true, record: REC, draft: { step } });
-    assert.equal(calls.resets, 0, `step ${step} is a live draft`);
-    assert.deepEqual(calls.show, [[step, true]]);
-    assert.equal(state.step, step);
-  }
-});
-
-test('a draft on the fork or the first question is live too — a founder part-way through keeps their place (tasks 1004417, 1004504)', () => {
-  for (const step of [1, 2]) {
-    const { calls, state } = runEnter({ focus: true, record: REC, draft: { step } });
-    assert.equal(calls.resets, 0, `step ${step} is a live draft`);
-    assert.equal(state.step, step);
-  }
-});
-
-test('a draft whose step is missing or junk resets too — only 1-5 preserves anything', () => {
-  for (const draft of [{ step: 0 }, { step: 6 }, { name: 'half-typed' }]) {
+test('a draft whose step is missing or junk resets too — only the page (step 1) preserves anything', () => {
+  for (const draft of [{ step: 0 }, { step: 2 }, { step: 6 }, { name: 'half-typed' }]) {
     const { calls } = runEnter({ focus: true, record: REC, draft });
     assert.equal(calls.resets, 1, `step ${JSON.stringify(draft.step)} is not a wizard step`);
     assert.deepEqual(calls.show, [[1, false]]);
@@ -219,14 +199,14 @@ test('paintResumeOffer names the project by textContent and hides on null (no li
   assert.doesNotMatch(offerSlice, /innerHTML/, 'this surface builds no live DOM from strings');
 });
 
-test('the offer ships as real markup inside step 1, hidden until there is something to resume', () => {
-  // step 1 is the fork since task 1004504 (the terms are its tick) — the offer lives there
-  const panel = HUB.slice(HUB.indexOf('id="panel-fork"'), HUB.indexOf('id="panel-what"'));
-  assert.ok(HUB.indexOf('id="panel-fork"') > -1 && HUB.indexOf('id="panel-what"') > HUB.indexOf('id="panel-fork"'), 'step 1 is findable');
+test('the offer ships as real markup at the top of the page, hidden until there is something to resume', () => {
+  // the page is step 1 since task 1004648 — the offer sits above its heading
+  const panel = HUB.slice(HUB.indexOf('id="panel-page"'), HUB.indexOf('id="part-project"'));
+  assert.ok(HUB.indexOf('id="panel-page"') > -1 && HUB.indexOf('id="part-project"') > HUB.indexOf('id="panel-page"'), 'the page is findable');
   assert.match(panel, /<p class="resumeOffer" id="wizResume" hidden>still watching <strong id="wizResumeName">your project<\/strong> — <a href="#" id="wizResumeGo">resume it<\/a><\/p>/,
-    'baked into the panel (C7), carrying its own hidden state');
-  assert.ok(panel.indexOf('id="wizResume"') < panel.indexOf('<form data-next="2">'),
-    'it sits above the fork\'s form, where a visitor reads it before anything else');
+    'baked into the page (C7), carrying its own hidden state');
+  assert.ok(panel.indexOf('id="wizResume"') < panel.indexOf('id="page-h"'),
+    'it sits above the heading, where a visitor reads it before anything else');
   assert.equal((HUB.match(/id="wizResume"/g) || []).length, 1,
     'and only once — a second copy would be a duplicate id');
   assert.match(SCRIPT, /\$\('wizResumeGo'\)\.addEventListener\('click', function \(ev\) \{\n\s*ev\.preventDefault\(\);\n\s*resumeIntent = true;\n\s*enter\(true\);/,