@bongos/core 1.19.116 → 1.19.118

package/tests/design_tokens_sync.mjs

@@ -0,0 +1,79 @@
+// tests/design_tokens_sync.mjs — config/design-tokens.neutral.json mirrors the
+// branding pack, never a palette of its own (task 1002752).
+//
+// The repo has two files describing the neutral look: config/branding.neutral.json
+// (the RUNTIME pack — themeMarkup() paints every served page with it) and
+// config/design-tokens.neutral.json (the DESIGN-side tokens feeding the Figma /
+// Claude Design round-trip). Nothing tied them together, so the design file kept
+// the pre-1002749 palette — including the exact accents removed for failing WCAG
+// AA — and every prototype started from colours the product no longer paints.
+// Model: the fallback-equals-pack assertions in tests/devbox_dmg_backdrop.mjs.
+//
+// Run:  node tests/design_tokens_sync.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const readJson = (...p) => JSON.parse(fs.readFileSync(path.join(REPO_ROOT, ...p), 'utf8'));
+
+const pack = readJson('config', 'branding.neutral.json');
+const tokens = readJson('config', 'design-tokens.neutral.json');
+
+// Strip comments so rationale prose — which must be free to name a removed
+// colour — never trips a scan of the CODE (the stripCommentsForIdentity
+// contract, as applied in tests/devbox_dmg_backdrop.mjs).
+function codeOnly(text) {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .split(/\r?\n/)
+    .map((line) => line.replace(/(^|[^:"'])\/\/.*$/, '$1'))
+    .join('\n');
+}
+
+test('every design-token colour is the branding pack value — a divergent token is a fork of the brand', () => {
+  const packColors = pack.theme.ui.colors;
+  assert.deepEqual(
+    Object.keys(tokens.colors || {}).sort(), Object.keys(packColors).sort(),
+    'the design file must carry exactly the pack colour keys — a missing or extra key is drift too, ' +
+    'running through the key set instead of the values');
+  for (const [key, val] of Object.entries(tokens.colors)) {
+    assert.equal(String(val).toLowerCase(), String(packColors[key]).toLowerCase(),
+      `design-token "${key}" must equal the pack's value — a drifted token hands every prototype ` +
+      'a palette the product no longer paints');
+  }
+});
+
+test('the fonts the two files share are the same fonts', () => {
+  const packFonts = pack.theme.ui.fonts;
+  for (const [key, val] of Object.entries(tokens.fonts || {})) {
+    if (!(key in packFonts)) continue; // mono is design-side only — the pack declares no mono surface
+    assert.deepEqual(val, packFonts[key],
+      `design-token font "${key}" must equal the pack's — same drift class as the colours`);
+  }
+});
+
+test('the claude-design adapter falls back to the pack accent, never a brand literal of its own', () => {
+  const source = fs.readFileSync(
+    path.join(REPO_ROOT, 'src', 'ui', 'adapters', 'claude-design', 'index.js'), 'utf8');
+  const block = source.match(/const FALLBACK_ACCENT =[\s\S]*?\}\)\(\);/);
+  assert.ok(block, 'the adapter declares one resolved fallback accent instead of inline literals');
+  assert.match(block[0], /design-tokens\.neutral\.json/,
+    'the fallback resolves from the neutral token file, never a bare literal');
+  for (const hex of block[0].match(/#[0-9a-fA-F]{6}\b/g) || []) {
+    assert.equal(hex.toLowerCase(), String(pack.theme.ui.colors.accent).toLowerCase(),
+      'the catch literal must be the pack ACCENT, not merely some pack colour');
+  }
+  // Every colour literal left in the adapter must be the neutral pack's own value
+  // (i.e. a fallback, not a brand). The preview-card chrome is 3-digit grays, so
+  // a 6-digit literal is exactly the brand-value class.
+  const packValues = new Set(Object.values(pack.theme.ui.colors).map((h) => String(h).toLowerCase()));
+  const hexes = codeOnly(source).match(/#[0-9a-fA-F]{6}\b/g) || [];
+  for (const hex of hexes) {
+    assert.ok(packValues.has(hex.toLowerCase()),
+      `hardcoded colour ${hex} in the claude-design adapter — resolve it from the tokens instead`);
+  }
+});

package/tests/projects_hub.mjs

@@ -228,11 +228,37 @@ test('/create is absorbed — the wizard lives here and the route only redirects
   const server = fs.readFileSync(path.join(ROOT, 'src', 'platform-server.js'), 'utf8');
   assert.match(server, /res\.redirect\(302, '\/projects\?view=new'/,
     '/create must 302 into the hub (302, not 301: the URL is an OAuth return target in the wild)');
-  for (const id of ['panel-gate', 'panel-name', 'panel-home', 'panel-address', 'panel-review', 'panel-done']) {
+  for (const id of ['panel-gate', 'panel-name', 'panel-type', 'panel-home', 'panel-address', 'panel-review', 'panel-done']) {
     assert.match(HUB, new RegExp(`id="${id}"`), `the wizard's ${id} ships as real markup (C7)`);
   }
 });
 
+test('the wizard step indices stay coupled — data-next lands one past its own panel (task 1002772)', () => {
+  // The whole renumbering turns on validateStep(next - 1): a form's data-next
+  // must sit inside panels[next - 1], or the validator guards the wrong step.
+  const pm = SCRIPT.match(/var panels = \{([^}]*)\}/);
+  assert.ok(pm, 'the panels map must exist');
+  const map = {};
+  for (const m of pm[1].matchAll(/(\d+):\s*'([a-z-]+)'/g)) map[Number(m[1])] = m[2];
+  const nexts = [...HUB.matchAll(/data-next="(\d+)"/g)];
+  assert.ok(nexts.length >= 4, 'every wizard form declares its next step');
+  for (const m of nexts) {
+    const before = HUB.slice(0, m.index);
+    const sec = before.lastIndexOf('id="panel-');
+    assert.ok(sec !== -1, 'a data-next form lives inside a panel');
+    const id = HUB.slice(sec + 4).match(/^(panel-[a-z]+)/)[1];
+    assert.equal(id, map[Number(m[1]) - 1],
+      `data-next="${m[1]}" must live in panels[${Number(m[1]) - 1}] — validateStep(next-1) guards that panel`);
+  }
+  for (const m of HUB.matchAll(/data-back="(\d+)"/g)) {
+    assert.ok(map[Number(m[1])], `data-back="${m[1]}" must point at a mapped panel`);
+  }
+  // the rail numbers every step except the gate and the done panel
+  const beats = [...HUB.matchAll(/data-step="(\d+)"/g)].map((x) => Number(x[1]));
+  assert.equal(Math.max.apply(null, beats), Object.keys(map).length - 2,
+    'the rail shows every numbered step except gate and done');
+});
+
 test('the absorbed wizard sheds its two URL landmines — /gate/ and the whole-query strip', () => {
   // create.html carried a document-level Escape that navigated to the retired
   // /gate/ (a 404 the href-only guard above cannot see: it was a
@@ -475,18 +501,21 @@ test('the row keeps its own Open link working underneath the card', () => {
    The mock's columns shipped whole — Project / Builders / Type / Tags / Status
    — but three of them rendered an em dash for every row, forever, because the
    public projection carries four fields and Type/Tags are not in the catalog
-   schema at all. A header promising a column is a claim like any other. ── */
+   schema at all. A header promising a column is a claim like any other.
+   Builders and Runs came back with a source in task 1002771; Type came back in
+   task 1002772 when a project began DECLARING it at creation — a nullable
+   declared field, so an em dash now means "not declared", never a guess. ── */
 
-test('the table declares no column it has no source for', () => {
+test('every table column has a source — Type is declared, never guessed', () => {
   const thead = (HUB.match(/<thead>([\s\S]*?)<\/thead>/) || [, ''])[1];
-  // Type is still absent: the owner's call is that a project DECLARES its type
-  // at creation, so until that field exists the hub must not guess one.
-  assert.doesNotMatch(thead, />Type</, 'Type has no source until a project declares it');
-  // Builders and Runs came back in task 1002771 WITH a source behind them
+  assert.match(thead, />Type</, 'Type has a source now: the project declares it at creation (task 1002772)');
+  assert.match(SCRIPT, /typeHtml\(p\.type\)/, 'the Type cell must read the declared field through the one formatter');
   assert.match(thead, />Builders</);
   assert.match(thead, />Runs</);
   assert.match(SCRIPT, /p\.builders/, 'the Builders cell must read real data');
   assert.match(SCRIPT, /tagsHtml\(p\.tags\)/, 'the Runs cell must read real data');
+  // the wizard files the declaration with the create — the source end of the pipe
+  assert.match(SCRIPT, /type: state\.projType/, 'the create request carries the declared type');
 });
 
 test('header and body agree on the column count', () => {
@@ -509,11 +538,13 @@ test('no sort control is offered for a column that cannot sort', () => {
   }
 });
 
-test('Type left no styling behind, and the live columns kept theirs', () => {
-  assert.ok(!COSMOS.includes('.colType'), '.colType is dead — the column is gone');
-  for (const live of ['.tbl .num', '.tbl .tags', '.colTags']) {
-    assert.ok(COSMOS.includes(live), `${live} styles a column that now renders real data`);
+test('every live column keeps its styling — .colType included since task 1002772', () => {
+  for (const live of ['.tbl .num', '.tbl .tags', '.colTags', '.colType', '.typeTag']) {
+    assert.ok(COSMOS.includes(live), `${live} styles a column that renders real data`);
   }
+  // the type tag is its own vocabulary: not the relationship .pill, not the
+  // liveness .chip — two different facts must not wear the same chrome
+  assert.doesNotMatch(SCRIPT, /typeHtml[\s\S]{0,80}?class="pill"/, 'type must not wear the relationship pill');
 });
 
 /* ── Real Builders + Runs (task 1002771) ────────────────────────────────────