@bongos/core 1.21.91 → 1.21.92

package/tests/wizard_physics_more.mjs

@@ -46,13 +46,12 @@ const SCRIPT = slice('/* ── planet physics (tasks 1004418 and 1004419, BV2.P
 const TEAM = slice('    function teamLabel(t) {', "    $('f-desc').value = state.description || '';", 'the team pills');
 const APP = slice('    function appPlatformChoice() {', '    var ROWS = [', 'the app choice');
 const REVIEW = slice('    var ROWS = [', '    function renderRecap() {', 'the review rows');
-const VALIDATE = slice('    /* per-screen validation on Continue */', "    root.querySelectorAll('.panel form')", 'validateStep');
-for (const [name, region] of [['checksAdvance', SCRIPT], ['paintChecks', SCRIPT], ['physDefaults', SCRIPT], ['confirmRow', REVIEW],
-  ['rowValid', REVIEW], ['rowFixed', REVIEW], ['paintSetup', REVIEW], ['validateStep', VALIDATE], ['paintTeam', TEAM]]) {
+for (const [name, region] of [['physScreen', SCRIPT], ['paintChecks', SCRIPT], ['physDefaults', SCRIPT], ['firstInvalidRow', REVIEW],
+  ['rowValid', REVIEW], ['rowFixed', REVIEW], ['paintSetup', REVIEW], ['paintTeam', TEAM]]) {
   assert.ok(region.includes(`function ${name}(`), `the slice carries ${name}()`);
 }
-// the screens the controller paints: the quick checks and the review
-const PANEL = slice('<section class="panel" id="panel-checks"', '<!-- 5 · a look, then Create', 'the checks and review markup');
+// what the controller paints: part 01 (the quick checks) and part 02 (the rows), task 1004648
+const PANEL = slice('<div class="part" id="part-project"', '<!-- the terms (tasks', 'parts 01 and 02');
 const plain = (v) => JSON.parse(JSON.stringify(v)); // values born in the vm
 
 // ── a small DOM: the screens' own elements, as a tree, matched by selector ────
@@ -60,7 +59,7 @@ class El {
   constructor(tag, attrs = {}) {
     this.tagName = tag; this.attrs = { ...attrs }; this.hidden = 'hidden' in attrs; this.disabled = 'disabled' in attrs;
     this.value = attrs.value || ''; this.textContent = ''; this.title = ''; this.className = attrs.class || '';
-    this.listeners = {}; this.children = []; this.options = [{}]; this.parent = null; this.checked = 'checked' in attrs;
+    this.listeners = {}; this.children = []; this.options = [{}]; this.parent = null; this.checked = 'checked' in attrs; this.style = {};
     const self = this;
     this.classes = new Set(this.className.split(/\s+/).filter(Boolean));
     this.classList = { toggle(c, on) { if (on) self.classes.add(c); else self.classes.delete(c); }, contains: (c) => self.classes.has(c),
@@ -154,12 +153,15 @@ function boot({ check = (body) => ({ stop: false, soft_limits: softLimitsFor(bod
   const $ = (id) => (els[id] = els[id] || new El('div', { id }));
   const shown = [];
   const fetched = [];
-  const state = Object.assign({ step: 4, name: 'Kestrel', description: '', teamShape: null, physics: null, projType: 'game', mode: 'greenfield',
-    appPlatform: 'later', demo: null, modules: null, confirmed: {}, termsAck: true }, draft);
+  const state = Object.assign({ step: 1, name: 'Kestrel', description: '', teamShape: null, physics: null, projType: 'game', mode: 'greenfield',
+    appPlatform: 'later', demo: null, modules: null, termsAck: true }, draft);
   const sandbox = {
     $, state, API: '/api/bongos', root: dom.root, Intl,
     document: { createElement: (t) => new El(t) },
-    saveDraft() {}, show(n) { shown.push(n); state.step = n; },
+    saveDraft() {}, show(n) { shown.push(n); state.step = n; }, paintCreate() {}, renderLook() {},
+    // the Look row's words come from the shared picker's catalogue (tests/projects_hub_look.mjs)
+    lookKit: { LOOKS: { 'chrome-world': { title: 'The chrome world', colors: { accent: '#fb9569' } } } },
+    defaultLook: () => ({ look: 'chrome-world', nightTint: true, logo: null }),
     setMode(m) { state.mode = m; }, authKnown: true,
     // the code, address and Render checks are their own files' to run (projects_hub_app_step,
     // public_landing_projects); here they answer as told
@@ -175,7 +177,7 @@ function boot({ check = (body) => ({ stop: false, soft_limits: softLimitsFor(bod
     },
   };
   vm.createContext(sandbox);
-  vm.runInContext([TEAM, SCRIPT, APP, REVIEW, VALIDATE].join('\n'), sandbox, { filename: 'projects.html#physics' });
+  vm.runInContext([TEAM, SCRIPT, APP, REVIEW].join('\n'), sandbox, { filename: 'projects.html#physics' });
   const q = (sel) => dom.root.querySelectorAll(sel);
   const row = (key) => q(`#reviewRows .setRow[data-row="${key}"]`)[0];
   return {
@@ -184,21 +186,17 @@ function boot({ check = (body) => ({ stop: false, soft_limits: softLimitsFor(bod
     a: () => state.physics.answers,
     pick: (key, val) => q(`[data-phys="${key}"][data-val="${val}"]`)[0].click(),
     rowSays: (key) => [row(key).querySelector('[data-row-v]').textContent, row(key).querySelector('[data-row-s]').textContent],
-    // a row's own check and confirmation, as the page's one "Looks right, continue" runs it
-    // per row (task 1004550): there is no per-row Looks right any more
-    ok: (key) => vm.runInContext(`confirmRow('${key}')`, sandbox),
-    // Edit opens a row; the same control reads Done while it is open, and confirms it
+    // Change opens a row; the same control reads Done while it is open, and closes it (task 1004648)
     change: (key) => row(key).querySelector('[data-row-chg]').click(),
     done: (key) => row(key).querySelector('[data-row-chg]').click(),
     isOpen: (key) => !row(key).querySelector('.opts').hidden,
-    go: () => $('reviewGo'),
     settle: async () => { for (let i = 0; i < 4; i += 1) await tick(); },
   };
 }
 const tick = () => new Promise((r) => setTimeout(r, 0));
 // the quick checks, answered (the Kestrel sample of the canvas)
 const CHECKS = { home_country: 'US', home_region: 'US-CA', builder_geography: 'us-eu', minors_on_board: false, entity: 'intent-solo' };
-// on the review, with the checks answered, the prefills written and the table asked
+// on the page, with the checks answered, the prefills written and the table asked
 async function onReview(answers = {}, opts = {}) {
   const w = boot(opts);
   w.run('phys()');
@@ -245,9 +243,9 @@ test('the kit stub\'s physics hide rules are the table\'s own, word for word', (
   }
 });
 
-// ── screen 3, the quick checks ───────────────────────────────────────────────
+// ── part 01, the quick checks ────────────────────────────────────────────────
 test('the quick checks reveal what an answer opens: the age tiers, the legal forms, a state or province', () => {
-  const w = boot({ draft: { step: 3 } });
+  const w = boot();
   w.run('paintChecks()');
   assert.equal(w.$('physAges').hidden, true, 'no tiers before a yes');
   assert.equal(w.$('physForms').hidden, true, 'the plain intents first');
@@ -277,11 +275,11 @@ test('the quick checks reveal what an answer opens: the age tiers, the legal for
 });
 
 test('the quick checks fill in from the account\'s last project, never its state, and offer nothing without one', async () => {
-  const none = boot({ draft: { step: 3 } });
+  const none = boot();
   none.run('physLoadAccountOnce()');
   await none.settle();
   assert.equal(none.$('physFillOffer').hidden, true, 'no earlier answers: no offer');
-  const w = boot({ draft: { step: 3 }, instances: { instances: [
+  const w = boot({ instances: { instances: [
     { created_at: '2026-01-01', detail: { home_country: 'GB', entity: 'intent-unsure' } },
     { created_at: '2026-06-01', detail: { home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'for-profit', project_state: 'existing', framing: 'local' } },
   ] } });
@@ -293,28 +291,31 @@ test('the quick checks fill in from the account\'s last project, never its state
   assert.equal(w.$('physCountry').value, 'NL', 'painted where the founder can see it');
 });
 
-test('Continue on the checks writes the review\'s prefills, asks the real table, and opens the review', async () => {
-  const w = boot({ draft: { step: 3, description: 'A field guide app for birdwatchers' } });
+test('the page writes part 02\'s prefills, and Create\'s screen asks the real table with them', async () => {
+  const w = boot({ draft: { description: 'A field guide app for birdwatchers' } });
   w.run('phys()');
   Object.assign(w.a(), CHECKS);
-  assert.equal(w.run('checksAdvance()'), false, 'the screen never says yes itself');
+  w.run('physDefaults()');
+  w.run('var screened = null; physScreen().then(function (ok) { screened = ok; });');
   await w.settle();
-  assert.deepEqual(w.shown, [4]);
+  assert.equal(w.run('screened'), true, 'no stop: Create may go on');
+  assert.deepEqual(w.shown, [], 'the screen moves nothing itself');
   const sent = w.fetched.find((f) => f.url.endsWith('/provisioning/physics-check')).body;
   assert.equal(sent.description, 'A field guide app for birdwatchers');
   assert.deepEqual({ s: sent.detail.project_state, f: sent.detail.framing, n: [sent.detail.builders_at_start, sent.detail.builders_expected] },
     { s: 'new', f: 'managed', n: [1, 1] }, 'a new project, all managed, one person');
   assert.equal(w.state.teamShape, 'solo');
-  assert.ok(w.run('physLimits').some((l) => l.option === 'reward_intents' && l.effect === 'hide'), 'the table\'s verdicts shape the review');
+  assert.ok(w.run('physLimits').some((l) => l.option === 'reward_intents' && l.effect === 'hide'), 'the table\'s verdicts shape the rows');
 });
 
-test('a stop from the server ends on the stop screen, before anything exists', async () => {
-  const w = boot({ draft: { step: 3, description: 'ransomware' }, check: () => ({ stop: true, message: 'We cannot host this.' }) });
+test('a stop from the server ends in place of the checks, before anything exists', async () => {
+  const w = boot({ draft: { description: 'ransomware' }, check: () => ({ stop: true, message: 'We cannot host this.' }) });
   w.run('phys()');
   Object.assign(w.a(), CHECKS);
-  w.run('checksAdvance()');
+  w.run('var screened = null; physScreen().then(function (ok) { screened = ok; });');
   await w.settle();
-  assert.deepEqual(w.shown, [], 'no review');
+  assert.equal(w.run('screened'), false, 'Create files nothing');
+  assert.deepEqual(w.shown, [], 'nothing moves on');
   assert.equal(w.$('physStopMsg').textContent, 'We cannot host this.');
   assert.equal(w.$('checksStop').hidden, false);
   assert.equal(w.$('checksMain').hidden, true);
@@ -323,7 +324,7 @@ test('a stop from the server ends on the stop screen, before anything exists', a
 // ── the Team size row (question 5) ───────────────────────────────────────────
 test('Team size: one or many, a start count, and a guessed growth the founder corrects', async () => {
   const w = await onReview();
-  assert.deepEqual(w.rowSays('team'), ['One person', 'Just you.'], 'prefilled: one person');
+  assert.deepEqual(w.rowSays('team'), ['Just you to start', 'Open to invites.'], 'prefilled: one person');
   assert.equal(w.q('[data-phys-solo="one"]')[0].getAttribute('aria-pressed'), 'true');
   assert.equal(w.$('physTeam').hidden, true);
   w.change('team');
@@ -348,27 +349,19 @@ test('Team size: one or many, a start count, and a guessed growth the founder co
   assert.equal(w.rowSays('team')[1], 'About 12 by month three · anyone can apply.');
   assert.equal(w.row('team').querySelector('[data-row-chg]').textContent, 'Done', 'an open row\'s one control reads Done');
   w.done('team');
-  assert.equal(w.state.confirmed.team, true);
   assert.equal(w.isOpen('team'), false, 'Done closes the row');
-  assert.equal(w.row('team').querySelector('[data-row-chg]').textContent, 'Edit');
+  assert.equal(w.row('team').querySelector('[data-row-chg]').textContent, 'Change');
+  assert.equal(w.state.confirmed, undefined, 'and nothing is recorded as confirmed: the summary wins');
 });
 
-test('changing the team re-asks the rows it moves: rewards and extras', async () => {
-  const w = await onReview({ builders_at_start: 3, builders_expected: 8 });
-  w.state.confirmed = { rewards: true, extras: true, code: true };
-  w.q('[data-phys-solo="one"]')[0].click();
-  assert.deepEqual(Object.keys(w.state.confirmed), ['code'], 'rewards and extras come back to be confirmed; the repo does not');
-  assert.equal(w.state.teamShape, 'solo');
-});
-
-test('a team row with no count cannot be confirmed: it opens instead', async () => {
+test('a team row that cannot be filed keeps Create from filing it, and Done leaves it open with its controls', async () => {
   const w = await onReview();
+  w.change('team');
   w.state.physics.answers.builders_at_start = 4; w.state.physics.answers.builders_expected = 2;   // fewer later than now
-  assert.equal(w.run("confirmRow('team')"), false);
-  assert.equal(w.isOpen('team'), true, 'the row opens with its controls');
-  assert.equal(w.row('team').classList.contains('open'), true);
+  assert.equal(w.run('firstInvalidRow()'), 'team', 'Create\'s check names it');
+  w.done('team');
+  assert.equal(w.isOpen('team'), true, 'Done does not close a row whose answer fails');
   assert.equal(w.row('team').querySelector('[data-row-chg]').getAttribute('aria-expanded'), 'true');
-  assert.equal(w.state.confirmed.team, undefined);
 });
 
 // ── the Rewards row (question 6) ─────────────────────────────────────────────
@@ -376,14 +369,12 @@ test('rewards are hidden for a solo founder: the real table hides the row, and t
   const w = await onReview({ reward_intents: ['cash'] });
   assert.equal(w.run("rowApplies('rewards')"), false, 'the REAL softLimitsFor hides reward_intents for one-and-one');
   assert.equal(w.row('rewards').hidden, true, 'and the row goes with it');
-  assert.ok(!w.run('unconfirmedRows()').includes('rewards'), 'nothing to confirm for a question never asked');
-  assert.equal(w.run('unconfirmedRows()').length, 7, 'seven rows apply');
   assert.equal(w.run('createDetail()').reward_intents, undefined);
   w.change('team');
   w.q('[data-phys-solo="many"]')[0].click();
   await w.settle();
   assert.equal(w.row('rewards').hidden, false, 'a team brings the question back, once the table is asked again');
-  assert.equal(w.run('unconfirmedRows()').length, 8);
+  assert.equal(w.run("rowApplies('rewards')"), true);
 });
 
 test('rewards: a greyed option is disabled and leaves the list, and each reason is said once', async () => {
@@ -412,11 +403,9 @@ test('rewards: a greyed option is disabled and leaves the list, and each reason
 test('We run: hybrid and local open the suite pre-picked; managed and open source hide it with the table\'s reason', async () => {
   const w = await onReview({ builders_at_start: 3, builders_expected: 8, reward_intents: ['non-monetary'] });
   assert.deepEqual(w.rowSays('run'), ['Everything, for you', 'Hosting, payouts and the starter kit, managed.'], 'prefilled: all managed');
-  w.state.confirmed.app = true;
   w.change('run');
   w.pick('framing', 'hybrid');
   await w.settle();
-  assert.equal(w.state.confirmed.app, undefined, 'a new framing re-asks the App hosting row');
   assert.deepEqual(plain(w.a().services), ['hosting', 'starter-kit', 'marketplace-buy', 'guild-access'], 'the canvas\'s hybrid suite');
   assert.equal(w.$('physSuite').hidden, false);
   assert.equal(w.$('physSuiteLbl').textContent, 'Your hybrid suite');
@@ -439,7 +428,7 @@ test('We run: hybrid and local open the suite pre-picked; managed and open sourc
   assert.equal(w.run('createDetail()').services, undefined, 'all managed sends no suite');
   w.pick('framing', 'managed');
   assert.equal(w.a().framing, null, 'a second click un-says it');
-  assert.equal(w.run("rowValid('run')"), false, 'and a run row with no framing cannot be confirmed');
+  assert.equal(w.run("rowValid('run')"), false, 'and a run row with no framing cannot be filed');
 });
 
 test('a company already formed hides company creation from the suite', async () => {
@@ -450,14 +439,14 @@ test('a company already formed hides company creation from the suite', async ()
 });
 
 // ── fixed rows: the App hosting row on your own machines, and a demo's own answers ──
-test('a planet on its own machines fixes the App hosting row: it says so, confirms without the Render check, and never opens', async () => {
+test('a planet on its own machines fixes the Hosting row: it says so, files without the Render check, and never opens', async () => {
   for (const [framing, fixed] of [['managed', false], ['hybrid', false], ['local', true], ['open-source', true]]) {
     const w = await onReview({ framing }, { renderOk: false });
     assert.equal(w.run("rowFixed('app')"), fixed, framing);
     assert.equal(w.row('app').querySelector('[data-row-chg]').hidden, fixed, `${framing}: Change is ${fixed ? 'gone' : 'offered'}`);
-    assert.equal(w.run("confirmRow('app')"), fixed, `${framing}: ${fixed ? 'confirmed without' : 'held by'} the Render check`);
+    assert.equal(w.run("rowValid('app')"), fixed, `${framing}: ${fixed ? 'filed without' : 'held by'} the Render check`);
     if (fixed) assert.equal(w.rowSays('app')[0], 'Runs on your own machines');
-    else assert.equal(w.isOpen('app'), true, 'a failed check opens the row with its reason');
+    else assert.equal(w.run('firstInvalidRow()'), 'app', 'a failed check is what Create opens');
   }
   const demo = await onReview({ framing: 'local' }, { renderOk: false, draft: { demo: { people: 3, hours_each: 4 } } });
   assert.equal(demo.run("rowFixed('app')"), false, 'a demo is all managed, whatever framing a walk left behind');
@@ -476,35 +465,26 @@ test('a demo\'s team, rewards and run are the demo\'s own: fixed, said plainly,
   assert.deepEqual(w.rowSays('run'), ['Everything, for you', 'A demo is all managed and private to your team.']);
 });
 
-// ── confirming, and the locked Continue ──────────────────────────────────────
-test('one "Looks right, continue" confirms every row that applies, each through its own check (task 1004550)', async () => {
+// ── nothing to confirm (task 1004648: the summary wins) ─────────────────────
+test('no row needs confirming: the prefilled page is fileable as it stands, and the extras stay the server\'s suggestion', async () => {
   const w = await onReview({ builders_at_start: 3, builders_expected: 8 });
-  assert.equal(w.go().disabled, false, 'Continue is never locked: it is the confirmation');
-  assert.equal(w.go().textContent, 'Looks right, continue');
-  assert.equal(w.row('code').querySelector('[data-row-ok]'), null, 'no row carries a Looks right of its own');
-  assert.equal(w.run('unconfirmedRows()').length, 8, 'nothing is confirmed before the founder says so');
-  assert.equal(w.run('validateStep(4)'), true, 'one Continue confirms them all');
-  for (const key of ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run', 'ship']) assert.equal(w.state.confirmed[key], true, key);
-  assert.equal(w.state.modules && plain(w.state.modules).join(), 'discord', 'confirming the extras is the answer the create sends');
-  w.change('team');
-  assert.equal(w.state.confirmed.team, undefined, 'Edit takes a row back');
-  assert.equal(w.isOpen('team'), true);
-  assert.deepEqual(plain(w.run('unconfirmedRows()')), ['team']);
-  w.done('team');
-  assert.equal(w.isOpen('team'), false, 'Done closes it again');
-  assert.equal(w.state.confirmed.team, true, 'and Done is the answer');
+  assert.equal(w.run('firstInvalidRow()'), null, 'every row that applies can be filed as it stands');
+  for (const key of ['code', 'address', 'team', 'extras', 'rewards', 'app', 'run', 'ship', 'look']) {
+    assert.equal(w.row(key).querySelector('[data-row-chg]').textContent, 'Change', `${key}: one Change`);
+    assert.equal(w.isOpen(key), false, `${key}: closed`);
+  }
+  assert.equal(w.state.modules, null, 'the extras are never turned into an answer nobody gave: the server applies the same bundle');
+  assert.equal(w.q('#reviewGo').length, 0, 'there is no Continue to press');
+  assert.deepEqual(w.rowSays('look'), ['Chrome world', 'Add a logo later from the project page.'], 'the Look row says the look');
+  assert.equal(w.$('lookDot').style.background, '#fb9569', 'and wears its accent');
 });
 
-test('Continue stops on the first row that fails its check, opened with its reason, and confirms nothing past it', async () => {
+test('Create\'s check finds the first row that cannot be filed, in the page\'s order', async () => {
   const w = await onReview({ builders_at_start: 3, builders_expected: 8 });
   w.state.physics.answers.builders_at_start = 4; w.state.physics.answers.builders_expected = 2;   // fewer later than now
-  assert.equal(w.run('validateStep(4)'), false, 'Continue refuses');
-  assert.equal(w.isOpen('team'), true, 'the failing row opens');
-  assert.equal(w.state.confirmed.team, undefined);
-  assert.equal(w.state.confirmed.rewards, undefined, 'nothing after it is confirmed on the founder\'s behalf');
-  assert.equal(w.state.confirmed.code, true, 'the rows before it held, and stay confirmed');
-  assert.match(w.$('h-review').textContent, /Fix the row that’s open/);
-  assert.equal(w.$('h-review').className, 'hint err');
+  assert.equal(w.run('firstInvalidRow()'), 'team');
+  w.run('validateCode = function () { return false; }');
+  assert.equal(w.run('firstInvalidRow()'), 'code', 'the earliest row first');
 });
 
 test('opening a row closes another open one whose answer holds, and leaves one that fails open', async () => {
@@ -512,7 +492,7 @@ test('opening a row closes another open one whose answer holds, and leaves one t
   w.change('code');
   w.change('team');
   assert.equal(w.isOpen('code'), false, 'one row open at a time');
-  assert.equal(w.state.confirmed.code, true, 'closing it that way is the same as Done');
+  assert.equal(w.row('code').querySelector('[data-row-chg]').textContent, 'Change', 'closed that way, it reads Change again');
   w.state.physics.answers.builders_expected = 1;   // fewer later than now: the team row fails
   w.change('run');
   assert.equal(w.isOpen('team'), true, 'a row that fails its check stays open');
@@ -528,9 +508,9 @@ test('the prefills never overwrite a founder\'s own answer', () => {
   assert.deepEqual({ s: w.a().project_state, f: w.a().framing, n: [w.a().builders_at_start, w.a().builders_expected], t: w.state.teamShape },
     { s: 'existing', f: 'hybrid', n: [3, 9], t: 'community' });
   assert.equal(w.state.mode, 'adopt', 'a project that already has code adopts its repo');
-  w.state.mode = 'greenfield'; w.state.confirmed = { code: true };
+  w.state.mode = 'greenfield'; w.state.modeChosen = true;
   w.run('physDefaults()');
-  assert.equal(w.state.mode, 'greenfield', 'but never over a Code row the founder confirmed');
+  assert.equal(w.state.mode, 'greenfield', 'but never over a repo choice the founder made');
   for (const gone of ['physPrefill', 'typePrefill', 'homePrefill', 'physSummary', 'data-phys-goto', 'physStepSkipped', 'physPastSkips']) {
     assert.ok(!HUB.includes(gone), `${gone} is gone: the review shows every prefill as a row instead`);
   }
@@ -548,7 +528,7 @@ test('one plain voice for everyone: professional is stored for an organization a
   assert.doesNotMatch(HUB, /id="(physCoords|physCallout|physCapLbl)"/, 'the profile caption left with the forming planet');
 });
 
-test('the one voice carries no planet words on the checks and the review', () => {
+test('the one voice carries no planet words on parts 01 and 02', () => {
   const words = PANEL.replace(/<!--[\s\S]*?-->/g, '').replace(/<[^>]*>/g, ' ');
   assert.doesNotMatch(words, /\bplanet|\bmoons?\b|\borbit/i, 'the plain copy names no planet, moon or orbit');
 });
@@ -582,27 +562,22 @@ test('the forming planet is gone, and the room behind the wizard moves on CSS al
 });
 
 // ── the done-when, end to end ────────────────────────────────────────────────
-test('a new owner walks from the quick checks through a fully confirmed review, the setup prefilled', async () => {
-  const w = boot({ draft: { step: 3, description: 'An inventory tool our team started last year.' } });
-  w.run('paintChecks()');
+test('a new owner walks the page from the quick checks through the rows they change, the rest prefilled', async () => {
+  const w = boot({ draft: { description: 'An inventory tool our team started last year.' } });
+  w.run('physDefaults(); paintChecks(); paintSetup();');
   w.$('physCountry').value = 'US'; w.$('physCountry').listeners.change();
   w.$('physRegion').value = 'US-NY'; w.$('physRegion').listeners.change();
   w.pick('builder_geography', 'global');
   w.pick('minors_on_board', 'false');
   w.$('physHaveEntity').click();
   w.pick('entity', 'for-profit');           // a company already formed, so equity is on the table
-  w.run('checksAdvance()');
   await w.settle();
-  assert.deepEqual(w.shown, [4], 'the review');
   w.run('paintSetup()');
   assert.equal(w.row('rewards').hidden, true, 'one person: no rewards row');
-  w.ok('code'); w.ok('address'); w.ok('app'); w.ok('extras');
   w.change('team');
   w.q('[data-phys-solo="many"]')[0].click();
   w.done('team');
   await w.settle();
-  assert.equal(w.state.confirmed.extras, undefined, 'the team moved the extras\' preselect, so that row is asked again');
-  w.ok('extras');
   assert.equal(w.row('rewards').hidden, false);
   w.change('rewards');
   w.pick('reward_intents', 'cash');
@@ -612,34 +587,24 @@ test('a new owner walks from the quick checks through a fully confirmed review,
   w.pick('framing', 'open-source');
   await w.settle();
   w.done('run');
-  assert.equal(w.state.confirmed.app, undefined, 'the framing moved the App hosting row');
-  assert.equal(w.rowSays('app')[0], 'Runs on your own machines');
-  assert.equal(w.run('validateStep(4)'), true, 'one Continue confirms the rest');
-  assert.equal(w.state.confirmed.app, true);
+  assert.equal(w.rowSays('app')[0], 'Runs on your own machines', 'the framing moved the Hosting row');
+  assert.equal(w.run('firstInvalidRow()'), null, 'and the page can be filed as it stands');
   const d = plain(w.run('createDetail()'));
   assert.deepEqual({ voice: d.voice, framing: d.framing, services: d.services, team: [d.builders_at_start, d.builders_expected], shape: d.team_shape, rewards: d.reward_intents },
     { voice: 'professional', framing: 'open-source', services: undefined, team: [2, 5], shape: 'small-team', rewards: ['cash', 'equity'] });
 });
 
 // ── the address is the founder's own choice, on every path (task 1004507, BV2.PS19) ──
-test('no path reaches Look without the founder confirming the address: a prefill suggests it, never confirms it', async () => {
+test('the address is on every path, the demo\'s too: never a fixed row, always changeable, and an address that cannot be filed holds Create', async () => {
   for (const draft of [{}, { demo: { people: 3, hours_each: 4, idea: '', invites: [] } }]) {
     const label = draft.demo ? 'demo' : 'real project';
     const w = await onReview({}, { draft });
-    assert.equal(w.state.confirmed.address, undefined, `${label}: the prefills leave the address unconfirmed`);
+    assert.equal(w.row('address').hidden, false, `${label}: the address row shows`);
     assert.equal(w.run("rowFixed('address')"), false, `${label}: the address is never a fixed row`);
     assert.equal(w.row('address').querySelector('[data-row-chg]').hidden, false, `${label}: it can always be changed`);
-    for (const key of ['code', 'app', 'extras', 'team', 'rewards', 'run', 'ship']) if (w.run(`rowApplies('${key}')`)) w.ok(key);
-    assert.deepEqual(plain(w.run('unconfirmedRows()')), ['address'], `${label}: every other row confirmed, the address still asked`);
-    // the address is on the page the founder confirms (task 1004550): only their own
-    // "Looks right, continue" — or Done on the row — confirms it, and its check still runs
     w.run('validateAddress = function () { return false; }');
-    assert.equal(w.run('validateStep(4)'), false, `${label}: an address that fails its check refuses Continue`);
-    assert.equal(w.isOpen('address'), true, `${label}: and opens the address row`);
-    assert.equal(w.state.confirmed.address, undefined, `${label}: still unconfirmed`);
+    assert.equal(w.run('firstInvalidRow()'), 'address', `${label}: an address that fails its check is what Create opens`);
     w.run('validateAddress = function () { return true; }');
-    w.done('address');
-    assert.equal(w.state.confirmed.address, true, `${label}: choosing it is the answer`);
-    assert.equal(w.run('validateStep(4)'), true, `${label}: then Continue goes on`);
+    assert.equal(w.run('firstInvalidRow()'), null, `${label}: then Create goes on`);
   }
 });

package/tests/wizard_ship_mode.mjs

@@ -40,7 +40,7 @@ function slice(start, end, what) {
 // ── 1. the wizard ──────────────────────────────────────────────────────────
 
 test('the review asks how finished work ships: Auto (recommended) first and checked, Manual second', () => {
-  const row = slice('<div class="setRow" data-row="ship">', '<div class="hint" id="h-review">', 'the ship row');
+  const row = slice('<div class="setRow" data-row="ship">', '<div class="setRow" data-row="look">', 'the ship row');
   const auto = row.indexOf('value="auto"'), manual = row.indexOf('value="manual"');
   assert.ok(auto > 0 && manual > auto, 'Auto comes first');
   assert.match(row, /<input type="radio" name="shipMode" value="auto" checked>/, 'and is the pick until the founder says otherwise');

package/tests/wizard_six_screens.mjs

@@ -1,129 +0,0 @@
-// tests/wizard_six_screens.mjs — the blended create wizard (task 1004504, BV2.PS16; goal 1000121).
-//
-// The design of record is docs/design/mocks/combined-onboarding/index.html (the owner approved it
-// as drawn, 2026-10-01): six screens and the done panel, in this order — sign in, demo or real
-// (the terms as its one tick), what are you making, a few quick checks, check what we set up,
-// give it a look → Create, done — with the mockup's own words, no progress rail, and a review
-// that cannot be skipped: every prefilled answer is a row the founder confirms or changes, and
-// Continue stays locked until all of them are confirmed.
-//
-// This file pins the shape and the words statically. The rows' behaviour is executed by
-// tests/wizard_physics_more.mjs (the controller under a DOM stub) and walked end to end by the
-// kit probes in projects.probes.json; the night room's tokens and motion by tests/projects_hub.mjs.
-//
-// Run:  node --test tests/wizard_six_screens.mjs
-
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const HUB = fs.readFileSync(path.join(ROOT, 'modules', 'public-landing', 'public', 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
-const SCRIPT = HUB.slice(HUB.lastIndexOf('<script>'), HUB.lastIndexOf('</script>'));
-const VIEW = (HUB.match(/<section id="view-new" hidden>[\s\S]*?\n<\/section>/) || [''])[0];
-const MOCK = fs.readFileSync(path.join(ROOT, 'docs', 'design', 'mocks', 'combined-onboarding', 'index.html'), 'utf8').replace(/\r\n/g, '\n');
-const panel = (id) => (VIEW.match(new RegExp(`<section class="panel[^"]*" id="${id}"[\\s\\S]*?\\n {10}</section>`)) || [''])[0];
-
-const ORDER = ['panel-gate', 'panel-fork', 'panel-what', 'panel-checks', 'panel-review', 'panel-look', 'panel-done'];
-
-test('six screens and the done panel, in the design of record\'s order, in the markup and in the controller\'s map', () => {
-  assert.ok(VIEW, 'the ?view=new section is found');
-  const inMarkup = [...VIEW.matchAll(/<section class="panel[^"]*" id="(panel-[a-z]+)"/g)].map((m) => m[1]);
-  assert.deepEqual(inMarkup, ORDER, 'the panels appear in this order and there are no others');
-  const map = (SCRIPT.match(/var panels = \{([^}]*)\}/) || [, ''])[1];
-  const fromMap = [...map.matchAll(/(\d+):\s*'(panel-[a-z]+)'/g)].map((m) => [Number(m[1]), m[2]]);
-  assert.deepEqual(fromMap, ORDER.map((id, i) => [i, id]), 'the controller numbers them 0–6 in the same order');
-  assert.match(SCRIPT, /var DRAFT_KEY = 'cb-create-draft-v9';/, 'a renumbering bumps the draft key, so an older draft is ignored rather than replayed onto the wrong screen');
-});
-
-test('the old screens and the progress rails are gone', () => {
-  for (const id of ['panel-terms', 'panel-physics', 'panel-name', 'panel-type', 'panel-detail', 'panel-modules', 'panel-home', 'panel-address', 'panel-app']) {
-    assert.doesNotMatch(HUB, new RegExp(`id="${id}"`), `${id} folded into the six screens`);
-  }
-  assert.doesNotMatch(VIEW, /class="steps"|id="physRail"|data-step=/, 'no progress rail, outer or inner');
-  assert.doesNotMatch(SCRIPT, /function paintRail\(|function physNextQ\(|function physPaintStage\(/, 'nor the code that painted them');
-  assert.doesNotMatch(VIEW, /id="physStage"|id="forkStage"|class="bongoCell"|class="bongos"/, 'the forming planet, the plate and the drums give way to the night room');
-  assert.match(VIEW, /<div class="wizTop">\s*<span class="wizEyebrow" id="wizEyebrow">New project<\/span>\s*<button type="button" class="wizBack" id="wizBack" hidden>← Back<\/button>/,
-    'one eyebrow names the screen and one Back walks backwards');
-});
-
-test('each screen opens with the mockup\'s own words', () => {
-  const pairs = [
-    ['panel-gate', 'Make something.', 'Sign in with GitHub to start your project.'],
-    ['panel-fork', 'You’re about to start a digital planet.', 'Try a small demo first, or start your real project.'],
-    ['panel-what', 'What are you making?', null],
-    ['panel-checks', 'A few quick checks.', 'These decide which legal and payout options we can offer.'],
-    ['panel-review', 'Check what we set up.', 'We filled these in from your answers. Change anything that’s wrong.'],
-    ['panel-look', 'Give it a look.', 'So builders always know which project they’re in.'],
-  ];
-  for (const [id, h, lede] of pairs) {
-    const p = panel(id);
-    assert.ok(p, `${id} is found`);
-    const mockLine = h.replace(/’/g, '(’|\'|&rsquo;)');
-    assert.match(MOCK, new RegExp(mockLine.replace(/[.?]/g, '\\$&')), `"${h}" is the mockup's own headline`);
-    assert.match(p, new RegExp(`<h1 id="[a-z-]+h[0-9]?"?[^>]*>${h.replace(/[.?]/g, '\\$&')}`), `${id} opens "${h}"`);
-    if (lede) assert.match(p, new RegExp(`<p class="lede">${lede.replace(/[.?]/g, '\\$&')}</p>`), `${id}'s one line`);
-  }
-  assert.match(panel('panel-gate'), /Continue with GitHub/, 'the gate\'s door');
-  assert.match(panel('panel-fork'), /<button type="submit" class="btn big" id="wizStart" disabled>Start my project<\/button>/);
-  assert.match(panel('panel-fork'), /id="wizDemo"[^>]*disabled>Try the demo<\/button>/, 'both doors wait for the terms tick');
-  assert.match(panel('panel-fork'), /I can sign for this project, and I accept the <a class="termsRead" href="\/terms"/, 'the terms are one tick on the fork, with the terms one click away');
-  assert.match(panel('panel-what'), /<span>Name<\/span>[\s\S]*<span id="typeLbl">Kind<\/span>[\s\S]*In a sentence <small>\(optional — puts it on the public map\)<\/small>/, 'name, kind, one optional sentence');
-});
-
-test('planet words survive only as the light touch: the fork and the alive moment', () => {
-  const words = VIEW.replace(/<!--[\s\S]*?-->/g, '').replace(/<[^>]+>/g, ' ');
-  const planets = words.match(/planet/gi) || [];
-  assert.equal(planets.length, 1, 'one planet in the whole view: the fork\'s headline');
-  assert.match(SCRIPT, /\(state\.name \|\| state\.slug \|\| 'Your project'\) \+ ' is alive\.'/, 'the alive moment');
-  assert.match(SCRIPT, /if \(inst\.last_verified_up\) \{\n\s*\/\*[^*]*\*\/\n\s*\$\('done-h'\)\.textContent =/, 'said only once the project has answered (Live is a verified claim)');
-});
-
-test('the review cannot be skipped: eight rows, one Edit each, and one Continue that confirms them all (task 1004550)', () => {
-  const p = panel('panel-review');
-  const rows = [...p.matchAll(/<div class="setRow" data-row="([a-z]+)">/g)].map((m) => m[1]);
-  assert.deepEqual(rows, ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run', 'ship']);
-  for (const key of rows) {
-    const r = (p.match(new RegExp(`<div class="setRow" data-row="${key}">[\\s\\S]*?<span class="acts">[^\\n]*\\n`)) || [''])[0];
-    assert.match(r, /<span class="acts"><button type="button" class="rowChg" data-row-chg aria-expanded="false">Edit<\/button><\/span>/, `${key}: one Edit, nothing else`);
-    assert.match(r, /<div class="opts" hidden>/, `${key}: Edit opens the row's own controls`);
-  }
-  assert.doesNotMatch(p, /data-row-ok|data-row-use|Use this/, 'no per-row Looks right and no Use this are left');
-  assert.match(p, /<button type="submit" class="btn" id="reviewGo">Looks right, continue<\/button>/, 'Continue is the one confirmation, never locked');
-  assert.match(SCRIPT, /if \(step === 4\) return confirmAllRows\(\);/, 'Continue confirms every row through its own check');
-  assert.match(SCRIPT, /if \(!confirmRow\(rows\[i\]\)\) \{/, 'and stops on the first that fails');
-  assert.match(SCRIPT, /if \(unconfirmedRows\(\)\.length\) \{ reopenReview\(\); return; \}/, 'and Create refuses until every row is confirmed');
-  assert.match(SCRIPT, /chg\.textContent = 'Done';/, 'an open row\'s control reads Done');
-});
-
-test('nothing the old steps could do is lost: their controls are moved whole into the rows', () => {
-  const p = panel('panel-review');
-  const has = (row, ids) => {
-    const r = (p.match(new RegExp(`<div class="setRow" data-row="${row}">[\\s\\S]*?\\n {16}</div>\\n`)) || [''])[0];
-    for (const id of ids) assert.match(r, new RegExp(`id="${id}"`), `${row} row hosts #${id}`);
-  };
-  has('code', ['physExisting', 'c-green', 'c-adopt', 'adoptNote', 'ghNoAccess', 'ghAdopt', 'ghFresh', 'manualHome', 'h-home']);
-  has('address', ['f-slug', 'addrConfirm', 'addrCustom', 'f-domain', 'f-noaddr']);
-  has('app', ['appOpts', 'renderLater', 'renderSetup', 'f-renderKey', 'renderWs', 'renderSvc', 'renderNew']);
-  has('extras', ['modQ', 'modCards', 'modWhy', 'modCoreNote']);
-  has('team', ['physTeam', 'physStartN', 'physExpected', 'teamCards']);
-  has('run', ['physSuite']);
-  has('ship', ['shipOpts']);
-  for (const id of ['physCountry', 'physRegion', 'physAges', 'physIntent', 'physForms', 'physHaveEntity', 'checksStop', 'physStopMsg', 'physFromAccount']) {
-    assert.match(panel('panel-checks'), new RegExp(`id="${id}"`), `the quick checks host #${id}`);
-  }
-  for (const id of ['demoSetup', 'demoIdea', 'demoInvites', 'demoStart', 'wizResume']) {
-    assert.match(panel('panel-fork'), new RegExp(`id="${id}"`), `the fork hosts #${id}`);
-  }
-  for (const id of ['wizLook', 'wizRecap', 'createAlert', 'doCreate']) {
-    assert.match(panel('panel-look'), new RegExp(`id="${id}"`), `the look screen hosts #${id}`);
-  }
-  /* two answers moved across screens, so two old guarantees are re-pinned where they live now */
-  assert.match(SCRIPT, /function renderNow\(\) \{ return !appSkipped\(\) && /, 'a framing on the founder\'s own machines rules Render out at Create, whatever was picked before');
-  assert.match(SCRIPT, /function renderLater\(\) \{ return !appSkipped\(\) && /);
-  assert.match(SCRIPT, /if \(key === 'extras' && starterBundles\) state\.modules = pickedModules\(\);/, 'confirming the extras before the catalog lands files no answer, never an empty list');
-  const ids = [...VIEW.matchAll(/\sid="([^"]+)"/g)].map((m) => m[1]);
-  assert.deepEqual(ids.filter((id, i) => ids.indexOf(id) !== i), [], 'moved, never copied: every id in the view is unique');
-});