@bongos/core 1.20.76 → 1.20.77

package/tests/wizard_physics_more.mjs

@@ -0,0 +1,470 @@
+// tests/wizard_physics_more.mjs — planet physics, questions 5 to 7, the summary, the
+// voice split and the pre-filled technical steps (task 1004419 / BV2.PS11, goal 1000121).
+//
+// Done-when: a new owner walks from question 1 to "create my planet" with the technical
+// steps pre-filled. So the walk below is RUN end to end — the page's own physics
+// controller sliced out of projects.html into a vm under a DOM stub (the
+// tests/wizard_physics.mjs idiom), its pre-create check answered by the REAL soft-limit
+// table (modules/provisioning/soft-limits.js), never a hand-written verdict. The rest
+// pins each rule on its own: rewards hidden when solo, the framing's suite and its
+// reasons, the voice chosen from the entity (spec D5), the summary's change links, what
+// the create sends, which technical step is skipped, and the forming planet.
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const physics = require('../modules/provisioning/planet-physics.js');
+const { SOFT_LIMIT_RULES, softLimitsFor } = require('../modules/provisioning/soft-limits.js');
+
+const START = '/* ── planet physics, questions 1 to 7 (tasks 1004418 and 1004419, BV2.PS07 + PS11) ──';
+const SCRIPT = HUB.slice(HUB.indexOf(START), HUB.indexOf('    /* per-panel validation on Next */'));
+const PANEL = HUB.slice(HUB.indexOf('<section class="panel" id="panel-physics"'), HUB.indexOf('<!-- step 4 · name'));
+const plain = (v) => JSON.parse(JSON.stringify(v)); // values born in the vm
+
+// ── a small DOM: the panel's own elements, matched by attribute ──────────────
+class El {
+  constructor(tag, attrs = {}) {
+    this.tagName = tag; this.attrs = { ...attrs }; this.hidden = 'hidden' in attrs; this.disabled = false;
+    this.value = attrs.value || ''; this.textContent = ''; this.title = ''; this.className = attrs.class || '';
+    this.listeners = {}; this.children = []; this.options = [{}];
+    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), add: (c) => self.classes.add(c) };
+  }
+  setAttribute(k, v) { this.attrs[k] = String(v); }
+  getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; }
+  removeAttribute(k) { delete this.attrs[k]; }
+  addEventListener(t, fn) { this.listeners[t] = fn; }
+  click() { this.listeners.click && this.listeners.click({ target: this }); }
+  appendChild(c) { this.children.push(c); if (this.tagName === 'select') this.options.push(c); return c; }
+  removeChild(c) { const i = this.children.indexOf(c); if (i !== -1) this.children.splice(i, 1); if (this.tagName === 'select') this.options.pop(); }
+  get firstChild() { return this.children[0] || null; }
+  get lastChild() { return this.tagName === 'select' ? this.options[this.options.length - 1] : this.children[this.children.length - 1]; }
+  focus() {}
+  text() { return this.textContent + this.children.map((c) => c.text()).join(''); }
+}
+
+function parseAttrs(s) {
+  const out = {};
+  for (const m of s.matchAll(/([a-zA-Z-]+)(?:="([^"]*)")?/g)) out[m[1]] = m[2] === undefined ? '' : m[2];
+  return out;
+}
+function buildDom() {
+  const all = [];
+  const byId = {};
+  for (const m of PANEL.matchAll(/<(button|div|p|ul|fieldset|span|li|img|input|select|output|dd|legend|h1|ol|dl|form|label)\b([^>]*)>/g)) {
+    const el = new El(m[1], parseAttrs(m[2]));
+    all.push(el);
+    if (el.attrs.id) byId[el.attrs.id] = el;
+  }
+  // the stage's moons and ghosts are the children of their wrappers, in markup order
+  const kids = (id) => {
+    const at = PANEL.indexOf(`id="${id}"`);
+    const chunk = PANEL.slice(at, PANEL.indexOf('</span>', at));
+    const n = (chunk.match(/<img /g) || []).length;
+    return all.filter((e) => e.tagName === 'img' && e.attrs.src && e.attrs.src.includes('bead')).slice(id === 'physGhosts' ? 0 : 4, id === 'physGhosts' ? n : 4 + n);
+  };
+  const lists = { '#physMoons img': kids('physMoons'), '#physGhosts img': kids('physGhosts') };
+  lists['#physMoons img, #physGhosts img'] = [...lists['#physMoons img'], ...lists['#physGhosts img']];
+  const matches = (el, compound) => {
+    if (compound.startsWith('.')) return el.classes.has(compound.slice(1));
+    for (const m of compound.matchAll(/\[([a-z-]+)(?:="([^"]*)")?\]/g)) {
+      if (!(m[1] in el.attrs)) return false;
+      if (m[2] !== undefined && el.attrs[m[1]] !== m[2]) return false;
+    }
+    return /\[/.test(compound);
+  };
+  const root = {
+    querySelectorAll(sel) {
+      if (lists[sel]) return lists[sel];
+      if (sel === '#physRail li') return all.filter((e) => e.tagName === 'li' && 'data-q' in e.attrs);
+      if (sel === '#physStage .physBelt') return all.filter((e) => e.classes.has('physBelt'));
+      if (sel === '#panel-physics .physQ') return all.filter((e) => e.classes.has('physQ'));
+      const last = sel.trim().split(/\s+/).pop();
+      return all.filter((e) => matches(e, last));
+    },
+    querySelector(sel) { return this.querySelectorAll(sel)[0] || null; },
+  };
+  return { all, byId, root };
+}
+
+// the pre-create check, answered by the real table
+function boot({ check = (body) => ({ stop: false, soft_limits: softLimitsFor(body.detail) }), draft = {} } = {}) {
+  const dom = buildDom();
+  const els = { ...dom.byId };
+  const $ = (id) => (els[id] = els[id] || new El('div', { id }));
+  const shown = [];
+  const fetched = [];
+  const state = Object.assign({ description: '', teamShape: null, physics: null, projType: null, mode: 'greenfield', appPlatform: 'later', demo: null }, draft);
+  const sandbox = {
+    $, state, API: '/api/bongos', root: dom.root, Intl,
+    document: { createElement: (t) => new El(t) },
+    saveDraft() {}, show(n) { shown.push(n); },
+    fetch: async (url, opts) => {
+      const body = opts && opts.body ? JSON.parse(opts.body) : null;
+      fetched.push({ url, body });
+      return { ok: true, json: async () => (url.includes('physics-check') ? check(body) : []) };
+    },
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(SCRIPT, sandbox, { filename: 'projects.html#physics' });
+  const q = (sel) => dom.root.querySelectorAll(sel);
+  return {
+    state, $, shown, fetched, q, dom,
+    run: (code) => vm.runInContext(code, sandbox),
+    a: () => state.physics.answers,
+    pick: (key, val) => q(`[data-phys="${key}"][data-val="${val}"]`)[0].click(),
+    next: async () => { sandbox.$('physNext'); vm.runInContext('physAdvance()', sandbox); await tick(); await tick(); },
+  };
+}
+const tick = () => new Promise((r) => setTimeout(r, 0));
+// questions 1 to 4, answered (the Kestrel sample of the canvas, a new planet)
+const FOUR = { project_state: 'new', home_country: 'US', home_region: 'US-CA', builder_geography: 'us-eu', minors_on_board: false, entity: 'intent-solo' };
+function at(q, answers = FOUR, opts = {}) {
+  const w = boot(opts);
+  w.run('phys()');
+  Object.assign(w.state.physics.answers, answers);
+  w.run(`physGo(${JSON.stringify(q)})`);
+  return w;
+}
+
+// ── the copies are the server's ──────────────────────────────────────────────
+test('the page carries the server\'s rewards, framings and services, in order, and says every one', () => {
+  const box = {};
+  vm.createContext(box);
+  vm.runInContext(SCRIPT.slice(0, SCRIPT.indexOf('    var PHYS_LAST')).replace(/\bvar /g, 'this.'), box);
+  const Q = physics.PLANET_PHYSICS_QUESTIONS;
+  assert.deepEqual(plain(box.PHYS_REWARDS), [...Q.reward_intents.values]);
+  assert.deepEqual(plain(box.PHYS_FRAMINGS), [...Q.framing.values]);
+  assert.deepEqual(plain(box.PHYS_SERVICES), [...Q.services.values]);
+  assert.deepEqual(Object.keys(box.PHYS_ORBIT), [...Q.framing.values]);
+  for (const key of ['project_state', 'builder_geography', 'entity', 'reward_intents', 'framing', 'services']) {
+    assert.deepEqual(Object.keys(box.PHYS_SAY[key]).sort(), [...Q[key].values].sort(), `the summary can say every ${key}`);
+  }
+  for (const org of box.PHYS_ORGS) assert.ok(physics.ENTITY_FORMS.includes(org), `${org} is a formed entity`);
+  for (const [f, list] of Object.entries(box.PHYS_SUITE_START)) {
+    assert.ok(['hybrid', 'local'].includes(f));
+    assert.notEqual(physics.canonicalAnswer(Q.services, plain(list)), undefined, `${f}'s starting suite is a services answer`);
+  }
+  const TYPES = ['game', 'research', 'business', 'non-profit', 'not-sure'];
+  for (const [entity, type] of Object.entries(box.PHYS_TYPE)) {
+    assert.ok(Q.entity.values.includes(entity)); assert.ok(TYPES.includes(type), `${type} is a project type`);
+  }
+});
+
+test('the kit stub\'s physics hide rules are the table\'s own, word for word', () => {
+  const stub = fs.readFileSync(path.join(ROOT, 'modules', 'ui-design', 'kit', 'serve.js'), 'utf8');
+  const block = stub.slice(stub.indexOf('const STUB_PHYSICS_HIDES'), stub.indexOf('function readBody'));
+  const ids = [...block.matchAll(/id: '([a-z-]+)'/g)].map((m) => m[1]);
+  assert.equal(ids.length, 3);
+  for (const id of ids) {
+    const rule = SOFT_LIMIT_RULES.find((r) => r.id === id);
+    assert.ok(rule, `${id} is a real rule`);
+    assert.equal(rule.effect, 'hide');
+    assert.ok(block.includes(JSON.stringify(rule.reason).slice(1, -1)) || block.includes(rule.reason), `${id}'s reason is copied exactly`);
+  }
+});
+
+// ── question 5 ───────────────────────────────────────────────────────────────
+test('question 5: one or many, a start count, and a guessed growth the founder corrects', async () => {
+  const w = at(5);
+  await w.next();
+  assert.equal(w.state.physics.q, 5, 'unanswered: it stays');
+  assert.match(w.$('h-phys').textContent, /one or many/);
+  w.q('[data-phys-solo="many"]')[0].click();
+  assert.equal(w.a().builders_at_start, 2);
+  assert.equal(w.a().builders_expected, 5, 'the guess: about 2.6 times the start');
+  assert.equal(w.$('physTeam').hidden, false);
+  w.q('[data-phys-count="1"]')[0].click();
+  assert.equal(w.a().builders_at_start, 3);
+  assert.equal(w.a().builders_expected, 8, 'the guess follows the start');
+  assert.deepEqual([w.$('physM1').textContent, w.$('physM2').textContent, w.$('physM3').textContent], ['3', '5', '8'], 'the canvas\'s three months');
+  assert.match(w.$('physGuessLine').textContent, /about 8 builders by month three/);
+  w.$('physExpected').value = '12';
+  w.$('physExpected').listeners.input();
+  assert.equal(w.a().builders_expected, 12, 'the founder corrects it');
+  w.q('[data-phys-count="1"]')[0].click();
+  assert.equal(w.a().builders_expected, 12, 'and once corrected the guess stays theirs');
+  assert.equal(w.q('[data-phys-solo="many"]')[0].getAttribute('aria-pressed'), 'true');
+  await w.next();
+  assert.equal(w.state.physics.q, 6, 'a team goes on to rewards');
+});
+
+test('rewards are hidden when solo: the table says so, the walk skips question 6, the create sends none', async () => {
+  const w = at(5, { ...FOUR, reward_intents: ['cash'] });
+  w.q('[data-phys-solo="one"]')[0].click();
+  assert.equal(w.a().builders_at_start, 1);
+  assert.equal(w.a().builders_expected, 1);
+  assert.equal(w.$('physTeam').hidden, true);
+  await w.next();
+  assert.equal(w.state.physics.q, 7, 'straight to framing');
+  assert.ok(w.fetched.at(-1).body.detail.builders_at_start === 1, 'the check was asked with the answer');
+  const rail6 = w.q('#physRail li').find((li) => li.attrs['data-q'] === '6');
+  assert.ok(rail6.classList.contains('skipped'), 'the rail strikes it');
+  assert.equal(w.run('createDetail()').reward_intents, undefined, 'nothing answered for a question never asked');
+  w.$('physBack').listeners.click();
+  assert.equal(w.state.physics.q, 5, 'Back steps over it too');
+});
+
+test('rewards: a greyed option is disabled and leaves the list, and each reason is said once', async () => {
+  const w = at(6, { ...FOUR, minors_on_board: true, builders_at_start: 3, builders_expected: 8 });
+  await w.run('physCheck()').then((res) => { w.run(`physLimits = ${JSON.stringify(res.soft_limits.limits)}`); });
+  w.pick('reward_intents', 'non-monetary');
+  w.pick('reward_intents', 'future-payouts');
+  assert.deepEqual(plain(w.a().reward_intents), ['non-monetary', 'future-payouts']);
+  const equity = w.q('[data-phys="reward_intents"][data-val="equity"]')[0];
+  assert.equal(equity.disabled, true, 'equity is off until you form a company');
+  assert.match(equity.title, /until you form a company/);
+  const list = w.q('[data-why-list="reward_intents"]')[0];
+  assert.equal(list.hidden, false);
+  const lines = list.children.map((li) => li.textContent);
+  assert.ok(lines.some((l) => /^Equity or shares: Equity is off until you form a company/.test(l)), lines.join('\n'));
+  assert.equal(lines.filter((l) => /13 to 15/.test(l)).length, 1, 'the minors reason names its three options in one line');
+  assert.ok(lines.some((l) => /^Cash for work, Equity or shares, Future profits or payouts: Builders aged 13 to 15/.test(l)));
+  assert.ok(lines.some((l) => /^Cash for work: Cash payouts to builders in the EU/.test(l)), 'a note is said too');
+  w.pick('reward_intents', 'future-payouts');
+  assert.deepEqual(plain(w.a().reward_intents), ['non-monetary'], 'a second click takes one away');
+  await w.next();
+  assert.equal(w.state.physics.q, 7);
+});
+
+// ── question 7 ───────────────────────────────────────────────────────────────
+test('framing: hybrid and local open the suite pre-picked; managed and open source hide it with the table\'s reason', async () => {
+  const w = at(7, { ...FOUR, builders_at_start: 3, builders_expected: 8, reward_intents: ['non-monetary'] });
+  await w.next();
+  assert.equal(w.state.physics.q, 7, 'no framing: it stays');
+  w.pick('framing', 'hybrid');
+  await tick(); await tick();
+  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');
+  const labor = w.q('[data-phys="services"][data-val="labor-payment"]')[0];
+  assert.equal(labor.disabled, true, 'no cash for work, no pay to run');
+  assert.equal(w.q('[data-phys="services"][data-val="public-marketing"]')[0].disabled, true, 'on request');
+  w.pick('services', 'marketplace-sell');
+  assert.ok(w.a().services.includes('marketplace-sell'));
+  w.pick('framing', 'local');
+  await tick(); await tick();
+  assert.ok(w.a().services.includes('marketplace-sell'), 'a suite the founder touched is theirs: not re-seeded');
+  w.pick('framing', 'managed');
+  await tick(); await tick();
+  assert.equal(w.$('physSuite').hidden, true);
+  const why = w.q('[data-why="services"]')[0];
+  assert.equal(why.hidden, false);
+  assert.equal(why.textContent, SOFT_LIMIT_RULES.find((r) => r.id === 'managed-includes-every-service').reason);
+  assert.equal(w.run('createDetail()').services, undefined, 'all managed sends no suite');
+  assert.equal(w.$('physStage').getAttribute('data-orbit'), 'near');
+  await w.next();
+  assert.equal(w.state.physics.q, 'sum');
+});
+
+test('a company already formed hides company creation from the suite', async () => {
+  const w = at(7, { ...FOUR, entity: 'for-profit', builders_at_start: 3, builders_expected: 8, reward_intents: ['equity'] });
+  w.pick('framing', 'hybrid');
+  await tick(); await tick();
+  assert.equal(w.q('[data-phys="services"][data-val="company-creation"]')[0].hidden, true);
+});
+
+// ── the voice (spec D5) ──────────────────────────────────────────────────────
+test('the voice is chosen from the entity: professional for an organization, the planet\'s for everyone else', () => {
+  for (const [entity, voice] of [['for-profit', 'professional'], ['nonprofit', 'professional'], ['research', 'professional'], ['corporate-division', 'professional'],
+    ['intent-company', 'planet'], ['intent-solo', 'planet'], ['social-group', 'planet'], ['university-project', 'planet'], ['private-individual', 'planet'], ['single-owner-llc', 'planet']]) {
+    const w = at(5, { ...FOUR, entity });
+    assert.equal(w.run('physVoice()'), voice, entity);
+    assert.equal(w.run('createDetail()').voice, voice, `${entity} stores the voice it reads`);
+    const pro = w.q('[data-voice="pro"]'), planet = w.q('[data-voice="planet"]');
+    assert.ok(pro.length >= 10 && planet.length === pro.length, 'both variants are baked, pair by pair');
+    assert.ok(pro.every((e) => e.hidden === (voice !== 'professional')), `${entity}: the professional copy shows only for an organization`);
+    assert.ok(planet.every((e) => e.hidden === (voice === 'professional')), `${entity}: the planet copy otherwise`);
+  }
+  const pro = at(5, { ...FOUR, entity: 'for-profit', builders_at_start: 12, builders_expected: 30 });
+  assert.match(pro.$('physGuessLine').textContent, /we estimate 30 contributors by month three/);
+  assert.equal(pro.$('physCapLbl').textContent, 'project profile');
+  assert.match(pro.$('physCoords').textContent, /team 12 → 30/);
+  const planet = at(5, { ...FOUR, builders_at_start: 3, builders_expected: 8 });
+  assert.match(planet.$('physCallout').textContent, /moons · 3 builders now · the dashed orbit holds about 8/);
+});
+
+test('the voice variants are worded apart: the professional copy carries no planet words', () => {
+  const pro = [...PANEL.matchAll(/<span data-voice="pro" hidden>([^<]*)/g)].map((m) => m[1]);
+  assert.ok(pro.length >= 10);
+  for (const t of pro) assert.doesNotMatch(t, /planet|moon|orbit/i, t);
+});
+
+// ── the summary ──────────────────────────────────────────────────────────────
+const SEVEN = { ...FOUR, builders_at_start: 3, builders_expected: 8, reward_intents: ['non-monetary', 'future-payouts'], framing: 'hybrid', services: ['hosting', 'starter-kit'] };
+test('the summary lists every answer with a change link back to its question', async () => {
+  const w = at('sum', SEVEN);
+  w.state.description = 'A field guide app for birdwatchers';
+  w.run('paintPhysics()');
+  const dl = w.$('physSummary');
+  const dts = dl.children.filter((c) => c.tagName === 'dt').map((c) => c.textContent);
+  assert.deepEqual(dts, ['State', 'Geography', 'Under 18', 'You are', 'Builders', 'Rewards', 'Framing']);
+  const dds = dl.children.filter((c) => c.tagName === 'dd');
+  const said = dds.map((dd) => dd.children[0].text());
+  assert.match(said[0], /^NewA field guide app for birdwatchers$/);
+  assert.match(said[1], /^United States \(California\)Builders in the US and EU$/);
+  assert.match(said[4], /^3 nowAbout 8 by month three$/);
+  assert.match(said[5], /^Non-monetary, Future profits or payoutsIntent only$/);
+  assert.match(said[6], /^HybridHosting, Starting module kit$/);
+  const gotos = dds.map((dd) => dd.children[1]);
+  assert.deepEqual(gotos.map((b) => b.getAttribute('data-phys-goto')), ['1', '2', '3', '4', '5', '6', '7']);
+  assert.ok(gotos.every((b) => b.textContent === 'change' && b.type === 'button'));
+  assert.equal(w.$('physNext').textContent, 'Create my planet →');
+  assert.ok(w.q('#physRail li').every((li) => li.classList.contains('done')), 'the rail reads complete');
+  gotos[4].listeners.click();
+  assert.equal(w.state.physics.q, 5, 'change goes back to that question');
+  await w.next();
+  assert.equal(w.state.physics.q, 'sum', 'and Continue returns to the summary, the rest already answered');
+});
+
+test('the summary\'s Create my planet pre-fills the technical steps and moves on to the name', async () => {
+  const w = at('sum', { ...SEVEN, project_state: 'existing', existing_work: ['code'], main_work: 'code', entity: 'for-profit' });
+  w.run('paintPhysics()');
+  assert.equal(w.$('physNext').textContent, 'Continue to setup →', 'the professional voice');
+  assert.equal(w.run('physAdvance()'), false);
+  assert.deepEqual(w.shown, [4], 'on to the name step');
+  assert.equal(w.state.projType, 'business', 'a for-profit company is a business on the map');
+  assert.equal(w.state.mode, 'adopt', 'a planet that already has code adopts its repo');
+  assert.equal(w.state.teamShape, null, 'a team of three is not guessed into a shape');
+  w.run('physPaintPrefillNotes()');
+  assert.match(w.$('typePrefill').textContent, /Picked from your answer “For-profit company”/);
+  assert.match(w.$('homePrefill').textContent, /Adopt is picked because your project already has code/);
+});
+
+// ── pre-fill and skip, rule by rule ──────────────────────────────────────────
+test('a pre-fill never overwrites what the founder chose, and follows a changed answer', () => {
+  const w = at('sum', { ...SEVEN, builders_at_start: 1, builders_expected: 1, entity: 'nonprofit' });
+  w.run('physPrefill()');
+  assert.equal(w.state.projType, 'non-profit');
+  assert.equal(w.state.teamShape, 'solo', 'one builder says solo');
+  assert.equal(w.state.mode, 'greenfield');
+  w.state.projType = 'game';                 // the founder picks for themselves on the Type step
+  w.state.physics.answers.entity = 'research';
+  w.run('physPrefill()');
+  assert.equal(w.state.projType, 'game', 'their choice stands');
+  w.state.projType = 'non-profit';           // back to what we filled …
+  w.state.prefilled = { projType: 'non-profit' };
+  w.run('physPrefill()');
+  assert.equal(w.state.projType, 'research', '… and an untouched pre-fill follows the answer');
+  w.state.physics.answers.entity = 'intent-unsure';
+  w.run('physPrefill()');
+  assert.equal(w.state.projType, null, 'an answer that suggests nothing clears what we filled');
+  w.run('physPaintPrefillNotes()');
+  assert.equal(w.$('typePrefill').hidden, true);
+});
+
+test('a planet on its own machines skips the app step; Next and Back step over it, and a demo never does', () => {
+  for (const [framing, skipped] of [['managed', false], ['hybrid', false], ['local', true], ['open-source', true]]) {
+    const w = at('sum', { ...SEVEN, framing });
+    assert.equal(w.run('physStepSkipped(10)'), skipped, framing);
+    assert.equal(w.run('physPastSkips(10, 1)'), skipped ? 11 : 10);
+    assert.equal(w.run('physPastSkips(10, -1)'), skipped ? 9 : 10);
+    for (const n of [4, 5, 6, 7, 8, 9, 11, 12]) assert.equal(w.run(`physStepSkipped(${n})`), false, `step ${n} always applies`);
+  }
+  const w = at('sum', { ...SEVEN, framing: 'open-source' }, { draft: { appPlatform: 'render' } });
+  w.run('physPrefill()');
+  assert.equal(w.state.appPlatform, 'later', 'a skipped step keeps its default answer');
+  w.state.demo = { people: 3, hours_each: 4 };
+  assert.equal(w.run('physStepSkipped(10)'), false, 'a demo is all managed');
+});
+
+// ── what the create sends ────────────────────────────────────────────────────
+test('the create sends questions 5 to 7 and the voice as detail, in the vocabulary\'s order', () => {
+  const w = at('sum', { ...SEVEN, reward_intents: ['future-payouts', 'non-monetary'], services: ['starter-kit', 'hosting'] });
+  w.state.teamShape = 'small-team';
+  const d = plain(w.run('createDetail()'));
+  assert.deepEqual(d, {
+    project_state: 'new', home_country: 'US', home_region: 'US-CA', builder_geography: 'us-eu', minors_on_board: false, entity: 'intent-solo',
+    builders_at_start: 3, builders_expected: 8, framing: 'hybrid',
+    reward_intents: ['non-monetary', 'future-payouts'], services: ['hosting', 'starter-kit'], voice: 'planet', team_shape: 'small-team',
+  });
+  const { badProjectDetail } = require('../modules/provisioning/routes/body-validators.js');
+  assert.equal(badProjectDetail(d), null, 'every key and value is one the create route accepts');
+});
+
+// ── the planet ───────────────────────────────────────────────────────────────
+test('the planet gains moons, rings and its orbit around the platform\'s mark', () => {
+  const w = at(7, { ...SEVEN, entity: 'for-profit', builders_at_start: 4, builders_expected: 6, reward_intents: ['non-monetary', 'cash', 'future-payouts'], framing: 'local' });
+  const shown = (sel) => w.q(sel).filter((e) => !e.hidden).length;
+  assert.equal(shown('#physMoons img'), 4, 'a moon per builder now');
+  assert.equal(shown('#physGhosts img'), 2, 'faint ones for the expected growth');
+  assert.ok(w.q('#physMoons img').every((m) => m.getAttribute('src') === '/assets/world/r3-gold-bead-cut.webp'), 'beads of the core\'s material');
+  assert.equal(shown('#physStage .physBelt'), 3, 'a ring per reward being considered');
+  assert.equal(w.$('physStage').getAttribute('data-orbit'), 'far', 'local is a far orbit');
+  assert.equal(w.$('physSun').hidden, false);
+  assert.equal(w.$('physSun').getAttribute('src'), '/assets/world/r2-bongos-chrome-a-cut.webp', 'the platform\'s own mark');
+  w.state.physics.answers.framing = 'open-source';
+  w.run('physPaintStage()');
+  assert.equal(w.$('physStage').getAttribute('data-orbit'), 'own');
+  assert.equal(w.$('physSun').hidden, true, 'open source is a system of its own');
+  w.state.physics.answers.builders_at_start = 9; w.state.physics.answers.builders_expected = 40;
+  w.run('physPaintStage()');
+  assert.equal(shown('#physMoons img'), 6, 'six at most');
+  assert.equal(shown('#physGhosts img'), 4, 'four at most');
+  w.state.physics.q = 'sum';
+  w.run('physPaintStage()');
+  assert.equal(w.$('physPlanet').getAttribute('data-size'), '6', 'the full planet');
+  assert.equal(w.$('physCapN').textContent, 'complete');
+  for (const plate of ['r3-frost-bead-cut', 'r3-gold-bead-cut', 'r3-obsidian-bead-cut', 'r2-bongos-chrome-a-cut']) {
+    assert.ok(fs.existsSync(path.join(LANDING, 'assets', 'world', `${plate}.webp`)), `${plate} is a world plate`);
+  }
+});
+
+test('the orbit and the moons move on CSS alone, and the reduced-motion switch stops them', () => {
+  const css = HUB.slice(HUB.indexOf('.physBelt{'), HUB.indexOf('/* under 520 the two doors'));
+  assert.match(css, /@media \(prefers-reduced-motion:no-preference\)\{\s*\.physMoons\{animation:physOrbit 160s/);
+  assert.doesNotMatch(css.replace(/@media \(prefers-reduced-motion:no-preference\)\{[\s\S]*?\n\}/, ''), /animation:/, 'no animation outside the no-preference block');
+  assert.doesNotMatch(css, /box-shadow/);
+  assert.doesNotMatch(SCRIPT, /\.animate\(|requestAnimationFrame|innerHTML/, 'no motion and no innerHTML in the controller');
+});
+
+// ── the done-when, end to end ────────────────────────────────────────────────
+test('a new owner walks from question 1 to Create my planet, and the technical steps arrive pre-filled', async () => {
+  const w = boot();
+  await w.next();                                   // the start screen
+  assert.equal(w.state.physics.q, 1);
+  w.pick('project_state', 'existing');
+  w.state.physics.answers.existing_work = ['code']; w.state.physics.answers.main_work = 'code';
+  w.state.description = 'An inventory tool our team started last year.';
+  await w.next();
+  assert.equal(w.state.physics.q, 2);
+  Object.assign(w.state.physics.answers, { home_country: 'US', home_region: 'US-NY' });
+  w.pick('builder_geography', 'global');
+  await w.next();
+  w.pick('minors_on_board', 'false');
+  await w.next();
+  w.pick('entity', 'for-profit');
+  await w.next();
+  assert.equal(w.state.physics.q, 5);
+  w.q('[data-phys-solo="many"]')[0].click();
+  await w.next();
+  assert.equal(w.state.physics.q, 6);
+  w.pick('reward_intents', 'equity');
+  w.pick('reward_intents', 'cash');
+  await w.next();
+  assert.equal(w.state.physics.q, 7);
+  w.pick('framing', 'open-source');
+  await tick(); await tick();
+  await w.next();
+  assert.equal(w.state.physics.q, 'sum');
+  assert.equal(w.$('physNext').textContent, 'Continue to setup →');
+  await w.next();
+  assert.deepEqual(w.shown, [4], 'the name step');
+  assert.deepEqual({ type: w.state.projType, mode: w.state.mode, app: w.state.appPlatform, skipApp: w.run('physStepSkipped(10)') },
+    { type: 'business', mode: 'adopt', app: 'later', skipApp: true });
+  const d = plain(w.run('createDetail()'));
+  assert.equal(d.voice, 'professional');
+  assert.equal(d.framing, 'open-source');
+  assert.equal(d.services, undefined);
+  assert.deepEqual(d.reward_intents, ['cash', 'equity']);
+});