@bongos/core 1.19.670 → 1.19.672

package/tests/wizard_intent_resume.mjs

@@ -0,0 +1,216 @@
+// tests/wizard_intent_resume.mjs — "New project" means a NEW project (task 1003503).
+//
+// The hub's create wizard stores the instance it just stood up (`cb-created-instance`),
+// and enter() resumed that record's done panel on EVERY arrival. Right mid-standup — the
+// watch continues across a reload — but once the standup finished, the "New project" nav
+// kept landing on the old checklist for the rest of the tab session. The only escape was
+// the done panel's own "Start another project" button.
+//
+// Owner call (2026-09-11, the two options the task offered): intent-driven resume.
+//   • focus === false  — a reload, Back, or the boot's identity settle. The SAME visit
+//     continuing, so the done panel and its human-steps checklist come back untouched.
+//   • focus === true   — a deliberate nav click. An ask for ANOTHER project: a fresh
+//     step 1, with the standup one click away on a "still watching …" link.
+// The record is never cleared by this, so nothing is lost either way — which is what
+// ruled out the task's other option (drop the record at a terminal state).
+//
+// The reset fires only when there is a SECOND DRAFT to lose, and the draft's own step is
+// what says so. A landed create clears DRAFT_KEY — but show(8) then persists the done
+// panel's position straight back into it, so a plain "is there a draft?" test is always
+// yes and would skip the reset forever, leaving the finished project's name sitting in
+// the fresh form. (That is exactly what the first cut of this change shipped into a
+// render: "still watching Mercury" above a name field still reading "Mercury".) Only
+// steps 1-7 are wizard steps; anything else is the done panel's own bookkeeping.
+//
+// Harness: there is no jsdom in this repo, so this follows tests/wizard_draft_resume.mjs
+// and tests/project_door_ui.mjs — slice the real region out of the page's INLINE script
+// and run it in a vm under a minimal DOM stub. Both slice boundaries are asserted, so a
+// rename fails loudly instead of leaving this file quietly testing nothing.
+//
+// projects.html is CRLF on a Windows checkout, so this file normalises at read time the
+// way tests/projects_hub_pre_uat.mjs does — a vm cannot run a slice with stray \r in it.
+//
+// Run:  node --test --test-reporter=tap tests/wizard_intent_resume.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const COSMOS = fs.readFileSync(path.join(LANDING, 'assets', 'cosmos.css'), 'utf8').replace(/\r\n/g, '\n');
+const SCRIPT = HUB.slice(HUB.lastIndexOf('<script>'), HUB.lastIndexOf('</script>'));
+
+// ── the two slices ───────────────────────────────────────────────────────────────
+// Each function closes on the first `}` at the wizard IIFE's own four-space indent.
+const ENTER_RE = /function enterCreated\(created, focus\) \{[\s\S]*?\n {4}\}/;
+const OFFER_RE = /function paintResumeOffer\(created\) \{[\s\S]*?\n {4}\}/;
+const enterSlice = (SCRIPT.match(ENTER_RE) || [null])[0];
+const offerSlice = (SCRIPT.match(OFFER_RE) || [null])[0];
+
+test('both slices are still findable (a rename must fail loudly, not silently pass)', () => {
+  assert.ok(enterSlice, 'enterCreated() was not found in projects.html');
+  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 <= 7/,
+    'the STORED draft\'s step decides, not state.step — state.step is 8 for the whole life of a finished standup');
+  assert.match(SCRIPT, /if \(created && created\.id\) \{ enterCreated\(created, !!focus\); return; \}/,
+    'enter() still hands the created record straight to it');
+});
+
+// A faithful miniature: the stubs record what enterCreated ASKS FOR, which is the whole
+// contract — which panel is shown, whether the answers were reset, and what the offer
+// above step 1 was told to name.
+function runEnter({ focus, resumeIntent = false, draft = null, record }) {
+  const store = new Map();
+  if (draft) store.set('draft', JSON.stringify(draft));
+  const calls = { show: [], resets: 0, offer: [], done: 0, progress: [], polls: 0, focused: 0 };
+  // 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 : 8, name: 'Mercury', slug: 'mercury', domain: '', mode: 'greenfield', noAddress: false, modules: null };
+  const sandbox = {
+    record, focus, resumeIntent, state,
+    DRAFT_KEY: 'draft',
+    live: { manifest: null, appSlug: null },
+    manifestState: null,
+    manifestPending: false,
+    sessionStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null) },
+    resetForNewProject() { calls.resets += 1; state.step = 1; state.name = ''; state.slug = ''; },
+    paintResumeOffer(c) { calls.offer.push(c ? (c.name || c.slug) : null); },
+    show(step, moveFocus) { state.step = step; calls.show.push([step, moveFocus]); },
+    renderDone() { calls.done += 1; },
+    startProgress(id) { calls.progress.push(id); },
+    resumePolls() { calls.polls += 1; },
+    $: () => ({ focus() { calls.focused += 1; } }),
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(`${enterSlice}\nenterCreated(record, focus);`, sandbox);
+  return { calls, state, sandbox };
+}
+
+const REC = { id: 'inst-1', name: 'Acme', slug: 'acme', domain: 'acme.example', mode: 'greenfield' };
+
+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, [[8, false]], 'the done panel, 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');
+  assert.equal(calls.polls, 1, 'and the parked manifest poll is resumed');
+  assert.equal(state.name, 'Acme', 'the record re-seeds the state the done panel reads');
+  assert.deepEqual(calls.offer, [null], 'the offer is down — the done panel is on stage, not step 1');
+});
+
+test('a deliberate "New project" click after a finished standup opens a FRESH step 1', () => {
+  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, 'the name field does — the deliberate-nav rule enter() already applies');
+  assert.equal(state.name, '', 'the old name is gone from the form');
+});
+
+test('…and the standup stays one click away, named, on the resume link', () => {
+  const { calls } = runEnter({ focus: true, record: REC });
+  assert.deepEqual(calls.offer, ['Acme'], 'the offer names the project the record holds');
+  const noName = runEnter({ focus: true, record: { id: 'inst-2', slug: 'beta' } });
+  assert.deepEqual(noName.calls.offer, ['beta'], 'falling back to the handle when the record carries no name');
+});
+
+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, [[8, true]], 'a deliberate resume moves focus to the done panel');
+  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');
+});
+
+test('a second draft already under way is NOT wiped by navigating back to the wizard', () => {
+  // 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: 5 } });
+  assert.equal(calls.resets, 0, 'a live draft is never reset');
+  assert.deepEqual(calls.show, [[5, true]], 'the second draft resumes where it was left, heading focused');
+  assert.equal(state.step, 5);
+  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(8) 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: 8, 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 the name step');
+  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');
+});
+
+test('a draft whose step is missing or junk resets too — only 1-7 preserves anything', () => {
+  for (const draft of [{ step: 0 }, { step: 9 }, { 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]]);
+  }
+});
+
+// ── the offer itself ─────────────────────────────────────────────────────────────
+test('paintResumeOffer names the project by textContent and hides on null (no live DOM from strings)', () => {
+  const els = { wizResume: { hidden: true }, wizResumeName: { textContent: '' } };
+  const sandbox = { $: (id) => els[id] };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(`${offerSlice}
+    paintResumeOffer({ id: 'i', name: 'Acme' });
+    var shown = { hidden: $('wizResume').hidden, name: $('wizResumeName').textContent };
+    paintResumeOffer(null);
+    var hid = $('wizResume').hidden;`, sandbox);
+  assert.equal(sandbox.shown.hidden, false, 'a record shows the line');
+  assert.equal(sandbox.shown.name, 'Acme', 'written as text, never as markup');
+  assert.equal(sandbox.hid, true, 'null takes it down');
+  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', () => {
+  const panel = HUB.slice(HUB.indexOf('id="panel-name"'), HUB.indexOf('id="panel-type"'));
+  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 id="newForm"'),
+    'it sits above the name form, where a visitor reads it before typing');
+  assert.match(SCRIPT, /\$\('wizResumeGo'\)\.addEventListener\('click', function \(ev\) \{\n\s*ev\.preventDefault\(\);\n\s*resumeIntent = true;\n\s*enter\(true\);/,
+    'the link raises the one-shot intent and re-enters, rather than href-navigating');
+});
+
+test('the offer clears the 24px hit floor as a box, like every other link on this panel', () => {
+  assert.match(COSMOS, /#view-new \.resumeOffer a\{display:inline-block;padding:3px 0;min-height:24px;/,
+    'an inline link\'s rect is its content box — the floor needs the box');
+  assert.match(COSMOS, /#view-new \.resumeOffer\{[^}]*color:var\(--ink-soft\)/, 'quiet ink: this is an offer, not a banner');
+});
+
+// ── the reset the two doors share ────────────────────────────────────────────────
+test('"Start another project" is the deliberate goodbye: the record goes, and the offer with it', () => {
+  const again = SCRIPT.slice(SCRIPT.indexOf('function wireAgain()'), SCRIPT.indexOf('function createdRecord()'));
+  assert.match(again, /resetForNewProject\(\);/, 'it shares the reset with the intent-driven start');
+  assert.match(again, /sessionStorage\.removeItem\(CREATED_KEY\)/, 'and it alone drops the record');
+  assert.match(again, /paintResumeOffer\(null\)/, 'so the offer must not survive it');
+  assert.doesNotMatch(enterSlice, /removeItem\(CREATED_KEY\)/,
+    'the intent-driven path must NEVER clear the record — the link is the whole point');
+});
+
+test('the reset re-declares every key the initial state declares (modules is the one that bites)', () => {
+  const initial = SCRIPT.match(/var state = \{ step: 0,([^}]*)\}/);
+  const reset = SCRIPT.match(/function resetForNewProject\(\)[\s\S]*?state = \{ step: 1,([^}]*)\}/);
+  assert.ok(initial && reset, 'both state literals must be findable');
+  const keys = (s) => [...s.matchAll(/(\w+):/g)].map((m) => m[1]).sort();
+  assert.deepEqual(keys(reset[1]), keys(initial[1]),
+    'a key left out reads as undefined, not as its sentinel — pickedModules() called .slice() on it and the second project\'s Modules step threw');
+  assert.match(reset[1], /modules: null/, 'null is the picker\'s "nothing said" answer (task 1002339)');
+});