@bongos/core 1.19.1008 → 1.19.1009

package/tests/ideator_one_line_path_proof.mjs

@@ -0,0 +1,338 @@
+// tests/ideator_one_line_path_proof.mjs — THE PROOF for spec decision 18
+// (task 1004101 / BV2.R22 of goal 1000095, spec R06a).
+//
+// THE DECISION THIS GUARDS. Spec decision 18 folded the Full Idea form onto the
+// same surface as the one-line composer and called itself "the decision with the
+// most risk in it", because a spark's whole value is that it costs nothing to
+// have. If the fast path picked up an extra step, a scroll or a decision, this
+// scope would have built something beautiful that people stop using — and they
+// would go back to firing one-liners into Discord.
+//
+// WHY THIS IS NOT MORE UNIT TESTS. tests/idea_spark_hall.mjs already asserts
+// that the folded page behaves correctly. What it cannot see is whether the
+// folded page is WORSE THAN THE ONE IT REPLACED, because it only ever boots the
+// current file. A regression in the fast path is not a broken assertion; it is
+// the same page, still working, costing more than it used to. The only way to
+// see that is to measure both.
+//
+// SO THE BASELINE IS THE REAL PRE-FOLD PAGE, not a description of it.
+// tests/fixtures/ideator-prefold/ holds byte copies of
+// modules/hall-ui/public/ideas.{html,js} at commit f375a1f9 — the commit
+// immediately before the fold landed (task 1004087) — carried as .baseline files
+// so the duplication ratchet does not read a frozen copy as copy/paste to collapse
+// (see that folder's README). Both pages are booted through the SAME stub, instrumented the same way, in the same process. A
+// hand-written "before" number would agree with the "after" because the author
+// made it agree; these two can only agree if the code does.
+//
+// WHAT THIS FILE CAN AND CANNOT MEASURE — read this before trusting it.
+// It measures the things that are DETERMINISTIC: how many gestures filing
+// takes, how much the page does before the fast path is usable, where the fast
+// path sits in the document, and what the fast path depends on. It does NOT
+// measure wall-clock, because a wall-clock assertion in CI is a flake and a
+// median over a stub DOM is not a number about the product. The real elapsed
+// time was measured in a browser and is recorded, with its method and its
+// error bars, in docs/governance/bongos-v2-ideator-one-line-path-proof.md.
+// A reader who wants the seconds should go there; what is enforced on every
+// push is below.
+//
+// Pure vm + file read. No DB, no network, no browser.
+//
+// Run:  node tests/ideator_one_line_path_proof.mjs
+
+import { strict as assert } from 'node:assert';
+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 HALL = path.join(ROOT, 'modules/hall-ui/public');
+const PREFOLD = path.join(ROOT, 'tests/fixtures/ideator-prefold');
+
+// The commit the baseline was taken at, so a reader can re-cut it and diff.
+const BASELINE_SHA = 'f375a1f9';
+
+const PAGES = {
+  before: {
+    label: `the page as it was (${BASELINE_SHA}, before the fold)`,
+    js: fs.readFileSync(path.join(PREFOLD, 'ideas.js.baseline'), 'utf8'),
+    html: fs.readFileSync(path.join(PREFOLD, 'ideas.html.baseline'), 'utf8'),
+  },
+  after: {
+    label: 'the page as it is now (folded)',
+    js: fs.readFileSync(path.join(HALL, 'ideas.js'), 'utf8'),
+    html: fs.readFileSync(path.join(HALL, 'ideas.html'), 'utf8'),
+  },
+};
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const TEMPLATE = {
+  key: BASE_TEMPLATE.key,
+  label: BASE_TEMPLATE.label,
+  fields: BASE_TEMPLATE.fields.map((f) => ({
+    key: f.key, label: f.label, required: !!f.required, substance_min: f.substanceMin || 0,
+  })),
+};
+
+const SPARKS = [
+  { id: '77', title: 'Let a builder mute one channel', status: 'open', grade: 'spark', captured_at: '2026-08-01T00:00:00Z', filed_by_login: 'thinker' },
+  { id: '78', title: 'A shared changelog', status: 'open', grade: 'spark', captured_at: '2026-07-30T00:00:00Z', filed_by_login: null },
+];
+const VERSIONS = [{ id: 'BV1', status: 'building' }];
+const GOALS = [{ id: '77', title: 'Goal Seventy Seven', version_id: 'BV1' }];
+
+// ---------------------------------------------------------------------------
+// the instrumented boot — identical for both pages
+// ---------------------------------------------------------------------------
+//
+// THE GESTURE COUNTER IS THE LOAD-BEARING PART. A "gesture" here is one
+// discrete thing a person does with the keyboard or the pointer: focusing a
+// control, changing its value, or pressing something. Typing a title is ONE
+// gesture (a person types a sentence, they do not perform N keystroke
+// decisions), which is the reading that makes the comparison fair — counting
+// keystrokes would let a shorter placeholder look like a faster path.
+//
+// It is counted by INSTRUMENTING THE STUB rather than by reading the source:
+// every value written to a control and every handler fired is recorded, so the
+// count is what the driver below actually had to do to reach a filed spark,
+// on whichever page it was driven against.
+
+function boot(which, { templateOk = true } = {}) {
+  const page = PAGES[which];
+  const els = new Map();
+  const gestures = [];
+  const calls = [];
+
+  const makeEl = (id) => ({
+    id,
+    dataset: {}, style: {}, textContent: '', hidden: false, disabled: false,
+    readOnly: false, tabIndex: 0, _html: '', _handlers: {},
+    _attrs: {}, _classes: new Set(),
+    _value: '',
+    get value() { return this._value; },
+    set value(v) { this._value = String(v == null ? '' : v); },
+    get classList() { const s = this._classes; return { add: (c) => s.add(c), remove: (c) => s.delete(c), contains: (c) => s.has(c) }; },
+    setAttribute(k, v) { this._attrs[String(k)] = String(v); },
+    getAttribute(k) { const v = this._attrs[String(k)]; return v === undefined ? null : v; },
+    addEventListener(t, fn) { this._handlers[t] = fn; },
+    querySelector() { return makeEl('anon'); }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+
+  const documentObj = {
+    title: '', body: { dataset: { page: 'ideas' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl(id)); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl('created'); },
+    addEventListener() {},
+  };
+
+  const client = {
+    inbox: {
+      getInboxTemplate: async () => { calls.push('template'); return templateOk ? { status: 200, ok: true, data: { template: TEMPLATE } } : { status: 500, ok: false, data: null }; },
+      getInboxSparks: async () => { calls.push('sparks'); return { status: 200, ok: true, data: { sparks: SPARKS, count: SPARKS.length } }; },
+      getInboxId: async () => { calls.push('idea'); return { status: 404, ok: false, data: null }; },
+      postInboxScore: async () => { calls.push('score'); return { status: 200, ok: true, data: { score: 60, fields: TEMPLATE.fields.map((f) => ({ key: f.key, substance: 24, floor: 40, ratio: 0.6 })) } }; },
+      postInbox: async (a) => { calls.push('capture'); return { status: 201, ok: true, data: { idea: { id: '910', routing: { routed: false, reason: 'no_goal' } } } }; },
+      postInboxIdDevelop: async () => { calls.push('develop'); return { status: 200, ok: true, data: { idea: {} } }; },
+      postInboxPreviewLanding: async () => { calls.push('preview'); return { status: 200, ok: true, data: { outcome: 'floats', reason: 'no_goal', status: null, goal: null, version_id: null, refusal: null } }; },
+    },
+    versions: { getVersions: async () => { calls.push('versions'); return { status: 200, ok: true, data: { versions: VERSIONS } }; } },
+    goals: {
+      getGoals: async () => { calls.push('goals'); return { status: 200, ok: true, data: { goals: GOALS } }; },
+      getGoalsSuggestions: async () => { calls.push('suggestions'); return { status: 200, ok: true, data: { suggestions: [] } }; },
+    },
+    me: { getMe: async () => { calls.push('me'); return { status: 200, ok: true, data: { task_kinds: ['bug', 'feature'] } }; } },
+  };
+
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    OTB: {
+      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+      $: (sel) => documentObj.querySelector(sel),
+      toast: () => {},
+      fillKindFilter: () => {},
+      kindLabel: (k) => k,
+    },
+    localStorage: { getItem: () => null, setItem: () => {}, removeItem: () => {} },
+    location: { hostname: 'builders.cloudbongos.com', pathname: '/ideas', search: '', hash: '', assign() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, Date };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(page.js, sandbox, { filename: `ideas.js[${which}]` });
+
+  const el = (id) => documentObj.getElementById(id);
+  return {
+    which, label: page.label, html: page.html, calls, gestures, el,
+    // Every driver action below goes through these, so the gesture count is a
+    // record of what was actually done rather than a number someone typed.
+    type(id, text) { gestures.push(`type:${id}`); el(id).value = text; const h = el(id)._handlers.input; if (h) h(); },
+    choose(id, v) { gestures.push(`choose:${id}`); el(id).value = v; const h = el(id)._handlers.change; if (h) h(); },
+    press(id) { gestures.push(`press:${id}`); const h = el(id)._handlers.click; if (h) return h(); return undefined; },
+    async fileIt() {
+      gestures.push('press:fq-submit');
+      return el('fq-form')._handlers.submit({ preventDefault() {} });
+    },
+    submittable() { return typeof el('fq-form')._handlers.submit === 'function'; },
+  };
+}
+
+const settle = () => new Promise((r) => setTimeout(r, 0));
+const boots = async (which, opts) => { const r = boot(which, opts); await settle(); await settle(); await settle(); return r; };
+
+let passed = 0;
+let failed = 0;
+const findings = [];
+async function claim(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (err) { failed++; findings.push(`${name}: ${err.message}`); console.error(`  FAIL  ${name}\n        ${err.message}`); }
+}
+
+console.log('\nTHE ONE-LINE PATH, BEFORE AND AFTER THE FOLD');
+console.log(`  before = ${PAGES.before.label}`);
+console.log(`  after  = ${PAGES.after.label}\n`);
+
+// ---------------------------------------------------------------------------
+// CLAIM 1 — the same gestures
+// ---------------------------------------------------------------------------
+
+await claim('filing one line takes the SAME gestures on both pages, and they are the same gestures', async () => {
+  const drive = async (which) => {
+    const r = await boots(which);
+    r.type('fq-title', 'the hall should remember what I filed');
+    await r.fileIt();
+    await settle();
+    return r;
+  };
+  const before = await drive('before');
+  const after = await drive('after');
+
+  assert.deepEqual(after.gestures, before.gestures,
+    `the gesture sequence changed:\n  before ${JSON.stringify(before.gestures)}\n  after  ${JSON.stringify(after.gestures)}`);
+  // Stated absolutely as well as relatively: two pages that both got WORSE in
+  // the same way would pass the comparison above and nothing else here.
+  assert.deepEqual(after.gestures, ['type:fq-title', 'press:fq-submit'],
+    'the fast path is a title and a press — anything else is a step this decision promised not to add');
+  assert.ok(before.calls.includes('capture') && after.calls.includes('capture'),
+    'and both actually filed — a path that files nothing is not a fast one');
+});
+
+await claim('neither page makes the filer touch the kind or the goal to file', async () => {
+  for (const which of ['before', 'after']) {
+    const r = await boots(which);
+    r.type('fq-title', 'one line');
+    await r.fileIt();
+    await settle();
+    const capture = r.calls.filter((c) => c === 'capture');
+    assert.equal(capture.length, 1, `${which}: filing with nothing but a title reaches the capture route`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 2 — the fast path is usable no later than it was
+// ---------------------------------------------------------------------------
+
+await claim('the form is submittable before ANY read answers — on both pages', async () => {
+  // Deliberately NOT awaited: this is the state of the page in the instant
+  // after its script runs, before a single promise has settled.
+  for (const which of ['before', 'after']) {
+    const r = boot(which);
+    assert.equal(r.submittable(), true,
+      `${which}: the submit handler is attached synchronously, so a fast typist is never racing the network`);
+  }
+  // Honest reading: this was ALREADY true before the fold. It is recorded as a
+  // property preserved, not as an improvement won — see the governance record.
+});
+
+await claim('the folded page does LESS on arrival: no template read, no scoring, no meter', async () => {
+  const before = await boots('before');
+  const after = await boots('after');
+
+  assert.ok(before.calls.includes('template'),
+    'the old page fetched the five questions on arrival whether or not anyone wanted them');
+  assert.ok(!after.calls.includes('template'),
+    'the folded page does not');
+  assert.ok(!after.calls.includes('score'), 'and scores nothing');
+  assert.ok(after.calls.length < before.calls.length,
+    `the folded page issues fewer reads on arrival (before ${before.calls.length}: ${before.calls.join(',')} · after ${after.calls.length}: ${after.calls.join(',')})`);
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 3 — the fast path is not behind anything
+// ---------------------------------------------------------------------------
+
+await claim('the one-line composer moved ABOVE the two things that used to precede it', async () => {
+  const pos = (html, id) => html.indexOf(`id="${id}"`);
+  const b = PAGES.before.html;
+  const a = PAGES.after.html;
+
+  assert.ok(pos(b, 'fi-queue-scroll') < pos(b, 'fq-compose-scroll'),
+    'before: the spark queue came first — the baseline says so itself, so this is measured, not remembered');
+  assert.ok(pos(a, 'fq-compose-scroll') < pos(a, 'fi-queue-scroll'),
+    'after: the one-line composer is first');
+  assert.ok(pos(a, 'fq-compose-scroll') < pos(a, 'fi-compose-scroll'),
+    'and still ahead of the five questions');
+  // The rail is the other half of "how much room the fast path gets".
+  assert.match(b, /class="app-content app-content--railed"/,
+    'before: the column reserved the meter\'s room at every wide width, occupied or not');
+  assert.doesNotMatch(a, /class="[^"]*app-content--railed/,
+    'after: it does not, so the one-line form is drawn at the page\'s full width');
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 4 — the fast path does not depend on the slow one
+// ---------------------------------------------------------------------------
+
+await claim('a totally broken Full Idea half does not slow, block or shout over the fast path', async () => {
+  const before = await boots('before', { templateOk: false });
+  const after = await boots('after', { templateOk: false });
+
+  for (const [which, r] of [['before', before], ['after', after]]) {
+    r.type('fq-title', 'filing while the other half is down');
+    await r.fileIt();
+    await settle();
+    assert.ok(r.calls.includes('capture'), `${which}: the filing still goes through`);
+  }
+  // The difference is what the PAGE says about it. The old page wrote the
+  // template's failure into the page-head subtitle — a failure notice sitting
+  // over a form that was working perfectly well.
+  assert.match(before.el('fi-sub').textContent, /Could not load the idea template/,
+    'before: the page announced a broken half the filer had not asked for');
+  assert.doesNotMatch(after.el('fi-sub').textContent, /Could not load/,
+    'after: a folded half that failed to load says nothing, because nobody opened it');
+});
+
+// ---------------------------------------------------------------------------
+// CLAIM 5 — the guard on this proof
+// ---------------------------------------------------------------------------
+
+await claim('the baseline is the REAL previous page, not a paraphrase of it', async () => {
+  // If someone ever "tidies" the fixture into agreement with the current page,
+  // every comparison above becomes vacuous and still passes. These are the
+  // properties that made the before the before.
+  const b = PAGES.before.js;
+  assert.ok(b.includes('const r = await api.inbox.getInboxTemplate({});'),
+    'the baseline still fetches the template unconditionally in main()');
+  assert.ok(!b.includes('setDisclosure'), 'and knows nothing about a disclosure');
+  assert.ok(!PAGES.before.html.includes('fi-open'), 'and has no toggle in its markup');
+  assert.notEqual(PAGES.before.js, PAGES.after.js, 'the two pages are not the same file');
+});
+
+// ---------------------------------------------------------------------------
+
+console.log('');
+console.log(`ideator_one_line_path_proof: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.error('\nTHE FAST PATH GOT MORE EXPENSIVE. Spec decision 18 is the decision this scope');
+  console.error('flagged as riskiest, and these are its guard rails:');
+  for (const f of findings) console.error(`  - ${f}`);
+  process.exit(1);
+}