@bongos/core 1.19.864 → 1.19.866

package/tests/helpers.mjs

@@ -281,6 +281,10 @@ export function makeEl(tagName, attrs = {}) {
     attrs,
     children: [],
     parentNode: null,
+    // parentElement — every parent this stub ever creates IS an element (no
+    // text-node parents tracked separately), so it is always the same value
+    // as parentNode; a getter keeps the two from drifting if that changes.
+    get parentElement() { return this.parentNode; },
     className: attrs.class || '',
     id: attrs.id || '',
     name: attrs.name,
@@ -325,6 +329,10 @@ export function makeEl(tagName, attrs = {}) {
       walk(this, (c) => { if (matches(c, sel)) out.push(c); return null; });
       return out;
     },
+    // HTMLSelectElement.options — real <select> elements have it; hall-kit.js's
+    // wirePager() reads `.length` off it before deciding whether to (re)build
+    // the per-page choices.
+    get options() { return this.tagName === 'select' ? this.querySelectorAll('option') : undefined; },
     closest(sel) {
       let node = this;
       while (node) { if (matches(node, sel)) return node; node = node.parentNode; }
@@ -340,6 +348,11 @@ export function makeEl(tagName, attrs = {}) {
     },
     addEventListener(type, fn) { (this.listeners[type] = this.listeners[type] || []).push(fn); },
     focus() {},
+    // HTMLFormElement.reset() — real forms have it, most elements do not, but a
+    // universal no-op is harmless (nothing currently reads a cleared value back)
+    // and lets a page script that calls form.reset() run without a stub-specific
+    // workaround in every test that exercises one.
+    reset() {},
     fire(type, event) { (this.listeners[type] || []).forEach((fn) => fn(event)); },
   };
   for (const [k, v] of Object.entries(attrs)) {

package/tests/joinability_invite_only.mjs

@@ -177,7 +177,17 @@ test('the hall landing renders one door per mode, and its form collapses on the
   assert.match(door, /mode === 'invite_only'/);
   assert.match(door, /there is nothing to apply for here/);
   assert.match(door, /id="access-request-form"/, 'the apply door keeps the request form');
-  assert.match(hall, /\$\{landingDoorHtml\(joinabilityMode\(\)\)\}/, 'renderLanding paints the door the pack names');
+  // This read `${landingDoorHtml(joinabilityMode())}` inline. Task 1004004 gave
+  // the apply door a real sign-in button, so renderLanding resolves the mode
+  // ONCE and hands the same value to both doors. The invariant is unchanged and
+  // now reaches further: BOTH doors are painted from the pack's own answer, so
+  // neither can drift onto a second reading of joinability.
+  const landing = (hall.match(/function renderLanding\(\) \{[\s\S]*?\n  \}\n/) || [''])[0];
+  assert.ok(landing, 'renderLanding() must exist');
+  assert.match(landing, /const mode = joinabilityMode\(\);/, 'the pack names the mode, once');
+  assert.match(landing, /\$\{landingDoorHtml\(mode\)\}/, 'renderLanding paints the door the pack names');
+  assert.match(landing, /\$\{returningDoorHtml\(mode\)\}/, 'and the returning-builder door off the same answer');
+  assert.equal((landing.match(/joinabilityMode\(\)/g) || []).length, 1, 'joinability is read once, not per door');
   assert.match(hall, /code === 'invite_only' \|\| code === 'open_enrollment'/, 'the refusal codes are handled, not shown red');
 });
 

package/tests/task_detail_ui.mjs

@@ -73,6 +73,18 @@ const DEFAULT_SUGGESTIONS = {
   BV1: [{ id: 1000058, title: 'Consumer path', score: 4, matched_terms: ['overlay'] }],
   BV2: [{ id: 1000062, title: 'Idea surfaces', score: 6, matched_terms: ['promote', 'merge'] }],
 };
+// task 1003456: the blocker resolve panel rides the SAME overlay, so it rides
+// the same executing harness — a source-regex test cannot catch the exact
+// class of bug this file's own header names (a ReferenceError inside a submit
+// handler that passes review and 500s at click time).
+const DEFAULT_BLOCKER = {
+  id: 5000042,
+  status: 'open',
+  title: 'Need the owner’s AWS card on file',
+  body_md: 'Raise the S3 budget or approve a spend.',
+  created_at: '2026-09-01T00:00:00.000Z',
+  blocking_task_ids: [],
+};
 
 const escapeHtml = (s) => String(s == null ? '' : s).replace(/[&<>"']/g,
   (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
@@ -89,7 +101,9 @@ function fail(status, code, message) {
 
 async function boot(opts = {}) {
   const {
+    kind = 'idea',
     idea = DEFAULT_IDEA,
+    blocker = DEFAULT_BLOCKER,
     rank = 'metic',
     versions = DEFAULT_VERSIONS,
     suggestions = DEFAULT_SUGGESTIONS,
@@ -98,8 +112,10 @@ async function boot(opts = {}) {
     createdTask = { id: 1003600, title: 'Cover the overlay handlers' },
     createFails = null,
     patchFails = null,
+    resolveFails = null,
     mergeTargets = { 1000900: { id: 1000900, title: 'The canonical idea' } },
   } = opts;
+  const ref = kind === 'blocker' ? blocker : idea;
 
   const requests = [];
   const toasts = [];
@@ -130,6 +146,15 @@ async function boot(opts = {}) {
       }
       if (method === 'POST' && route === '/tasks') return createFails || ok({ task: { ...createdTask, title: body.title } });
       if (method === 'PATCH' && route.startsWith('/inbox/')) return patchFails || ok({ idea: { ...idea, status: body.status } });
+      // task 1003456 — the blocker overlay panel rides the same stub.
+      if (method === 'GET' && route.startsWith('/blockers/')) {
+        const id = Number(route.slice('/blockers/'.length));
+        if (id === Number(blocker.id)) return ok({ blocker });
+        return { status: 404, ok: false, data: null };
+      }
+      if (method === 'POST' && /^\/blockers\/\d+\/resolve$/.test(route)) {
+        return resolveFails || ok({ blocker: { ...blocker, status: 'resolved', resolution_note: body.resolution_note } });
+      }
       return ok({});
     },
   };
@@ -138,7 +163,7 @@ async function boot(opts = {}) {
     hostname: 'builders.example.test',
     pathname: '/builders',
     search: '',
-    hash: `#/idea/${idea.id}`,
+    hash: `#/${kind}/${ref.id}`,
     href: '',
     assign(u) { navigations.push(['assign', u]); },
     replace(u) { navigations.push(['replace', u]); },
@@ -246,6 +271,59 @@ await test('a closed idea offers no triage panel', async () => {
   assert.equal(h.panel(), null, 'a settled idea has nothing left to decide');
 });
 
+// ===========================================================================
+// task 1003456 — the blocker resolve panel, on the SAME overlay
+// ===========================================================================
+
+await test('an open blocker offers a Metic the Resolve panel', async () => {
+  const h = await boot({ kind: 'blocker' });
+  assert.ok(h.overlay(), 'a #deeplink-card overlay is mounted');
+  const p = h.panel();
+  assert.ok(p, 'an open blocker carries the resolve panel');
+  const verbs = p.querySelectorAll('[data-go]').map((b) => b.dataset.go);
+  assert.deepEqual(verbs, ['resolve'], 'one verdict — resolve — not the idea three');
+});
+
+await test('a Xenos gets the blocker card but no resolve panel (the server gate is mirrored, not trusted)', async () => {
+  const h = await boot({ kind: 'blocker', rank: 'xenos' });
+  assert.ok(h.overlay(), 'the record is still readable');
+  assert.equal(h.panel(), null, 'the action is not offered below Metic');
+});
+
+await test('a resolved blocker offers no resolve panel, and says what closed it', async () => {
+  const h = await boot({ kind: 'blocker', blocker: { ...DEFAULT_BLOCKER, status: 'resolved', resolution_note: 'raised the budget' } });
+  assert.equal(h.panel(), null, 'a settled blocker has nothing left to decide');
+  const note = h.overlay().querySelectorAll('.deeplink-card__note').map((n) => n.textContent).join(' | ');
+  assert.match(note, /Resolved: raised the budget/);
+});
+
+await test('resolving posts to the real route, toasts, dispatches otb:blocker-resolved, and closes the overlay', async () => {
+  const h = await boot({ kind: 'blocker' });
+  await h.clickGo('resolve');
+  const form = h.panel().querySelector('[data-form="resolve"]');
+  form.note.value = 'raised the budget';
+  await h.submitForm('resolve');
+  const posts = h.requestsTo('POST', /\/blockers\/5000042\/resolve$/);
+  assert.equal(posts.length, 1, 'exactly one resolve POST');
+  assert.equal(posts[0].body.resolution_note, 'raised the budget');
+  assert.ok(h.toasts.some((t) => /Blocker #5000042 resolved\./.test(t)));
+  assert.equal(h.events.length, 1, 'the otb:blocker-resolved event fired');
+  assert.equal(h.events[0].type, 'otb:blocker-resolved');
+  assert.equal(h.events[0].detail.id, 5000042);
+  assert.equal(h.overlay(), null, 'the overlay closes on a settled verdict, the idea-panel precedent');
+});
+
+await test('a 403 on resolve renders HONEST copy and leaves the form open — never a silent no-op', async () => {
+  const h = await boot({
+    kind: 'blocker',
+    resolveFails: { status: 403, ok: false, data: { error: { code: 'permission_forbidden', message: 'nope' } } },
+  });
+  await h.clickGo('resolve');
+  await h.submitForm('resolve');
+  assert.equal(h.errText(), 'You need Metic+ access to resolve blockers.');
+  assert.ok(h.overlay(), 'the overlay stays open so the builder can see why it failed');
+});
+
 // ===========================================================================
 // Promote — the form the version and goal pickers live on
 // ===========================================================================