@bongos/core 1.19.440 → 1.19.442

package/tests/projects_hub.mjs

@@ -384,9 +384,9 @@ test('the platform has a self entry in the TABLE, not only in the sky', () => {
   // reason: stripApexOnly() is a string transform and cannot reach JS output
   assert.match(HUB, /id="selfOrb"/, 'the sky keeps its self orb');
   assert.match(HUB, /id="selfRow"/, 'the table needs one too — this is the bug');
-  // and the row must sit INSIDE the tbody the renderer owns
-  const tbody = (HUB.match(/<tbody id="mapRows">([\s\S]*?)<\/tbody>/) || [, ''])[1];
-  assert.match(tbody, /id="selfRow"/, 'the self row belongs in #mapRows');
+  // and the row must sit INSIDE the list the renderer owns
+  const rows = (HUB.match(/<ul class="tbl" id="mapRows">([\s\S]*?)<\/ul>/) || [, ''])[1];
+  assert.match(rows, /id="selfRow"/, 'the self row belongs in #mapRows');
 });
 
 test('both self entries are apex-only — a child instance has no "this platform"', () => {
@@ -404,9 +404,9 @@ test('the renderer preserves the self row exactly as it preserves the self orb',
   // delete a static row on the first catalog paint
   assert.doesNotMatch(SCRIPT, /\$\('mapRows'\)\.innerHTML\s*=/,
     'a wholesale innerHTML= on #mapRows destroys the static self row');
-  assert.match(SCRIPT, /querySelectorAll\('tr\[data-generated\]'\)/,
+  assert.match(SCRIPT, /querySelectorAll\('li\[data-generated\]'\)/,
     'generated rows must be removed selectively, like .worldOrb[data-generated]');
-  assert.match(SCRIPT, /<tr data-generated[ >]/, 'generated rows must be markable');
+  assert.match(SCRIPT, /<li class="tblRow" data-generated[ >]/, 'generated rows must be markable');
 });
 
 test('"only mine" no longer hides the platform from a signed-in builder', () => {
@@ -558,7 +558,7 @@ test('the ladder: each region hides on null and the other figure stands alone',
   assert.match(art, /classList\.toggle\('has-art', !!url\)/, 'art switches the whole layout');
   assert.match(SCRIPT, /\$\('cardArt'\)\.addEventListener\('error', function \(\) \{ cardArt\(''\); \}\);/,
     'a broken image demotes to the no-art layout, never a broken glyph');
-  assert.match(SCRIPT, /cardArt\(p\.isSelf \? '' : safeHttpUrl\(p\.art_url\)\)/, 'the art URL is scheme-checked client-side too');
+  assert.match(SCRIPT, /safeHttpUrl\(p\.art_url\)\)\);/, 'the art URL is scheme-checked client-side too (behind the owner\'s plate since task 1003352)');
 });
 
 test('exactly one hall-URL derivation: the DOM for the hub, the feed for a project, safeHttpUrl for both, and only where the hall is elsewhere', () => {
@@ -573,11 +573,11 @@ test('exactly one hall-URL derivation: the DOM for the hub, the feed for a proje
   assert.equal((SCRIPT.match(/isMember\(rel\) \? hallUrlOf\(p\) : ''/g) || []).length, 2, 'member-gated on the card AND on the row, one rule');
   assert.match(SCRIPT, /'<a class="cardHall" id="cardHall" href="' \+ esc\(hall\)/, 'the card\'s hall door is escaped');
   assert.match(SCRIPT, /'<a class="rowHall" href="' \+ esc\(hall\) \+ '" target="_blank" rel="noopener"/, 'the row\'s hall glyph is escaped and opens a new tab');
-  assert.match(SCRIPT, /: ''\) \+ hallGlyphHtml\(p, rel\) \+ '<\/td>'/, 'the glyph rides the existing door cell — no seventh column');
+  assert.match(SCRIPT, /: ''\) \+ hallGlyphHtml\(p, rel\) \+ '<\/div>'/, 'the glyph is the row\'s SECOND door, inside the one door slot — never a third');
 });
 
 test('the platform row carries a stamped, hidden hall glyph the session unhides — same tab, no target', () => {
-  const selfRow = (HUB.match(/<tr id="selfRow">([\s\S]*?)<\/tr>/) || [, ''])[1];
+  const selfRow = (HUB.match(/<li class="tblRow" id="selfRow">([\s\S]*?)\r?\n\s*<\/li>/) || [, ''])[1];
   assert.match(selfRow, /<a class="rowHall" id="selfHall" href="\{\{buildersOrigin\}\}"[^>]*hidden>/, 'server-stamped and hidden until the session says member');
   assert.match(SCRIPT, /if \(sh\) sh\.hidden = !badge \|\| !hallUrlOf\(SELF_PROJECT\);/, 'member-gated and address-gated, and null-safe: the stamp drops the anchor whole when a pack names no hall');
   assert.match(SCRIPT, /if \(p\.isSelf\) \{\r?\n\s*var a = \$\('selfHall'\);/);
@@ -614,7 +614,7 @@ test('the poster is in the world: 560 wide, one hairline, no shadow, the disc su
   assert.match(COSMOS, /\.projCard \.cardMeta dd\{[^}]*text-align:right[^}]*border-top:1px solid var\(--rule-soft\)/, 'the value right and on the same hairline');
   assert.match(COSMOS, /\.projCard \.cardRel\{[^}]*font-family:var\(--label-face\)/, 'the relationship is a mono label, not an accent pill');
   assert.doesNotMatch(COSMOS, /\.projCard \.cardMeta \.tags/, 'the card no longer renders the module list');
-  assert.match(COSMOS, /\.rowHall\{[^}]*width:28px;height:28px/, 'the row glyph clears the 24px floor');
+  assert.match(COSMOS, /\.rowHall\{[^}]*width:44px;height:40px/, 'the row\'s second door is a door, not a glyph: the same 40px the "view" pill stands at');
 });
 
 test('the row keeps its own Open link working underneath the card', () => {
@@ -631,14 +631,16 @@ test('the row keeps its own Open link working underneath the card', () => {
    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('every table column has a source — Type is declared, never guessed', () => {
-  const thead = (HUB.match(/<thead>([\s\S]*?)<\/thead>/) || [, ''])[1];
-  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');
+test('every fact the row states has a source — Type is declared, never guessed', () => {
+  // the header row left with the table (task 1003356): a fact is a line now, so
+  // what once had to be a column with a source is a line with a source
+  const facts = (SCRIPT.match(/function factLines\(p\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
+  assert.ok(facts, 'factLines() must exist');
+  assert.match(facts, /typeHtml\(p\.type\)/, 'the Type line must read the declared field through the one formatter');
+  assert.match(facts, /p\.builders/, 'the Builders line must read real data');
+  assert.match(facts, /shippedFigure\(p\)/, 'shipped-in-30-days is the feed\'s own figure, capped mark and all');
+  assert.match(facts, /listedDate\(p\.created_at\)/, 'the Listed date is the catalog\'s');
+  assert.match(SCRIPT, /tagsHtml\(p\.tags\)/, 'the Runs line 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');
 });
@@ -712,13 +714,20 @@ test('a renumbering of the wizard invalidates old drafts — the key carries the
   assert.equal(count, 8, 'gate + six numbered steps + done — bump DRAFT_KEY when this changes');
 });
 
-test('header and body agree on the column count', () => {
-  // a stray <td> shifts every cell after it — silent, and only visible on screen
-  const n = ((HUB.match(/<thead>([\s\S]*?)<\/thead>/) || [, ''])[1].match(/<th/g) || []).length;
-  const selfRow = (HUB.match(/<tr id="selfRow">([\s\S]*?)<\/tr>/) || [, ''])[1];
-  const generated = (SCRIPT.match(/return '<tr data-generated([\s\S]*?)'<\/tr>';/) || [, ''])[1];
-  assert.equal((selfRow.match(/<td/g) || []).length, n, 'the self row must match the header');
-  assert.equal((generated.match(/<td/g) || []).length, n, 'a generated row must match the header');
+test('every row lays the same five parts — the ledger has no ragged row', () => {
+  // a stray <td> used to shift every cell after it; the ledger's version of that
+  // bug is a row that skips one grid area, which silently collapses its track
+  const selfRow = (HUB.match(/<li class="tblRow" id="selfRow">([\s\S]*?)\r?\n\s*<\/li>/) || [, ''])[1];
+  const generated = (SCRIPT.match(/return '<li class="tblRow" data-generated([\s\S]*?)'<\/li>';/) || [, ''])[1];
+  assert.ok(selfRow && generated, 'both row templates must keep their extractable shape');
+  // the generated row builds its planet into a local first, so the parts test
+  // reads that expression too — otherwise dropping the planet would go unseen
+  const planet = (SCRIPT.match(/var planet = '<span class="worldOrb"[\s\S]*?;\r?\n/) || [''])[0];
+  for (const part of ['worldOrb', 'tWho', 'facts', 'ptag', 'runs', 'rowDoors']) {
+    assert.match(selfRow, new RegExp('class="[^"]*\\b' + part + '\\b'), `the self row is missing its ${part}`);
+    assert.match(generated + planet, new RegExp('class="[^"]*\\b' + part + '\\b'), `a generated row is missing its ${part}`);
+  }
+  assert.match(generated, /' \+ planet \+/, 'the generated row plants the planet it built');
 });
 
 test('no sort control is offered for a column that cannot sort', () => {
@@ -735,22 +744,25 @@ test('no sort control is offered for a column that cannot sort', () => {
 test('the table is in the world: a masthead, then ledger rows — no panel, no shadow, the accent only on the row\'s door (task 1003332)', () => {
   // the owner's pick from three rendered treatments: the view title in the display
   // voice and one chrome object; the title is two words ("every project", the owner cut ", as rows")
-  assert.match(HUB, /<div class="tblMast">\s*<h2 class="tblTitle">every project<\/h2>\s*<span class="mastObj" aria-hidden="true"><\/span>\s*<\/div>\s*<table class="tbl">/, 'one masthead ahead of the table');
+  assert.match(HUB, /<div class="tblMast">\s*<h2 class="tblTitle">every project<\/h2>\s*<span class="mastObj" aria-hidden="true"><\/span>\s*<\/div>/, 'one masthead ahead of the rows');
   assert.doesNotMatch(HUB, /tblMast--t[123]|data-tbl|mastCallouts|mastField/, 'the render round\'s switch and the unpicked mastheads left with the pick');
-  assert.match(COSMOS, /\.tbl\{width:100%;border-collapse:collapse;background:none;\}/, 'the rows sit on the page ground — no card');
-  assert.doesNotMatch((COSMOS.match(/\.tbl\{[^}]*\}/) || [''])[0], /border-radius|box-shadow/, 'no radius, no shadow on the table');
-  assert.match(COSMOS, /\.tbl td\{padding:17px 14px;border-bottom:1px solid var\(--rule-soft\);/, 'ledger rows: hairlines');
-  assert.match(COSMOS, /\.tbl tbody tr:hover td\{border-bottom-color:var\(--ink-faint\);\}/, 'hover is the hairline taking ink, not an accent tint');
-  assert.match(COSMOS, /\.rowGo\{[^}]*color:var\(--accent-deep\);text-decoration:underline;/, 'the row\'s door is accent text');
-  assert.match(HUB, /<a class="rowGo" href="\/">Open →<\/a>/, 'the self row\'s door');
+  // the table itself left with task 1003356: a list of ledger rows, no header
+  // row, no cell borders, no <table> wearing a role it no longer has
+  assert.doesNotMatch(HUB, /<table class="tbl">|<thead>|<th class="col/, 'the table markup, its header row and its cells are gone');
+  assert.match(COSMOS, /\.tbl\{list-style:none;margin:0;padding:0;\}/, 'the rows sit on the page ground — no card, no table');
+  assert.doesNotMatch((COSMOS.match(/\.tbl\{[^}]*\}/) || [''])[0], /border-radius|box-shadow/, 'no radius, no shadow on the list');
+  assert.match(COSMOS, /\.tbl \.tblRow:last-child\{border-bottom:1px solid var\(--rule-soft\);\}/, 'ledger rows: hairlines, and the last one closes');
+  assert.match(COSMOS, /\.tbl \.tblRow:hover\{border-top-color:var\(--ink-faint\);\}/, 'hover is the hairline taking ink, not an accent tint');
+  assert.match(COSMOS, /\.rowGo\{[^}]*border:1px solid var\(--rule\);border-radius:var\(--radius-pill\);/, 'the row\'s door is the mine row\'s hairline pill');
+  assert.match(HUB, /<a class="rowGo" href="\/">view<\/a>/, 'the self row\'s door');
   assert.match(SCRIPT, /'<a class="rowGo" href="' \+ esc\(safeHttpUrl\(p\.origin\)\)/, 'the generated rows\' door');
   assert.match(COSMOS, /\.mastObj\{display:block;--dia:clamp\(96px,10vw,132px\);[^}]*background-image:var\(--plate-set-cut\);/, 'the object is the set\'s small bead by token, in both modes');
   assert.doesNotMatch(COSMOS, /mix-blend-mode:var\(--mast/, 'the cutout needs no blend — the view wrap is a stacking context');
 });
 
-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`);
+test('every live part of the row keeps its styling — .typeTag included since task 1002772', () => {
+  for (const live of ['.tbl .facts', '.tbl .runs', '.tbl .tags', '.tbl .ptag', '.typeTag']) {
+    assert.ok(COSMOS.includes(live), `${live} styles a part of the row 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
@@ -766,8 +778,11 @@ test('every live column keeps its styling — .colType included since task 10027
 test('unknown and zero are rendered as different things', () => {
   // 0 builders is a real answer — "nobody has joined yet". null is not an
   // answer at all. Collapsing them would restate the lie 1002764 removed.
-  assert.match(SCRIPT, /p\.builders == null \? '—'/,
-    'only null becomes a dash; 0 must render as 0');
+  // since task 1003356 the fact is a line, so the two answers are two sentences
+  assert.match(SCRIPT, /p\.builders == null \? 'builders not known'/,
+    'only null says "not known"');
+  assert.match(SCRIPT, /esc\(String\(p\.builders\)\) \+ \(p\.builders === 1 \? ' builder' : ' builders'\)/,
+    '0 must render as "0 builders" — a real answer, not an absence');
 });
 
 test('a project that cannot be reached degrades to a dash, not to a wrong number', () => {
@@ -796,7 +811,7 @@ test('each card fact is wired to its data, not just present in the markup', () =
   assert.match(SCRIPT, /cardFact\('cardRuns', runsOf\(p\)\)/, 'runs is the address on the poster');
   const runs = (SCRIPT.match(/function runsOf\(p\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
   assert.match(runs, /hostOf\(p\.origin\)/, 'the address is the catalog origin\'s host');
-  assert.match(SCRIPT, /'<td class="colTags">' \+ tagsHtml\(p\.tags\)/, 'the table row keeps the module list');
+  assert.match(SCRIPT, /'<div class="runs"><span class="rLbl">runs<\/span>' \+ tagsHtml\(p\.tags\)/, 'the table row keeps the module list, under its own label');
   assert.match(SCRIPT, /cardFact\('cardOwner', rel === 'owner' \? '' : ownerHtml\(p\), true\)/,
     'owner comes from the enrichment and yields to the rel chip saying "yours"');
   const oh = (SCRIPT.match(/function ownerHtml\(p\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
@@ -907,21 +922,21 @@ test('the card metadata block lives inside the card, not a hideable sub-view', (
    ignores clicks inside an <a> so real links keep their jobs — but this link
    had no job, so the click was swallowed AND went nowhere. ── */
 
-test('the self row Open is a real link home, not an unwired hook', () => {
-  const selfRow = (HUB.match(/<tr id="selfRow">([\s\S]*?)<\/tr>/) || [, ''])[1];
-  assert.match(selfRow, /<a[^>]*href="\/"[^>]*>Open/,
-    'the platform project IS this site — its Open navigates to /');
+test('the self row\'s door is a real link home, not an unwired hook', () => {
+  const selfRow = (HUB.match(/<li class="tblRow" id="selfRow">([\s\S]*?)\r?\n\s*<\/li>/) || [, ''])[1];
+  assert.match(selfRow, /<a[^>]*href="\/"[^>]*>view/,
+    'the platform project IS this site — its door navigates to /');
   assert.doesNotMatch(selfRow, /target=/,
     'a new tab for the page you are already on is a bug, not a courtesy');
   assert.doesNotMatch(HUB, /data-self-open/, 'the never-wired hook must not survive');
 });
 
-test('no anchor in the table ships a placeholder href', () => {
+test('no anchor in the every-project list ships a placeholder href', () => {
   // href="#" is the shape of this bug: a dead link wearing button clothes
-  const table = (HUB.match(/<table[\s\S]*?<\/table>/) || [''])[0];
-  assert.ok(table, 'the table must be findable');
-  assert.doesNotMatch(table, /href="#"/, 'no anchor in the table may ship href="#"');
-  const generated = (SCRIPT.match(/return '<tr data-generated([\s\S]*?)'<\/tr>';/) || [, ''])[1];
+  const rows = (HUB.match(/<ul class="tbl" id="mapRows">[\s\S]*?<\/ul>/) || [''])[0];
+  assert.ok(rows, 'the list must be findable');
+  assert.doesNotMatch(rows, /href="#"/, 'no anchor in the list may ship href="#"');
+  const generated = (SCRIPT.match(/return '<li class="tblRow" data-generated([\s\S]*?)'<\/li>';/) || [, ''])[1];
   assert.doesNotMatch(generated, /href="#"/, 'generated rows must not ship placeholders either');
 });
 
@@ -958,11 +973,11 @@ test('a project both featured and owned renders once, marked owned', () => {
 test('owned truth reaches the TABLE too — same list, same chip, same manage job', () => {
   // the count, the sky and the table read ONE merged browse list; an owned row
   // carries chipFor()'s truth in Status and routes its click to manage
-  const generated = (SCRIPT.match(/return '<tr data-generated([\s\S]*?)'<\/tr>';/) || [, ''])[1];
+  const generated = (SCRIPT.match(/return '<li class="tblRow" data-generated([\s\S]*?)'<\/li>';/) || [, ''])[1];
   assert.ok(generated, 'the generated-row template must keep its extractable shape');
   assert.match(generated, /data-manage/, 'an owned row carries the manage route key');
-  assert.match(generated, /p\._inst \? chipFor\(p\._inst\)/, 'an owned row\'s Status is the overlay truth');
-  assert.match(generated, /chip calm/, 'an unprobed catalog row keeps the honest calm dash');
+  assert.match(generated, /p\._inst \? chipFor\(p\._inst\)/, 'an owned row\'s chip is the overlay truth');
+  assert.match(generated, /chip calm[\s\S]{0,80}not checked/, 'an unprobed catalog row says so in words beside the name');
   assert.match(SCRIPT, /tr\.hasAttribute\('data-manage'\)\) return goToManage/,
     'an owned row click goes to manage, exactly like its orb');
 });
@@ -1767,10 +1782,10 @@ test('the kit proves the picker: a state renders it on the owner\'s feed-carried
   assert.match(stub, /planet: PLANETS\.get\(String\(id\)\) \|\| NO_PLANET/, 'and answers it on the settings read and the receipt');
 });
 
-test('the feed carries the owner\'s choice through a seam: platform-identity resolves provisioning.projectPlanets optionally and spreads both keys on every project (task 1003347)', () => {
+test('the feed carries the owner\'s choice through a seam: platform-identity resolves provisioning.projectPlanets optionally and spreads every platform-drawn key on every project (tasks 1003347, 1003352)', () => {
   const route = fs.readFileSync(path.join(ROOT, 'modules', 'platform-identity', 'routes', 'projects.js'), 'utf8');
   assert.match(route, /api\.resolveOptional\('provisioning\.projectPlanets', async \(\) => \(\{\}\)\)\(projects\.map\(\(p\) => hostOfOrigin\(p\.origin\)\)\)/, 'optional — an instance without provisioning has no choices to carry');
-  assert.match(route, /return \{ planet_template: c\.planet_template \|\| null, planet_accent: c\.planet_accent \|\| null \};/, 'the wire always carries both keys');
+  assert.match(route, /return \{ planet_template: c\.planet_template \|\| null, planet_accent: c\.planet_accent \|\| null,\r?\n\s*card_backdrop: c\.card_backdrop \|\| null \};/, 'the wire always carries every key — null = nothing chosen');
   assert.match(route, /\.\.\.planetOf\(p\),/, 'spread beside the stats');
   assert.doesNotMatch(route, /require\(['"][^'"]*provisioning/, 'never an import across modules');
   const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules', 'provisioning', 'module.json'), 'utf8'));
@@ -1783,25 +1798,118 @@ test('the feed carries the owner\'s choice through a seam: platform-identity res
 
 /* ── the table's columns on FIXED tracks (task 1003348; the owner, 2026-08-29: "the
    columns in that projects table view dont look aligned") ── */
-test('one column grammar: the table lays every row on one set of fixed tracks (each header over its cells), and the mine list shares the rule', () => {
-  assert.match(COSMOS, /\.tbl\{table-layout:fixed;min-width:860px;\}/, 'the header row\'s widths are the table\'s — no per-row content sizing');
-  // the task's other half — the Your projects list — landed with task 1003345 and is pinned above
-  // ('the mine list lays every row on one set of FIXED tracks'); it is asserted here too so the two
-  // halves of the grammar can never drift apart: fixed planet + doors, ratio tracks with no content minimum
+test('one row grammar: the every-project row and the Your-projects row lay the SAME five tracks', () => {
+  // task 1003348 aligned the two views on one set of fixed tracks while one was
+  // still a table; task 1003356 gave the table the mine row's whole grammar, so
+  // the tracks must now match line for line or the two ledgers drift apart
   assert.match(COSMOS, /#view-mine \.proj\{display:grid;grid-template-columns:72px minmax\(0,1fr\);/, 'the mine row: the planet track is a width');
   assert.match(COSMOS, /#view-mine \.projBody\{display:grid;grid-template-columns:minmax\(0,1\.1fr\) minmax\(0,1\.3fr\) minmax\(0,1fr\) 232px;/, 'the mine row: name, facts and rail by ratio with no content minimum, the doors a width');
-  assert.match(COSMOS, /the same column grammar the every-project table takes/, 'the mine block names the table as its twin');
-  for (const [col, w] of [['colType', 88], ['colBuilders', 96], ['colTags', 168], ['colStatus', 224], ['colGo', 112]]) {
-    assert.match(COSMOS, new RegExp(`\\.tbl th\\.${col}\\{width:${w}px;\\}`), `${col} is a width, not a 1% hug`);
-  }
-  assert.doesNotMatch(COSMOS, /\.tbl \.col\w+\{width:1%/, 'no column hugs its widest cell any more');
-  assert.match(COSMOS, /\.tbl th\.colName\{padding-left:22px;\}/, 'the Project header sits over the name, past the dot and its gap');
-  assert.match(COSMOS, /\.tbl th\.right\{text-align:right;\}/, 'a right-aligned column\'s header is right-aligned too');
-  assert.match(HUB, /<th class="right colBuilders" data-sort="builders">/, 'the builders header names its column so its width can be set');
-  assert.match(COSMOS, /@media \(max-width:780px\)\{\.tbl \.colTags,\.tbl \.colType\{display:none;\}\.tbl\{min-width:600px;\}\}/, 'a phone scrolls the table inside its wrap');
+  assert.match(COSMOS, /\.tbl \.tblRow\{display:grid;\r?\n\s*grid-template-columns:72px minmax\(0,1\.1fr\) minmax\(0,1\.3fr\) minmax\(0,1fr\) 232px;/, 'the table row: the same five tracks, composed into one grid');
+  assert.match(COSMOS, /grid-template-areas:"orb who facts runs doors" "orb who tag runs doors";/, 'runs where the mine row draws its rail, the tagline where it puts its address');
+  assert.match(COSMOS, /the SAME five tracks in its \S\.tbl \.tblRow\S rule/, 'the mine block names the table as its twin');
+  assert.doesNotMatch(COSMOS, /table-layout:fixed|\.tbl th|\.tbl td/, 'no table rule outlived the table');
   assert.match(COSMOS, /#sub-table-body\{overflow-x:auto;\}/, 'the wrap scrolls, never the page');
 });
 
+test('the sort left the column head for a control the keyboard and a screen reader can both read (task 1003356)', () => {
+  // aria-sort is only valid on a columnheader; with no header row the order has
+  // to be stated by the control itself and by a sentence in a live region
+  assert.doesNotMatch(HUB, /aria-sort=/, 'aria-sort has no host once the header row is gone');
+  assert.match(HUB, /<div class="tblSort" role="group" aria-label="Sort the projects">/, 'the two orders are one group');
+  for (const k of ['name', 'builders']) {
+    assert.match(HUB, new RegExp(`<button type="button" class="sortPill" data-sort="${k}"`), `${k} is a real button`);
+  }
+  assert.match(HUB, /<p class="finePrint" id="mapSorted" role="status" aria-live="polite">/, 'the live order is announced, not only drawn');
+  assert.match(SCRIPT, /b\.setAttribute\('aria-pressed', on \? 'true' : 'false'\)/, 'pressed IS the live order');
+  assert.match(SCRIPT, /mapSort\.dir = \(mapSort\.key === k\) \? -mapSort\.dir : 1;/, 'pressing the pressed one reverses, exactly as the header did');
+  assert.match(SCRIPT, /\$\('mapSorted'\)\.textContent = 'Sorted by '/, 'the sentence is written from the same state the pills paint from');
+  assert.match(COSMOS, /\.tblSort button\[aria-pressed="true"\]\{background:var\(--ink\);border-color:var\(--ink\);color:var\(--bg\);\}/, 'the pressed pill inverts to ink, the mine filters\' rule');
+  assert.match(COSMOS, /\.tblSort button:focus-visible\{outline:2px solid var\(--accent\);outline-offset:2px;\}/, 'keyboard focus on the sort is visible');
+});
+
+/* ── the card's backdrop (task 1003352): the owner's plate, beside the planet ── */
+
+test('the kit stub refuses what the real route refuses, and its copied vocabulary cannot rot', async () => {
+  // A kit module may not import core, so serve.js copies the closed lists. The
+  // copy is what matters: it stayed permissive through a whole probe run while
+  // the real PATCH would have 400'd on card_backdrop (task 1003352, grade round
+  // 2), so the stub now validates — and this pins the copy to its source.
+  const stub = fs.readFileSync(path.join(ROOT, 'modules', 'ui-design', 'kit', 'serve.js'), 'utf8');
+  assert.match(stub, /function settingsRejection\(body\)/, 'the stub validates a settings body');
+  assert.match(stub, /if \(bad\) return json\(res, 400, \{ error: \{ code: 'validation_failed'/, 'and answers the real code');
+  const provisioning = createRequire(import.meta.url)('../modules/provisioning/provisioning.js');
+  const block = (stub.match(/const STUB_VOCAB = \{([\s\S]*?)\n\};/) || [, ''])[1];
+  assert.ok(block, 'STUB_VOCAB must keep its extractable shape');
+  const real = { ...provisioning.SETTINGS_VOCAB, ...provisioning.PLANET_VOCAB };
+  for (const [key, values] of Object.entries(real)) {
+    assert.match(block, new RegExp(`\\b${key}:`), `the stub must know ${key}`);
+    if (key === 'planet_template') continue;   // the template set is long: shape is checked, not membership
+    for (const v of values) assert.match(block, new RegExp(`'${v}'`), `the stub's ${key} is missing ${v}`);
+  }
+});
+
+test('the card backdrop is the same KIND of key as the planet: a closed platform-drawn list on the same channel, pushing nothing', () => {
+  const prov = fs.readFileSync(path.join(ROOT, 'modules', 'provisioning', 'provisioning.js'), 'utf8');
+  assert.match(prov, /const CARD_BACKDROPS = Object\.freeze\(\['nebula', 'dust', 'deepfield', 'chrome'\]\);/, 'a closed list, frozen');
+  // riding PLANET_VOCAB is the whole point: planetChoice() loops it, the settings
+  // route builds its validator and its settingKeys from it, and publicInstance
+  // spreads it — so the key reaches the row, the read and the wire with no new branch
+  assert.match(prov, /planet_template: PLANET_TEMPLATES, planet_accent: PLANET_ACCENTS, card_backdrop: CARD_BACKDROPS,/, 'it rides the platform-drawn vocab');
+  // and the route's SCHEMA is that vocab, not a copy of it: a hand-written list
+  // is what let card_backdrop reach settingKeys while strict validation still
+  // 400'd every real save (grade round 2)
+  const settingsRoute = fs.readFileSync(path.join(ROOT, 'modules', 'provisioning', 'routes', 'provisioning.js'), 'utf8');
+  assert.match(settingsRoute, /const vocabSchema = \(vocab\) => Object\.fromEntries\(/, 'the schema is derived');
+  assert.match(settingsRoute, /\.\.\.vocabSchema\(provisioning\.SETTINGS_VOCAB\),\r?\n\s*\.\.\.vocabSchema\(provisioning\.PLANET_VOCAB\),/, 'from both vocabularies');
+  assert.doesNotMatch(settingsRoute, /planet_template: \{ type: 'string', enum: provisioning\.PLANET_VOCAB/, 'no hand-written key survives to drift');
+  assert.match(prov, /if \(Object\.values\(choice\)\.some\(Boolean\)\) out\[r\.host\] = choice;/, 'a host that chose ONLY a backdrop still reaches the feed');
+  const route = fs.readFileSync(path.join(ROOT, 'modules', 'platform-identity', 'routes', 'projects.js'), 'utf8');
+  assert.match(route, /card_backdrop: c\.card_backdrop \|\| null/, 'the wire always carries the key — null = nothing chosen');
+});
+
+test("the card paints the owner's plate before the project's own picture, and a key the platform does not draw paints nothing", () => {
+  assert.match(SCRIPT, /cardArt\(p\.isSelf \? '' : \(backdropPlate\(p\.card_backdrop\) \|\| safeHttpUrl\(p\.art_url\)\)\);/,
+    "the plate wins; the project's own art is the fallback, which is all the card read before");
+  const fn = (SCRIPT.match(/function backdropPlate\(key\)\s*\{([\s\S]*?)\n  \}/) || [, ''])[1];
+  assert.ok(fn, 'backdropPlate() must exist');
+  assert.match(fn, /CARD_PLATES\[key\] \? '\/assets\/world\/' \+ CARD_PLATES\[key\] : ''/,
+    'an unknown key — a row written before a plate was retired — must never become a broken src');
+  const plates = (SCRIPT.match(/var CARD_PLATES = \{([^}]*)\}/) || [, ''])[1];
+  const offered = (SCRIPT.match(/var CARD_BACKDROPS = ([\s\S]*?);\r?\n/) || [, ''])[1];
+  for (const k of ['nebula', 'dust', 'deepfield', 'chrome']) {
+    assert.match(plates, new RegExp(`\\b${k}\\b`), `${k} has a plate`);
+    assert.match(offered, new RegExp(`'${k}'`), `${k} is offered in the picker`);
+  }
+});
+
+test('every plate the picker offers ships as a real file with its provenance sidecar', () => {
+  for (const k of ['nebula', 'dust', 'deepfield', 'chrome']) {
+    const file = path.join(ROOT, 'public-landing', 'assets', 'world', `r4-card-${k}.jpg`);
+    assert.ok(fs.existsSync(file), `r4-card-${k}.jpg must ship — the picker offers it`);
+    const side = JSON.parse(fs.readFileSync(`${file}.json`, 'utf8'));
+    assert.equal(side.task, 1003352, 'the sidecar names the task that made it');
+    assert.ok(side.model && side.prompt, 'and the model and the prompt, so it can be remade');
+    assert.equal(side.aspect_ratio, '5:2', "a card band, not a field ground — the reason this round existed");
+  }
+});
+
+test("its card is the planet section's twin: its own heading, the same channel, no restart", () => {
+  // beside the planet rather than inside it, so each heading stays true: one is
+  // how the project is drawn everywhere, the other is one surface's backdrop
+  assert.match(HUB, /<div class="card mSec" id="mCard">\s*<h2>Its card<\/h2>/, 'its own section');
+  assert.ok(HUB.indexOf('id="mCard"') > HUB.indexOf('id="mPlanetPick"'), 'and it stands after the planet, where the owner asked for it');
+  assert.match(SCRIPT, /body: JSON\.stringify\(\{ card_backdrop: mCard \|\| null \}\)/, "the save is the settings PATCH; '' hands the pick back as null");
+  assert.match(SCRIPT, /manageInst\.card_backdrop = \(data\.planet \|\| \{\}\)\.card_backdrop \|\| null;/,
+    'the reply is a receipt — the page repaints from the row, never from words in the reply');
+  assert.match(SCRIPT, /renderPick\(inst\);\r?\n\s*renderCardPick\(inst\);/, 'both sections fill from the same manage read');
+  const states = JSON.parse(fs.readFileSync(path.join(ROOT, 'public-landing', 'projects.states.json'), 'utf8'));
+  assert.ok(states.states['in-manage-card'], 'the section has a rendered state');
+  const probes = JSON.parse(fs.readFileSync(path.join(ROOT, 'public-landing', 'projects.probes.json'), 'utf8'));
+  const names = probes.probes.map((p) => p.name);
+  assert.ok(names.some((n) => n.startsWith('manage flows: its card (task 1003352)')), 'the save probe');
+  assert.ok(names.some((n) => n.includes("its card — handing it back")), 'the hand-back probe');
+});
+
 /* ── the create wizard in the world (task 1003346; direction record §15, the pick: v1 the
    rail above, the bongo pair kept). Two sheets carry it: cosmos.css draws the FRAME by scope
    (#view-new), projects.html's own wizard block draws the wizard's structures. ── */

package/tests/projects_hub_pre_uat.mjs

@@ -600,20 +600,22 @@ test('the done panel’s progress region is stable, change-only, and says each s
   assert.match(fn('stripMarkup'), /role="status" aria-live="polite"/, 'the mine-card strip is left alone this pass');
 });
 
-test('the map table sorts from the keyboard and an owned row’s name is a real link', () => {
-  assert.match(HUB, /<th class="colName" data-sort="name" aria-sort="ascending"><button type="button" class="thSort">Project<\/button><\/th>/);
-  assert.match(HUB, /<th class="right colBuilders" data-sort="builders"><button type="button" class="thSort">Builders<\/button><\/th>/);
-  assert.match(SCRIPT, /var btn = th\.querySelector\('button'\);\n\s*if \(!btn\) return;\n\s*btn\.addEventListener\('click'/, 'the listener sits on the button, not the th');
-  assert.doesNotMatch(SCRIPT, /th\.style\.cursor/, 'no JS-set cursor on the th');
-  assert.match(COSMOS, /\.tbl th button\{all:unset;cursor:pointer;\}/);
-  assert.match(COSMOS, /\.tbl th button:focus-visible\{outline:2px solid var\(--accent\);outline-offset:2px;\}/, 'keyboard focus on the sort button is visible');
-  const generated = (SCRIPT.match(/return '<tr data-generated([\s\S]*?)'<\/tr>';/) || [, ''])[1];
+test('the map list sorts from the keyboard and an owned row’s name is a real link', () => {
+  // the sort was a button inside a <th> until task 1003356 took the header row
+  // away with the table; it is a pill in a group now, and still a real button
+  assert.match(HUB, /<button type="button" class="sortPill" data-sort="name" aria-pressed="true">name <span class="dir">a to z<\/span><\/button>/);
+  assert.match(HUB, /<button type="button" class="sortPill" data-sort="builders" aria-pressed="false">builders<\/button>/);
+  assert.match(SCRIPT, /document\.querySelectorAll\('\.tblSort button\[data-sort\]'\)\.forEach\(function \(btn\) \{\r?\n\s*btn\.addEventListener\('click'/, 'the listener sits on the button itself');
+  assert.doesNotMatch(SCRIPT, /th\.style\.cursor/, 'no JS-set cursor on a header that no longer exists');
+  assert.match(COSMOS, /\.tblSort button\{[^}]*min-height:36px;/, 'the sort pill clears the 24px floor on its own, with no all:unset to undo');
+  assert.match(COSMOS, /\.tblSort button:focus-visible\{outline:2px solid var\(--accent\);outline-offset:2px;\}/, 'keyboard focus on the sort button is visible');
+  const generated = (SCRIPT.match(/return '<li class="tblRow" data-generated([\s\S]*?)'<\/li>';/) || [, ''])[1];
   assert.match(generated, /<a class="ptitle" data-manage="' \+ esc\(String\(p\._inst\.id\)\) \+ '" href="\?view=manage&id=' \+ esc\(String\(p\._inst\.id\)\) \+ '">/, 'an owned row’s title is a manage anchor');
   const rows = SCRIPT.slice(SCRIPT.indexOf("$('mapRows').addEventListener('click'"));
   const branch = rows.indexOf("closest('a[data-manage]')");
   const bail = rows.indexOf("if (ev.target.closest && ev.target.closest('a')) return;");
   assert.ok(branch > 0 && bail > branch, 'the manage branch runs before the anchor bail-out');
-  assert.match(HUB, /Sort by Project or Builders\./, 'the hint names the two sortable columns');
+  assert.match(HUB, /Sorted by name, A to Z\./, 'the live order is stated where the hint used to name the columns');
   assert.match(COSMOS, /\.tbl \.ptitle\{[^}]*text-decoration:none;\}/, 'the link wears the title’s ink, not the UA underline');
 });
 

package/tests/provisioning_settings.mjs

@@ -166,10 +166,13 @@ await ta('owner reads DEFAULTS (public / apply) on a row with empty settings —
   assert.equal(r.status, 200, r.raw);
   assert.deepEqual(r.body.settings, { platform_visibility: 'public', joinability: 'apply' });
   // the planet rides beside the settings (task 1003347): no default — null = the platform's own pick
-  assert.deepEqual(r.body.planet, { planet_template: null, planet_accent: null });
+  assert.deepEqual(r.body.planet, { planet_template: null, planet_accent: null, card_backdrop: null });
   assert.deepEqual(r.body.options, {
     platform_visibility: ['public', 'gated'], joinability: ['open', 'apply', 'invite_only'],
     planet_template: [...provisioning.PLANET_TEMPLATES], planet_accent: ['sea', 'terracotta', 'gold-soft', 'sun-lit', 'accent'],
+    // the card's backdrop (task 1003352) is the same kind of key: platform-drawn,
+    // closed list, no default, no push — so it rides the same vocab
+    card_backdrop: ['nebula', 'dust', 'deepfield', 'chrome'],
   });
 });
 
@@ -177,7 +180,7 @@ await ta('a stored planet reads back; a name that left the vocabulary reads null
   reset({ inst: { owner_builder_id: 7, slug: 'spike', status: 'active', settings: { planet_template: 'bead-obsidian-tint', planet_accent: 'purple' } } });
   const r = await get('/provisioning/instances/18/settings');
   assert.equal(r.status, 200, r.raw);
-  assert.deepEqual(r.body.planet, { planet_template: 'bead-obsidian-tint', planet_accent: null });
+  assert.deepEqual(r.body.planet, { planet_template: 'bead-obsidian-tint', planet_accent: null, card_backdrop: null });
   assert.deepEqual(r.body.settings, { platform_visibility: 'public', joinability: 'apply' }, 'the planet is not a setting: the policy read is untouched');
 });
 
@@ -268,7 +271,7 @@ await ta('the owner picks a planet: saved, echoed as `planet`, audited — and N
   reset();
   const r = await patch('/provisioning/instances/18/settings', { planet_template: 'bead-obsidian-tint', planet_accent: 'sea' });
   assert.equal(r.status, 200, r.raw);
-  assert.deepEqual(r.body.planet, { planet_template: 'bead-obsidian-tint', planet_accent: 'sea' });
+  assert.deepEqual(r.body.planet, { planet_template: 'bead-obsidian-tint', planet_accent: 'sea', card_backdrop: null });
   assert.deepEqual(r.body.saved, { platform_visibility: 'public', joinability: 'apply' }, 'the policy half is untouched');
   assert.deepEqual(updateCalls, [{ id: 18, patch: { planet_template: 'bead-obsidian-tint', planet_accent: 'sea' } }]);
   assert.equal(r.body.push.queued, false);
@@ -283,7 +286,7 @@ await ta('null hands the pick back to the platform (stored as null, read back as
   reset({ inst: { owner_builder_id: 7, slug: 'spike', status: 'active', hosting_shape: 'co-tenant', settings: { planet_template: 'bead-obsidian-tint', planet_accent: 'sea' } } });
   const r = await patch('/provisioning/instances/18/settings', { planet_template: null, planet_accent: null });
   assert.equal(r.status, 200, r.raw);
-  assert.deepEqual(r.body.planet, { planet_template: null, planet_accent: null });
+  assert.deepEqual(r.body.planet, { planet_template: null, planet_accent: null, card_backdrop: null });
   assert.deepEqual(updateCalls, [{ id: 18, patch: { planet_template: null, planet_accent: null } }]);
   assert.equal(enqueueCalls, 0);
 });
@@ -316,6 +319,48 @@ await ta('a policy change and a planet change in one save: the push queues for t
   assert.equal(enqueueCalls, 1);
 });
 
+await ta('the owner picks a card backdrop: the REAL router accepts it, echoes it, and still queues no push (task 1003352)', async () => {
+  // the regression this exists for: card_backdrop was added to PLANET_VOCAB (so
+  // settingKeys copied it) while the route's validator was a hand-written list
+  // that did not declare it — and strict mode 400s an undeclared field, so every
+  // real save from the manage page failed while the kit's probes stayed green
+  reset();
+  const r = await patch('/provisioning/instances/18/settings', { card_backdrop: 'nebula' });
+  assert.equal(r.status, 200, r.raw);
+  assert.deepEqual(r.body.planet, { planet_template: null, planet_accent: null, card_backdrop: 'nebula' });
+  assert.deepEqual(updateCalls, [{ id: 18, patch: { card_backdrop: 'nebula' } }]);
+  assert.equal(r.body.push.queued, false, 'the card is the platform\'s to draw — nothing is pushed');
+  assert.equal(r.body.push.restart, false);
+  assert.equal(enqueueCalls, 0, 'no settings-apply intent for a backdrop change');
+});
+
+await ta('null hands the card backdrop back to the platform, like the planet', async () => {
+  reset({ inst: { owner_builder_id: 7, slug: 'spike', status: 'active', settings: { card_backdrop: 'chrome' } } });
+  const r = await patch('/provisioning/instances/18/settings', { card_backdrop: null });
+  assert.equal(r.status, 200, r.raw);
+  assert.deepEqual(r.body.planet, { planet_template: null, planet_accent: null, card_backdrop: null });
+  assert.deepEqual(updateCalls, [{ id: 18, patch: { card_backdrop: null } }]);
+});
+
+await ta('an off-vocabulary card backdrop → 400 validation_failed (a closed list, not a free string)', async () => {
+  reset();
+  const r = await patch('/provisioning/instances/18/settings', { card_backdrop: 'sunset' });
+  assert.equal(r.status, 400, r.raw);
+  assert.equal(r.body.error.code, 'validation_failed');
+  assert.equal(updateCalls.length, 0);
+});
+
+await ta('the route\'s schema IS its vocabularies — every declared key is accepted, so one can never drift out', async () => {
+  // the guard against this whole class: a key added to SETTINGS_VOCAB or
+  // PLANET_VOCAB must be accepted by the validator without anyone remembering
+  const every = { ...provisioning.SETTINGS_VOCAB, ...provisioning.PLANET_VOCAB };
+  for (const [key, values] of Object.entries(every)) {
+    reset();
+    const r = await patch('/provisioning/instances/18/settings', { [key]: values[0] });
+    assert.equal(r.status, 200, `${key}: ${r.raw}`);
+  }
+});
+
 await ta('an off-vocabulary planet → 400 validation_failed (a colour is a token NAME, never a hex)', async () => {
   reset();
   for (const body of [{ planet_accent: '#fb9569' }, { planet_accent: 'purple' }, { planet_template: 'cube-gold-wash' }]) {