@bongos/core 1.25.23 → 1.25.25

package/tests/auth_switch_account.mjs

@@ -24,13 +24,9 @@ test('switchAccount adds prompt=select_account; a plain sign-in does not', () =>
   assert.equal(sw.searchParams.get('scope'), plain.searchParams.get('scope'));
 });
 
-test('the start route reads ?switch=1 and passes it to the GitHub leg', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/auth.js'), 'utf8');
-  assert.match(src, /const wantsSwitch = req\.query\.switch === '1'/);
-  assert.match(src, /switchAccount: wantsSwitch/);
-  // a switch must reach GitHub, never short-circuit through the live-session handoff
-  assert.match(src, /if \(!wantsRepos && !wantsSwitch\) \{/);
-});
+// The start route itself is now RUN, not read (task 1005283): tests/github_signup_handoff.mjs
+// calls GET /auth/web/start with ?switch=1 and asserts the redirect carries
+// prompt=select_account and goes to GitHub, never through the live-session handoff.
 
 test('the landing carries the New account door beside Sign in', () => {
   const html = fs.readFileSync(path.join(ROOT, 'modules/public-landing/public/index.html'), 'utf8');

package/tests/genesis_home.mjs

@@ -229,7 +229,7 @@ function world({ withGovernment = true } = {}) {
     lifecycle, government, now, documents: null,
   });
   return {
-    store, tasks, board, opened, deps,
+    store, tasks, board, opened, deps, government,
     finish: (s) => tasks[s].forEach((t) => { t.status = 'shipped'; }),
     pass: (s) => { board[s] = { state: 'passed', item_id: '9', waiting_on: [] }; },
     tick: (days) => { now = new Date(now.getTime() + days * 86400000); },
@@ -251,7 +251,7 @@ test('decide → five stages through the Board Room → alive, and the hall open
   g = await gh.readGenesis(w.deps());
   assert.equal(g.stage, 'scope');
   assert.equal(g.can_close, false, 'a stage with unfinished tasks cannot be put to the board');
-  assert.equal((await gh.savePlan({}, 1, w.deps())).reason, 'not_deciding', 'the plan is settled once');
+  assert.equal((await gh.savePlan({}, 1, w.deps())).revised, false, 'the same plan again changes nothing (task 1005107)');
 
   for (const s of STAGES5) {
     assert.equal((await gh.readGenesis(w.deps())).stage, s);
@@ -446,6 +446,48 @@ test('task 1005115: each stage on the genesis home carries its document', async
   assert.equal(g.stages[0].document, null);
 });
 
+test('task 1005107: the plan can be changed after decide; the same plan again changes nothing', async () => {
+  const w = world();
+  w.government.proposeCharter = async ({ form }) => ({ ok: true, item: { id: 44, constitution: { pass_rule: 'first_ratifier' } }, reads_as: { name: form } });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({ days: { scope: 7 } }, 1, w.deps());
+  let g = await gh.readGenesis(w.deps());
+  assert.equal(g.plan_editable, true);
+  const before = new Map(w.store);
+  const same = await gh.savePlan({ days: { scope: 7 } }, 1, w.deps());
+  assert.equal(same.ok, true);
+  assert.equal(same.revised, false);
+  assert.deepEqual([...w.store], [...before], 'leaving it unchanged writes nothing');
+  // A changed length moves the stage's due date at once.
+  const r = await gh.savePlan({ days: { scope: 10 } }, 1, w.deps());
+  assert.equal(r.revised, true);
+  assert.deepEqual(r.changed, ['days']);
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stages[0].days, 10);
+  assert.equal(g.stage, 'scope', 'revising the plan never moves the stage');
+  // A different government is filed for the board, like any charter change.
+  const gov = await gh.savePlan({ days: { scope: 10 }, government: 'republic' }, 1, w.deps());
+  assert.equal(gov.charter.state, 'sitting');
+  assert.equal(gov.charter.item_id, '44');
+  // Turning "existing" off cannot take back a filed step, and it says so.
+  await gh.savePlan({ days: { scope: 10 }, government: 'republic', existing: true }, 1, w.deps());
+  const off = await gh.savePlan({ days: { scope: 10 }, government: 'republic', existing: false }, 1, w.deps());
+  assert.equal(off.could_not.length, 1);
+  assert.match(off.could_not[0], /stays on the board/);
+  assert.equal((await gh.savePlan({ days: { scope: 999 } }, 1, w.deps())).reason, 'bad_days', 'a revision is held to the same ranges');
+});
+
+test('task 1005107: a stage the Board Room passed is shown fixed, with why; one that has not is not', async () => {
+  const w = world();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  w.finish('scope');
+  w.pass('scope');
+  const g = await gh.readGenesis(w.deps());
+  assert.match(g.stages[0].locked.reason, /Board Room passed the scope stage/);
+  assert.equal(g.stages[1].locked, null);
+});
+
 test('the view: states, wakes, the life plates and a due date from the plan', () => {
   const mode = { stage: 'strategize', stage_number: 2, stage_count: 5, day: 9 };
   const g = gh.shapeGenesis({
@@ -704,6 +746,77 @@ test('task 1005115: with no Board Room the card says the stage moved by itself,
   assert.doesNotMatch(host.innerHTML, /The strategy<\/b>/, 'an empty document is not listed');
 });
 
+test('task 1005107: the card offers to change the plan, reopens it with the saved answers, and says which stages are fixed', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'strategize', stage_number: 2, stage_count: 5, day: 3 },
+    plan: { days: { scope: 7, strategize: 9, charter: 4, legalize: 7, legislation: 3 }, passes: 2, advisors: 'cbaas', existing: true, government: null, expected_builders: null },
+    tasks: { scope: [{ id: '1', title: 'Scope', status: 'shipped' }], strategize: [{ id: '2', title: 'Strategy', status: 'ready' }] },
+    board: { scope: { state: 'passed', waiting_on: [] } },
+    stageAt: { strategize: '2026-10-08T00:00:00Z' },
+  });
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  const click = await mountClickable(b);
+  assert.match(b.host.innerHTML, /data-genesis-plan-edit>Change the plan</);
+  assert.match(b.host.innerHTML, /Fixed: The Board Room passed the scope stage/);
+  assert.doesNotMatch(b.host.innerHTML, /data-genesis-plan>/, 'the plan form is not shown until asked for');
+  await click(fakeButton('data-genesis-plan-edit'));
+  assert.match(b.host.innerHTML, /data-genesis-plan>Save the plan</);
+  assert.match(b.host.innerHTML, /data-genesis-plan-cancel>Keep it as it was</);
+  assert.match(b.host.innerHTML, /value="2" checked/, 'two passes, as saved');
+  assert.match(b.host.innerHTML, /value="cbaas" checked/, 'advisors, as saved');
+  assert.match(b.host.innerHTML, /data-existing checked/, '"it already exists", as saved');
+  assert.match(b.host.innerHTML, /<option value="9" selected>9 days/, 'the stage length, as saved');
+  await click(fakeButton('data-genesis-plan-cancel'));
+  assert.doesNotMatch(b.host.innerHTML, /data-genesis-plan>/, 'keeping it as it was sends nothing and closes the form');
+  assert.ok(!b.calls.some((c) => c.startsWith('POST /founding/plan')));
+});
+
+test('task 1005107: a finished stage\'s answers are changed in place; unchanged sends nothing, a change sends only itself', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'strategize', stage_number: 2, stage_count: 5, day: 3 },
+    plan: { days: {} },
+    tasks: { scope: [{ id: '1', title: 'Scope', status: 'shipped' }], strategize: [{ id: '2', title: 'Strategy', status: 'ready' }] },
+    stageAt: { strategize: '2026-10-08T00:00:00Z' },
+  });
+  const work = {
+    stage: 'scope', page: 'Old page',
+    questions: [
+      { id: 'what_creating', ask: 'What are you creating?', answer: { state: 'answered', text: 'A ledger' } },
+      { id: 'reach_who', ask: 'Who for?', answer: null },
+    ],
+  };
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1', work } });
+  const click = await mountClickable(b);
+  assert.match(b.host.innerHTML, /data-genesis-stage-edit="scope">Change its answers</);
+  await click(fakeButton('data-genesis-stage-edit', 'scope'));
+  assert.ok(b.calls.includes('GET /api/bongos/founding/work/scope'));
+  assert.match(b.host.innerHTML, /<textarea rows="3" data-answer="what_creating">A ledger<\/textarea>/, 'opens with the answer already given');
+  assert.match(b.host.innerHTML, /data-page>Old page</);
+  // Leaving everything as it was sends nothing.
+  const values = { '[data-answer="what_creating"]': 'A ledger', '[data-answer="reach_who"]': '', '[data-page]': 'Old page' };
+  b.host.querySelector = (sel) => (sel in values ? { value: values[sel] } : null);
+  const before = b.calls.length;
+  await click(fakeButton('data-genesis-stage-save'));
+  assert.equal(b.calls.length, before, 'nothing changed: no request');
+  assert.deepEqual(b.toasts.slice(-1), ['Nothing changed.']);
+  // A change sends only that answer.
+  await click(fakeButton('data-genesis-stage-edit', 'scope'));
+  values['[data-answer="reach_who"]'] = 'Small bakeries';
+  const mark = b.calls.length;
+  await click(fakeButton('data-genesis-stage-save'));
+  assert.deepEqual(b.calls.slice(mark), ['PUT /api/bongos/founding/work/scope/answers/reach_who']);
+});
+
+test('task 1005107: a government the plan cannot file is explained in words, never as a code', async () => {
+  const w = world();
+  w.government.proposeCharter = async () => ({ ok: false, reason: 'council_needs_a_rank' });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  const r = await gh.savePlan({ government: 'foundation' }, 1, w.deps());
+  assert.match(r.could_not[0], /needs a council with a rank/);
+  assert.doesNotMatch(r.could_not[0], /needs_council|council_needs/);
+});
+
 test('the hall carries the five life plates byte-identical to the world\'s', () => {
   const world = path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'world');
   const hall = path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis');

package/tests/genesis_work.mjs

@@ -399,6 +399,44 @@ if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
     assert.equal(all.charter.title, 'The charter');
   });
 
+  await test('task 1005107: a stage the Board Room passed is read-only with a plain reason; others stay editable', async () => {
+    let passed = ['scope'];
+    const government = { genesisStageStatus: async () => ({ stages: passed.map((key) => ({ key, state: 'passed' })) }) };
+    const deps = { store: memStore(), government };
+    const w = await gw.setAnswer('scope', 'what_creating', { text: 'A ledger' }, 1, deps);
+    assert.equal(w.ok, false);
+    assert.equal(w.reason, 'stage_closed');
+    assert.match(w.message, /Board Room passed the scope stage/);
+    assert.equal((await gw.setPage('scope', 'x', 1, deps)).reason, 'stage_closed');
+    assert.equal((await gw.setLink('scope', 'https://x.test', 1, deps)).reason, 'stage_closed');
+    assert.equal((await gw.clearAnswer('scope', 'what_creating', 1, deps)).reason, 'stage_closed');
+    const read = await gw.readStage('scope', deps);
+    assert.match(read.work.locked.reason, /fixed/);
+    const doc = (await gw.readDocument('scope', deps)).document;
+    assert.equal(doc.editable, false);
+    assert.match(doc.locked_reason, /what was voted on/);
+    assert.equal((await gw.readDocuments(deps)).scope.editable, false);
+    // A stage not passed stays editable, and so does one with no Board Room at all.
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'Time' }, 1, deps)).ok, true);
+    assert.equal((await gw.setAnswer('scope', 'what_creating', { text: 'A ledger' }, 1, { store: deps.store, government: null })).ok, true);
+    // When the Board Room cannot be read, nothing is written.
+    const broken = { store: deps.store, government: { genesisStageStatus: async () => { throw new Error('down'); } } };
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'Money' }, 1, broken)).reason, 'stage_lock_unknown');
+    passed = [];
+    assert.equal((await gw.setPage('scope', 'Now open again', 1, deps)).ok, true);
+  });
+
+  await test('task 1005107: a fixed stage answers stage_closed whatever was sent, and the board is read once per write', async () => {
+    let reads = 0;
+    const government = { genesisStageStatus: async () => { reads++; return { stages: [{ key: 'charter', state: 'passed' }] }; } };
+    const deps = { store: memStore(), government };
+    assert.equal((await gw.setPage('charter', 'x'.repeat(gw.LIMITS.page + 1), 1, deps)).reason, 'stage_closed', 'not page_too_long');
+    assert.equal((await gw.setAnswer('charter', 'no_such_question', { text: 'x' }, 1, deps)).reason, 'stage_closed', 'not unknown_question');
+    reads = 0;
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'Time' }, 1, deps)).ok, true);
+    assert.equal(reads, 1, 'the write and the read that answers it share one Board Room read');
+  });
+
   console.log(`\ngenesis_work: ${passed} passed, ${failed} failed`);
   if (failed) process.exit(1);
 }

package/tests/genesis_work_routes.mjs

@@ -34,12 +34,15 @@ app.use(express.json());
 const router = express.Router();
 // The project's facts (task 1005129) live in project_settings: an in-memory one here.
 const settings = new Map();
+let passedStages = [];
 mount(router, {
   store,
   getSetting: async (k) => (settings.has(k) ? { key: k, value: settings.get(k) } : null),
   setSetting: async (k, v) => { settings.set(k, String(v)); },
   factsMarker: null,
   payGates: null,
+  // The Board Room (task 1005107): the stages listed in `passedStages` read as passed.
+  government: { genesisStageStatus: async () => { if (!passedStages) throw new Error('board down'); return { stages: passedStages.map((key) => ({ key, state: 'passed' })) }; } },
 });
 app.use('/api/bongos', router);
 const server = app.listen(0);
@@ -100,6 +103,24 @@ try {
     assert.match(r.data.markdown, /Where its builders are: global/);
   });
 
+  await test('task 1005107: a write to a stage the Board Room passed is a 409 that says why', async () => {
+    passedStages = ['legislation'];
+    const r = await call('PUT', '/founding/work/legislation/page', { body: { page: 'x' } });
+    assert.equal(r.status, 409);
+    assert.equal(r.data.error.code, 'stage_closed');
+    assert.match(r.data.error.message, /Board Room passed the legislation stage/);
+    const d = await call('GET', '/founding/work/legislation/document', { as: OTHER });
+    assert.equal(d.data.document.editable, false);
+    passedStages = [];
+    assert.equal((await call('PUT', '/founding/work/legislation/page', { body: { page: 'x' } })).status, 200);
+    // When the Board Room cannot be read, the write is refused as a 503, never let through.
+    passedStages = null;
+    const down = await call('PUT', '/founding/work/legislation/page', { body: { page: 'y' } });
+    assert.equal(down.status, 503);
+    assert.equal(down.data.error.code, 'stage_lock_unknown');
+    passedStages = [];
+  });
+
   await test('a builder who is not the owner cannot write', async () => {
     for (const [m, p, body] of [
       ['PUT', '/founding/work/strategize/answers/risks', { text: 'x' }],

package/tests/github_signup_handoff.mjs

@@ -0,0 +1,135 @@
+// tests/github_signup_handoff.mjs — no GitHub account yet: GitHub's own sign-up page, with
+// "Continue with Google", and back to project creation (task 1005283).
+//
+// WHY. Bongos cannot make a GitHub account for anyone, and every project lives in a GitHub
+// repository. A person with only a Google account used to meet "Continue with GitHub" and
+// nothing else. GitHub's sign-up page offers "Continue with Google", and during an OAuth
+// sign-in GitHub's own screen links it with `return_to` = the authorize step, so the
+// sign-in resumes once the account exists (checked on GitHub's live pages, signed out,
+// 2026-11-13). `?signup=1` on our sign-in start opens THAT page directly.
+//
+// What this pins, by RUNNING the start route's handler (no network, no database):
+//   1. ?signup=1 redirects to https://github.com/signup with return_to = the same
+//      authorize step (same state cookie, same client, same repo scope, same callback);
+//   2. it skips the GitHub-or-Google chooser, which would offer a Bongos Google sign-in
+//      that cannot make a project;
+//   3. a plain sign-in still goes to the authorize step, and ?switch=1 still adds the
+//      account picker (converted here from tests/auth_switch_account.mjs's source read);
+//   4. githubSignupUrl hands on only github.com's own authorize path;
+//   5. the creation page's gate says why GitHub is needed and carries the door, whose
+//      link runs through the route above and returns to /projects?view=new.
+//
+// Run:  node --test tests/github_signup_handoff.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+process.env.BONGOS_GITHUB_CLIENT_ID = process.env.BONGOS_GITHUB_CLIENT_ID || 'gh-test-client';
+process.env.BONGOS_GITHUB_CLIENT_SECRET = process.env.BONGOS_GITHUB_CLIENT_SECRET || 'gh-test-secret';
+// Google sign-in on, so the chooser would show for a plain sign-in: the door must skip it
+process.env.BONGOS_GOOGLE_CLIENT_ID = 'google-test-client';
+process.env.BONGOS_GOOGLE_CLIENT_SECRET = 'google-test-secret';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+// "Continue with Google" is offered only when the hub that keeps Google sign-ins is present
+const seams = require(path.join(ROOT, 'src/module-seams.js'));
+if (!seams.hasProvider('platform-identity.hub')) {
+  seams.registerProvider('platform-identity.hub', { signInWithGoogle: async () => null, recordHubSignin: async () => {} });
+}
+const buildAuthRouter = require(path.join(ROOT, 'src/bongos/routes/auth.js'));
+const { githubSignupUrl } = require(path.join(ROOT, 'src/bongos/auth.js'));
+const { attachFail } = require(path.join(ROOT, 'src/bongos/middleware/error-envelope.js'));
+
+function fakeRes() {
+  const res = {
+    _status: 200, _body: null, _redirect: null, _cookies: {},
+    status(c) { this._status = c; return this; },
+    type() { return this; },
+    send(b) { this._body = b; return this; },
+    json(b) { this._body = b; return this; },
+    set() { return this; },
+    redirect(a, b) { this._redirect = b === undefined ? a : b; return this; },
+    cookie(n, v, o) { this._cookies[n] = { v, o }; return this; },
+    clearCookie() { return this; },
+  };
+  attachFail({}, res, () => {});
+  return res;
+}
+const start = (() => {
+  const layer = buildAuthRouter().stack.find((l) => l.route?.path === '/auth/web/start' && l.route.methods.get);
+  assert.ok(layer, 'GET /auth/web/start exists');
+  return layer.route.stack.at(-1).handle;
+})();
+const req = (query) => ({ query, headers: { host: 'localhost' }, baseUrl: '/api/bongos', body: {} });
+async function run(query) { const res = fakeRes(); await start(req(query), res); return res; }
+
+test('?signup=1 opens GitHub’s sign-up page, which resumes this same sign-in', async () => {
+  const res = await run({ via: 'github', signup: '1', return: '/projects?view=new', repos: '1' });
+  assert.ok(res._redirect, 'a redirect, not the chooser page');
+  const signup = new URL(res._redirect);
+  assert.equal(signup.origin + signup.pathname, 'https://github.com/signup');
+  assert.equal(signup.searchParams.get('source'), 'oauth', 'the same marker GitHub’s own "Create an account" link carries');
+  const back = new URL(signup.searchParams.get('return_to'), 'https://github.com');
+  assert.equal(back.pathname, '/login/oauth/authorize', 'the way back is the authorize step');
+  assert.equal(back.searchParams.get('client_id'), process.env.BONGOS_GITHUB_CLIENT_ID);
+  const stateCookie = Object.values(res._cookies).find((c) => /^[0-9a-f]{32}$/.test(String(c.v)));
+  assert.ok(stateCookie, 'a state cookie is set');
+  assert.equal(back.searchParams.get('state'), stateCookie.v,
+    'the state GitHub hands back is the one in this browser’s cookie, so the callback accepts it');
+  assert.match(back.searchParams.get('scope'), /\brepo\b/, 'the repo access project creation needs is asked once, on the way back');
+  assert.match(back.searchParams.get('redirect_uri'), /\/auth\/web\/callback$/);
+  assert.ok(Object.values(res._cookies).some((c) => c.v === '/projects?view=new'), 'after the callback, the person lands on project creation');
+});
+
+test('the door skips the GitHub-or-Google chooser; a plain sign-in still shows it', async () => {
+  const signup = await run({ signup: '1', return: '/projects?view=new', repos: '1' });
+  assert.match(signup._redirect || '', /^https:\/\/github\.com\/signup\?/, 'no via=github needed: a GitHub sign-up is GitHub');
+  const plain = await run({ return: '/projects?view=new', repos: '1' });
+  assert.equal(plain._redirect, null);
+  assert.match(plain._body, /Continue with GitHub/);
+});
+
+test('without ?signup a sign-in goes to the authorize step, and ?switch=1 still adds the account picker', async () => {
+  const plain = await run({ via: 'github', return: '/projects?view=new', repos: '1' });
+  const p = new URL(plain._redirect);
+  assert.equal(p.origin + p.pathname, 'https://github.com/login/oauth/authorize');
+  assert.equal(p.searchParams.get('prompt'), null);
+  const sw = await run({ switch: '1', return: '/' });
+  const s = new URL(sw._redirect);
+  assert.equal(s.pathname, '/login/oauth/authorize');
+  assert.equal(s.searchParams.get('prompt'), 'select_account', 'a switch reaches GitHub, never the live-session handoff');
+});
+
+test('githubSignupUrl hands on only github.com’s own authorize path', () => {
+  const ok = githubSignupUrl('https://github.com/login/oauth/authorize?client_id=c&state=s&scope=repo');
+  assert.equal(new URL(ok).searchParams.get('return_to'), '/login/oauth/authorize?client_id=c&state=s&scope=repo');
+  for (const bad of [
+    'https://evil.example/login/oauth/authorize?state=s',
+    'http://github.com/login/oauth/authorize?state=s',
+    'https://github.com/settings/tokens',
+    'https://github.com.evil.example/login/oauth/authorize',
+    'not a url',
+    null,
+  ]) assert.equal(githubSignupUrl(bad), null, String(bad));
+});
+
+test('the creation page says why GitHub is needed and offers the door, returning to creation', () => {
+  const hub = fs.readFileSync(path.join(ROOT, 'modules/public-landing/public/projects.html'), 'utf8').replace(/\r\n/g, '\n');
+  const gate = (hub.match(/<section class="panel" id="panel-gate"[\s\S]*?<\/section>/) || [''])[0];
+  assert.ok(gate, 'the gate is findable');
+  assert.match(gate, /<p class="finePrint" id="wizWhyGh">Your project’s files live in a GitHub repository, so it needs a GitHub account\.<\/p>/);
+  const door = gate.match(/<a id="wizSignup" href="([^"]+)">Make one free with Google<\/a>/);
+  assert.ok(door, 'the door sits on the gate');
+  assert.ok(gate.indexOf('id="wizSignin"') < gate.indexOf('id="wizSignup"'), 'under Continue with GitHub, not instead of it');
+  const href = new URL(door[1].replace(/&amp;/g, '&'), 'https://hub.example');
+  assert.equal(href.pathname, '/api/bongos/auth/web/start');
+  assert.equal(href.searchParams.get('signup'), '1');
+  assert.equal(href.searchParams.get('repos'), '1', 'the same repo access the GitHub button asks for');
+  assert.equal(href.searchParams.get('return'), '/projects?view=new');
+  assert.match(gate, /choose <strong>Continue with Google<\/strong>, and you come straight back here/);
+});