@bongos/core 1.21.105 → 1.21.106

package/tests/wizard_github_feedback.mjs

@@ -13,7 +13,8 @@
 //
 // Four layers, all DB-free and network-free:
 //   1. manifest-truth.js — the effective status and how far a failure got (PURE).
-//   2. renderStepOauthApp, EXECUTED by the vm-slice idiom: the words for each stage.
+//   2. part 03's GitHub facts (ghFacts, task 1004683), EXECUTED by the vm-slice idiom:
+//      the words and the one action for each stage.
 //   3. the reload path, EXECUTED: the seed from the instance read and the wait timer.
 //   4. the project's own sign-in door with nothing configured: a page in words.
 //
@@ -69,130 +70,132 @@ test('publicGithubApp: effective status, failure only on error, started_at, and
 
 // ── 2. the words for each stage ─────────────────────────────────────────────
 
-// from the shared helpers of the four GitHub steps (task 1004649) to the renderer table
-const RS = SCRIPT.indexOf('    /* The four GitHub steps of part 03');
-const RE = SCRIPT.indexOf('    var STEP_RENDERERS = {', RS);
-const RENDER = SCRIPT.slice(RS, RE);
+// part 03's facts (task 1004683): the pure half of the facts region, run as is
+const FS = SCRIPT.indexOf('    function ghStep(key) {');
+const FE = SCRIPT.indexOf('    /* ── drawing it: nodes and textContent only', FS);
+const RENDER = SCRIPT.slice(FS, FE);
 
-test('the GitHub step region is still findable (a rename must fail loudly)', () => {
-  assert.ok(RS > 0 && RE > RS, 'both slice boundaries found');
-  assert.match(RENDER, /function renderStepOauthApp\(\)/);
+test('the GitHub facts region is still findable (a rename must fail loudly)', () => {
+  assert.ok(FS > 0 && FE > FS, 'both slice boundaries found');
+  assert.match(RENDER, /function ghFacts\(now\)/);
 });
 
-function stage(live, { tab = null, fn = 'renderStepOauthApp' } = {}) {
+// every GitHub fact for one reading of the attempt, as the founder reads it
+function stageAll(live, { tab = null } = {}) {
   const sandbox = {
-    live: { manifest: null, manifestMsg: '', manifestCode: '', manifestFailure: null, appSlug: null, setup: null, installUrl: null, instStatus: 'active', addrReady: true, pickUp: null, verifying: false, askedPlatform: false, ...live },
+    live: { manifest: null, manifestMsg: '', manifestCode: '', manifestFailure: null, appSlug: null, setup: null, installUrl: null, instStatus: 'active', addrReady: true, pickUp: null, verifying: false, askedPlatform: false, inst: null, readAt: Date.now(), gone: '', repo: null, ...live },
     state: { name: 'Mercury', slug: 'mercury' },
-    autoOpenArmed: false,
     resolvedDomain: () => 'mercury.example.com',
     apexBase: () => 'example.com',
-    esc: (x) => String(x).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c])),
-    GH_ICON: '',
-    manualOauthDetails: () => '<details>manual</details>',
-    projectPageLink: (t) => '<a>' + t + '</a>',
-    autoOpenTick: () => '<label>auto</label>',
-    progressMarkup: (now, done, note, cls) => `<prog now=${now} done=${done} cls="${cls}">${note}</prog>`,
+    addressReady: () => true,
   };
   vm.createContext(sandbox);
-  vm.runInContext(`${RENDER}\nghTabTrouble = ${JSON.stringify(tab)};\nvar out = ${fn}();`, sandbox);
-  return sandbox.out;
+  vm.runInContext(`${RENDER}\nghTabTrouble = ${JSON.stringify(tab)};\nvar out = JSON.stringify(ghFacts(Date.now()));`, sandbox);
+  return JSON.parse(sandbox.out).map((r) => ({
+    ...r,
+    words: [r.title, [].concat(r.sub || []).map((p) => (typeof p === 'string' ? p : p.t)).join('')].join(' — '),
+    acts: [].concat(r.act || []),
+  }));
+}
+function stage(live, { tab = null, key = 'approve' } = {}) {
+  return stageAll(live, { tab }).find((r) => r.key === key);
 }
-const startButton = /data-action="manifest-start"/;
 const NEVER_A_CHORE = /\/contact|Contact us|delete it first|Developer settings → GitHub Apps\) so|Try again anyway|Start the setup again/;
 
-test('pending: waiting for approval, says where a missing GitHub tab went, and reopens the SAME setup', () => {
-  const html = stage({ manifest: 'pending' });
-  assert.match(html, /Waiting for your approval on GitHub/);
-  assert.match(html, /No GitHub tab\? It may have opened behind this window or in another one/);
-  assert.doesNotMatch(html, startButton, 'no new-link button while GitHub holds this one (task 1004652)');
-  assert.match(html, /class="linklike" data-action="reopen-github">No GitHub tab\? Reopen GitHub/, 'the way back is there from the first second, not after 90');
-  // the tab this page opened, seen from here (task 1004652)
+test('pending: the founder\'s turn, says where a missing GitHub tab went, and reopens the SAME setup', () => {
+  const f = stage({ manifest: 'pending' });
+  assert.equal(f.state, 'you');
+  assert.match(f.words, /Waiting for you in the GitHub tab\./);
+  assert.deepEqual(f.acts, ['reopen'], 'no new-link button while GitHub holds this one (task 1004652); the way back is there from the first second');
   const behind = stage({ manifest: 'pending' }, { tab: 'behind' });
-  assert.match(behind, /Your GitHub tab opened behind this window/);
-  assert.match(behind, /class="ghbtn" data-action="reopen-github">Reopen GitHub ↗/);
+  assert.match(behind.words, /Your GitHub tab opened behind this window\./);
+  assert.deepEqual(behind.acts, ['reopen']);
   const closed = stage({ manifest: 'pending' }, { tab: 'closed' });
-  assert.match(closed, /The GitHub tab closed before the app was approved, so nothing was made on GitHub/);
-  assert.match(closed, /data-action="reopen-github"/);
-  assert.doesNotMatch(behind + closed, startButton);
+  assert.match(closed.words, /The GitHub tab closed before you approved, so nothing was made\. Reopen it to carry on\./);
+  assert.deepEqual(closed.acts, ['reopen']);
 });
 
-test('converting is the SAME stage as code_received — approved, placing credentials — never "waiting for approval"', () => {
+test('converting is the SAME fact as code_received — approved, keys being collected — never "waiting for you"', () => {
   for (const m of ['code_received', 'converting']) {
-    const html = stage({ manifest: m });
-    assert.match(html, /Approved on GitHub/, m);
-    assert.match(html, /goes on to installing it on your repo/, `${m}: the trip carries on to the install (task 1004649)`);
-    assert.match(html, /<prog now=1 done=1/, `${m}: the strip is past the approval stage`);
-    assert.doesNotMatch(html, /Waiting for your approval/, m);
+    const f = stage({ manifest: m });
+    assert.equal(f.state, 'now', `${m}: under way, not the founder's turn`);
+    assert.match(f.words, /Approved\. The platform is collecting the app’s keys\./, m);
+    assert.doesNotMatch(f.words, /Waiting for you/, m);
+    assert.deepEqual(f.acts, [], `${m}: nothing to press`);
   }
 });
 
-test('sign-in unconfirmed: the app stays ticked, sign-in is the stopped step, and picking it up makes no second app', () => {
+test('sign-in unconfirmed: the app stays ticked, sign-in is a stopped fact, and picking it up makes no second app', () => {
   const live = { manifest: 'error', manifestFailure: 'sign_in_unconfirmed', appSlug: 'mercury-cloudbongos-com', pickUp: 'check' };
-  const approve = stage(live);
-  assert.match(approve, /^<li class="sdone"/, 'GitHub made the app and its keys are placed: that much is true');
-  const signIn = stage(live, { fn: 'renderStepFirstSignIn' });
-  assert.match(signIn, /^<li class="sstopped"/);
-  assert.match(signIn, /Your project didn’t confirm that sign-in works\. Nothing is lost, and no second app will be made\./);
-  assert.match(signIn, /data-action="pick-up">Pick up where it stopped/);
-  assert.match(signIn, /data-action="ask-platform">Send it to the platform team/, 'a project that still will not answer goes to the platform team from here');
-  assert.doesNotMatch(approve + signIn, startButton, 'no new link: it would make a second app');
-  assert.doesNotMatch(approve + signIn, NEVER_A_CHORE);
-  // while the runner is asking again, the step says so and offers no button that repeats it
-  const checking = stage({ ...live, pickUp: null, verifying: true }, { fn: 'renderStepFirstSignIn' });
-  assert.match(checking, /We’re asking it again, with the app GitHub already made/);
-  assert.doesNotMatch(checking, /data-action="pick-up"/);
-  // sent: the step says the platform team has it
-  assert.match(stage({ ...live, askedPlatform: true }, { fn: 'renderStepFirstSignIn' }), /Sent\. The platform team has it/);
-  assert.match(stage({ ...live, askedPlatform: 'failed' }, { fn: 'renderStepFirstSignIn' }), /That didn’t send\. Try again\.[\s\S]*data-action="ask-platform"/);
+  const all = stageAll(live);
+  const [approve, , signIn] = all;
+  assert.equal(approve.state, 'done', 'GitHub made the app and its keys are placed: that much is true');
+  assert.equal(signIn.state, 'bad');
+  assert.match(signIn.words, /Your project didn’t confirm that sign-in works\./);
+  assert.ok(signIn.acts.includes('ask-platform'), 'a project that still will not answer goes to the platform team from here');
+  assert.equal(all.flatMap((r) => r.acts).filter((a) => /^pick-up/.test(a)).length, 1, 'one "Pick up where it stopped", on the first stopped fact');
+  assert.ok(!all.some((r) => r.acts.includes('connect')), 'no new link: it would make a second app');
+  assert.doesNotMatch(all.map((r) => r.words).join('\n'), NEVER_A_CHORE);
+  // while the runner is asking again, the fact says so and offers no button that repeats it
+  const checking = stage({ ...live, pickUp: null, verifying: true }, { key: 'sign_in' });
+  assert.equal(checking.state, 'now');
+  assert.match(checking.words, /Asking your project again, with the app GitHub already made\./);
+  assert.deepEqual(checking.acts, []);
+  // sent: the fact says the platform team has it
+  const sent = stage({ ...live, askedPlatform: true }, { key: 'sign_in' });
+  assert.match(sent.words, /Sent\. The platform team has it and finishes it from here\./);
+  assert.ok(!sent.acts.includes('ask-platform'), 'sent once');
+  const failed = stage({ ...live, askedPlatform: 'failed' }, { key: 'sign_in' });
+  assert.match(failed.words, /That didn’t send\. Try again\./);
+  assert.ok(failed.acts.includes('ask-platform'));
 });
 
 test('approved, conversion stopped with its code still young: pick it up, no second app', () => {
-  const html = stage({ manifest: 'error', manifestFailure: 'finish_failed', pickUp: 'convert' });
-  assert.match(html, /^<li class="sstopped"/);
-  assert.match(html, /GitHub approved the app, and the platform stopped before it finished collecting the app’s keys\. Nothing is lost, and no second app will be made\./);
-  assert.match(html, /data-action="pick-up">Pick up where it stopped/);
-  assert.doesNotMatch(html, startButton);
-  assert.doesNotMatch(html, NEVER_A_CHORE);
+  const f = stage({ manifest: 'error', manifestFailure: 'finish_failed', pickUp: 'convert' });
+  assert.equal(f.state, 'bad');
+  assert.match(f.words, /GitHub approved the app, and the platform stopped before it finished collecting the app’s keys\./);
+  assert.deepEqual(f.acts, ['pick-up']);
+  assert.doesNotMatch(f.words, NEVER_A_CHORE);
 });
 
 test('approved but the keys never reached us: the platform team, sent from the page — never a GitHub chore', () => {
-  const html = stage({ manifest: 'error', manifestFailure: 'finish_failed', pickUp: 'operator' });
-  assert.match(html, /GitHub made the app, but its keys never reached your project/);
-  assert.match(html, /data-action="ask-platform">Send it to the platform team/);
-  assert.doesNotMatch(html, startButton, 'a new link would leave the founder with two apps');
-  assert.doesNotMatch(html, NEVER_A_CHORE);
-  assert.doesNotMatch(html, /Nothing was changed on GitHub/);
+  const f = stage({ manifest: 'error', manifestFailure: 'finish_failed', pickUp: 'operator' });
+  assert.match(f.words, /GitHub made the app, but its keys never reached your project/);
+  assert.deepEqual(f.acts, ['ask-platform'], 'a new link would leave the founder with two apps');
+  assert.doesNotMatch(f.words, NEVER_A_CHORE);
+  assert.doesNotMatch(f.words, /Nothing was changed on GitHub/);
 });
 
-test('the install the runner stopped checking for: the mockup’s sentence, and a pick-up that opens the SAME app’s install', () => {
-  const html = stage({ manifest: 'done', appSlug: 'mercury-app', installUrl: 'https://github.com/apps/mercury-app/installations/new', pickUp: 'check' }, { fn: 'renderStepAppInstall' });
-  assert.match(html, /^<li class="sstopped" data-onboard-step="app-install">/);
-  assert.match(html, /GitHub stopped before the app was installed on your repo\. Nothing is lost, and no second app will be made\./);
-  assert.match(html, /<a class="ghbtn" href="https:\/\/github\.com\/apps\/mercury-app\/installations\/new" target="_blank" rel="noopener" data-action="pick-up">Pick up where it stopped ↗<\/a>/);
-  // still being checked: the ordinary step, no stop
-  assert.doesNotMatch(stage({ manifest: 'done', appSlug: 'mercury-app', pickUp: null, verifying: true }, { fn: 'renderStepAppInstall' }), /sstopped/);
+test('the install the runner stopped checking for: the mockup’s words, and a pick-up that opens the SAME app’s install', () => {
+  const f = stage({ manifest: 'done', appSlug: 'mercury-app', installUrl: 'https://github.com/apps/mercury-app/installations/new', pickUp: 'check' }, { key: 'install' });
+  assert.equal(f.state, 'bad');
+  assert.match(f.words, /GitHub stopped before the app was on your repo\./);
+  assert.deepEqual(f.acts, ['pick-up-link']);
+  assert.equal(f.href, 'https://github.com/apps/mercury-app/installations/new');
+  // still being checked: the founder's turn on GitHub, no stop
+  assert.equal(stage({ manifest: 'done', appSlug: 'mercury-app', pickUp: null, verifying: true }, { key: 'install' }).state, 'you');
 });
 
 test('device flow after the runner stopped checking: "Check again", once the install has ticked', () => {
   const setup = { approve: 'done', install: 'done', sign_in: 'done', device_flow: 'later', connected: true };
-  const again = stage({ manifest: 'done', appSlug: 'mercury-app', setup, pickUp: 'check' }, { fn: 'renderStepDeviceFlow' });
-  assert.match(again, /data-action="pick-up">Turned it on\? Check again/);
-  assert.doesNotMatch(stage({ manifest: 'done', appSlug: 'mercury-app', setup, pickUp: null, verifying: true }, { fn: 'renderStepDeviceFlow' }), /Check again/);
-  assert.doesNotMatch(stage({ manifest: 'done', appSlug: 'mercury-app', setup: { ...setup, install: 'now', connected: false }, pickUp: 'check' }, { fn: 'renderStepDeviceFlow' }), /Check again/, 'the install step carries the action until it ticks');
+  assert.deepEqual(stage({ manifest: 'done', appSlug: 'mercury-app', setup, pickUp: 'check' }, { key: 'device_flow' }).acts, ['check-again']);
+  assert.deepEqual(stage({ manifest: 'done', appSlug: 'mercury-app', setup, pickUp: null, verifying: true }, { key: 'device_flow' }).acts, []);
+  assert.deepEqual(stage({ manifest: 'done', appSlug: 'mercury-app', setup: { ...setup, install: 'now', connected: false }, pickUp: 'check' }, { key: 'device_flow' }).acts, [],
+    'the install fact carries the action until it ticks');
 });
 
 test('a failure before GitHub (or a refused start) keeps the honest "nothing changed" line', () => {
-  assert.match(stage({ manifest: 'error', manifestFailure: 'not_approved' }), /Nothing was changed on GitHub/);
+  assert.match(stage({ manifest: 'error', manifestFailure: 'not_approved' }).words, /Nothing was changed on GitHub/);
   const refused = stage({ manifest: 'error', manifestMsg: 'HTTP 500' });
-  assert.match(refused, /Nothing was changed on GitHub/);
-  assert.match(refused, /Technical details/);
-  assert.match(refused, startButton);
+  assert.match(refused.words, /Nothing was changed on GitHub/);
+  assert.equal(refused.tech, 'HTTP 500', 'the route text folds under Technical details');
+  assert.deepEqual(refused.acts, ['connect']);
 });
 
 test('an expired link offers a fresh one', () => {
-  const html = stage({ manifest: 'expired' });
-  assert.match(html, /That setup link expired/);
-  assert.match(html, startButton);
+  const f = stage({ manifest: 'expired' });
+  assert.match(f.words, /That setup link expired/);
+  assert.deepEqual(f.acts, ['connect']);
 });
 
 // ── 3. the reload path ──────────────────────────────────────────────────────
@@ -201,7 +204,7 @@ const WS = SCRIPT.indexOf('    function manifestInFlight() {');
 const WE = SCRIPT.indexOf('    function pollManifest(stateToken) {', WS);
 const WAIT = SCRIPT.slice(WS, WE);
 const SS = SCRIPT.indexOf('            var ga = data.github_app;');
-const SE = SCRIPT.indexOf('            /* the checklist reflects live state (task 1002694)', SS);
+const SE = SCRIPT.indexOf('            /* the server-verified checklist rides the same read (task 1004649)', SS);
 const SEED = SCRIPT.slice(SS, SE);
 
 test('the reload regions are still findable (a rename must fail loudly)', () => {
@@ -220,7 +223,7 @@ function reloaded(githubApp, now) {
     live: { manifest: null, manifestFailure: null, appSlug: null },
     manifestPollTimer: null, manifestStartedAt: 0, ghTabTrouble: null,
     document: { hidden: false, hasFocus: () => true },
-    rememberManifest: () => {}, renderSteps: () => renders.push(1),
+    rememberManifest: () => {}, paintFacts: () => renders.push(1),
     Date: { now: () => now, parse: Date.parse },
   };
   vm.createContext(sandbox);

package/tests/wizard_one_page.mjs

@@ -112,7 +112,7 @@ test('nothing the live wizard does is lost: every capability in the direction ta
   assert.match(row('run'), /data-val="hybrid" aria-pressed="false">Some of it<\/button>/, 'We run: "Some of it" reveals the service checklist');
   has('the Shipping row', row('ship'), ['shipOpts']);
   has('the Look row', row('look'), ['wizLook', 'lookDot']);
-  has('the page', PAGE, ['wizResume', 'termsAck', 'doCreate', 'wizRecap', 'createWhy', 'createAlert', 'humanSteps', 'liveProgress', 'wizInvite', 'done-h']);
+  has('the page', PAGE, ['wizResume', 'termsAck', 'doCreate', 'wizRecap', 'createWhy', 'createAlert', 'setupNow', 'homeFacts', 'ghFacts', 'wizInvite', 'done-h', 'enterGenesis']);
   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');
 });
@@ -143,7 +143,7 @@ test('Create waits for a name and the terms tick only, and says why in place (ex
 });
 
 test('Create runs the screening stop before anything exists, and a row that cannot be filed opens with its reason', () => {
-  const create = slice('$(\'doCreate\').addEventListener(\'click\'', '/* ── done panel');
+  const create = slice('$(\'doCreate\').addEventListener(\'click\'', '/* ── part 03 after Create (task 1004683');
   const order = ['createWhy()', 'firstInvalidRow()', 'physScreen()', 'ensureFreshRepo()', "fetch(API + '/provisioning/instances'"].map((s) => create.indexOf(s));
   assert.ok(order.every((i, k) => i > 0 && (k === 0 || i > order[k - 1])), 'name and tick, then the rows, then the screen, then the repo, then the create');
   assert.match(create, /if \(!ok\) \{ var stop = new Error\('stopped'\); stop\.stopped = true; throw stop; \}/, 'a stop files nothing');
@@ -181,16 +181,18 @@ test('the day room is the mockup\'s, drawn from the fifteen, and its motion sits
   assert.doesNotMatch(STYLE.replace(calm, ''), /rmDrift 60s|animation:rmTwinkle|animation:rmBreathe/, 'no room motion outside the no-preference block');
 });
 
-test('part 03 is the checklist, every step on show, with the state line from the server\'s own record', () => {
+test('part 03 waits for the project, then is one list of checked facts with its count, all on show', () => {
   assert.match(part('panel-done') || PAGE, /id="panel-done"/);
   assert.match(PAGE, /<div class="part waiting" id="panel-done" aria-labelledby="done-part-h">/, 'part 03 waits until the project exists');
+  assert.match(PAGE, /<h2 id="done-part-h"><span class="n">03<\/span><span id="donePartT">Connect GitHub<\/span> <span class="state" id="ghState">opens once your project exists<\/span><\/h2>/,
+    'before Create it is Connect GitHub; the script names it "Getting <name> ready" after');
   assert.match(SCRIPT, /done\.classList\.toggle\('waiting', !created\);/);
-  const steps = slice('function stepsPaint()', '(function hopInput()');
-  assert.match(steps, /'connected ✓'/);
-  assert.match(steps, /'waiting on GitHub…'/);
-  assert.match(steps, /'ready'/);
-  assert.doesNotMatch(steps, /innerHTML/, 'no markup built from strings');
-  assert.doesNotMatch(STYLE, /humanSteps>li:not\(\.cur\)/, 'the checklist is no longer paged one step at a time');
+  const paint = slice('function paintFacts()', 'function repaintFacts()');
+  assert.match(paint, /title\.textContent = 'Getting ' \+ projectName\(\) \+ ' ready';/);
+  assert.match(paint, /count\.textContent = setupCount\(home, gh\);/);
+  assert.match(slice('function setupCount(home, gh)', 'function setupSentence('), /'ready ✓' : done \+ ' of ' \+ req\.length \+ ' done'/);
+  assert.doesNotMatch(slice('/* ── part 03 after Create (task 1004683', '/* ── C8: the wizard'), /innerHTML\s*=/, 'no markup built from strings: the facts are nodes');
+  assert.doesNotMatch(STYLE, /humanSteps/, 'the old checklist and its sheet are gone');
 });
 
 test('the name is typed, so the handle under it is built from nodes, never markup', () => {

package/tests/wizard_auto_open.mjs

@@ -1,94 +0,0 @@
-// tests/wizard_auto_open.mjs — the checklist's "Open my project automatically when it's
-// ready" tick (task 1004548).
-//
-// WHY. The GitHub-App callback page used to hold the founder on its own stepper and open
-// the instance itself. Since task 1004548 it hands them straight back to the checklist,
-// so the auto-open moved there. The rule it must keep: open ONCE, only when sign-in is
-// wired AND the project answers, only after a wait this page actually watched (so a
-// revisit to a long-finished checklist never jumps away), never when the founder
-// unticked it — and prefer a new tab, falling back to this one when the browser blocks
-// an unprompted tab.
-//
-// Executed, not read: the real AUTO_OPEN_KEY…maybeAutoOpen region is sliced out of the
-// page's inline script and run in a node:vm under stubs (the vm-slice idiom of
-// tests/wizard_intent_resume.mjs). The slice boundaries are asserted, so a rename fails
-// loudly instead of testing nothing.
-//
-// Run:  node --test tests/wizard_auto_open.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 SCRIPT = HUB.slice(HUB.lastIndexOf('<script>'), HUB.lastIndexOf('</script>'));
-
-const START = SCRIPT.indexOf("    var AUTO_OPEN_KEY = 'cb-open-when-ready';");
-const END = SCRIPT.indexOf('    /* oauth-app — the ADR 0133 one-click GitHub-App manifest flow', START);
-const SLICE = SCRIPT.slice(START, END);
-
-test('the auto-open region is still findable (a rename must fail loudly)', () => {
-  assert.ok(START > 0 && END > START, 'both slice boundaries found');
-  assert.match(SLICE, /function maybeAutoOpen\(\)/);
-  assert.match(SLICE, /function autoOpenTick\(\)/);
-});
-
-const READY = { manifest: 'done', instStatus: 'active', addrReady: true };
-
-function run({ live = READY, armed = true, pref = null, popupBlocked = false, ticks = 1 } = {}) {
-  const store = new Map();
-  if (pref !== null) store.set('cb-open-when-ready', pref);
-  const calls = { opened: [], assigned: [] };
-  const sandbox = {
-    live: { ...live },
-    resolvedDomain: () => 'mercury.example.com',
-    localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, v) },
-    window: {
-      open: (u, t) => { calls.opened.push([u, t]); return popupBlocked ? null : { opener: 'checklist' }; },
-      location: { assign: (u) => { calls.assigned.push(u); } },
-    },
-  };
-  sandbox.globalThis = sandbox;
-  vm.createContext(sandbox);
-  vm.runInContext(`${SLICE}\nautoOpenArmed = ${armed ? 'true' : 'false'};\nfor (var i = 0; i < ${ticks}; i++) maybeAutoOpen();\nvar tickHtml = autoOpenTick();`, sandbox);
-  return { calls, sandbox };
-}
-
-test('ready + armed + ticked (the default) → opens the project ONCE, in a new tab', () => {
-  const { calls } = run({ ticks: 3 });
-  assert.deepEqual(calls.opened, [['https://mercury.example.com', '_blank']], 'one new tab, however many renders follow');
-  assert.deepEqual(calls.assigned, [], 'this checklist stays put');
-});
-
-test('a browser that blocks the unprompted tab sends THIS tab instead — the founder asked', () => {
-  const { calls } = run({ popupBlocked: true });
-  assert.deepEqual(calls.assigned, ['https://mercury.example.com']);
-});
-
-test('nothing opens until sign-in is wired AND the project answers', () => {
-  for (const live of [
-    { ...READY, manifest: 'code_received' },
-    { ...READY, instStatus: 'provisioning' },
-    { ...READY, addrReady: false },
-  ]) {
-    const { calls } = run({ live });
-    assert.deepEqual([calls.opened, calls.assigned], [[], []], JSON.stringify(live));
-  }
-});
-
-test('unticked → never opens, and the tick renders unticked', () => {
-  const { calls, sandbox } = run({ pref: '0' });
-  assert.deepEqual([calls.opened, calls.assigned], [[], []]);
-  assert.doesNotMatch(sandbox.tickHtml, / checked/);
-  assert.match(run().sandbox.tickHtml, / checked>/, 'the default is ticked');
-});
-
-test('a checklist that never watched the wait (a revisit) does not jump away', () => {
-  const { calls } = run({ armed: false });
-  assert.deepEqual([calls.opened, calls.assigned], [[], []]);
-});