@rig-c/review 0.7.1 → 0.8.1

package/web/cloth-panel.ts

@@ -0,0 +1,168 @@
+/**
+ * Setup · Cloth (#111), page side: one form per cloth tag the installed reader accepts, holding the recipe's fields as
+ * the producer config states them, and a link preview on the stage — each chain the tag's parts are meshed on, drawn
+ * from its config `points` and `tip` in rig px of the setup pose (the crop → world mapping the cuts, chest and bones
+ * views use). Every change is a config patch op at `/cloth/<tag>/…` (`src/cloth-recipe.ts`); Apply sends them as one
+ * `rig` patch, which the server runs as `rig-parts propose --cloth … --write-config` and then builds the written config
+ * (`build` when the config declares limbs, else `rig --config`); the scratch build reloads in place under the stage's
+ * Environment. After an Apply the preview adds the chains of the config the producer wrote. The producer's refusals
+ * (`CONFIG_CLOTH_*`, `PROPOSE_CLOTH_DRAFTED`, `PROPOSE_CLOTH_PART`, `PROPOSE_WRITE_CONFIG_*`) come back verbatim.
+ * Hand-editing the drafted constraints is the physics block's, after the draft. The draft keeps the pending edits
+ * (`#cloth-pending`).
+ */
+import {ClothFieldError,fieldText,recipeFromFields,recipeOps,RECIPE_FIELDS,type ClothTagView,type RecipeField} from '../src/cloth-recipe.ts';
+import type {PatchOp} from '../src/config-patch.ts';
+import type {CropWorldMapping} from '../src/chest-regions.ts';
+import type {OverlayPoint,OverlayProject,OverlayRegion} from './rig-overlays.ts';
+import type {ClothStatusView,PatchJobView,RebuildRefusal} from './rebuild-client.ts';
+
+export interface ClothPanelDeps {
+ project:()=>OverlayProject|null;mapping:()=>CropWorldMapping;inspector:()=>string|undefined;
+ pause:()=>void;changed:()=>void;saved:()=>void;
+ apply:(ops:PatchOp[])=>Promise<PatchJobView|RebuildRefusal|null>;
+ reset:()=>Promise<void>;
+ token:(name:string)=>string;
+}
+export interface ClothPanel {
+ load(status:ClothStatusView|null,reason:string|null):void;
+ tag():string;select(tag:string):void;
+ values(tag?:string):Record<string,string>;set(key:string,text:string,tag?:string):void;declare(on:boolean,tag?:string):void;
+ ops():PatchOp[];
+ active():boolean;setActive(on:boolean):void;
+ overlayRegions():OverlayRegion[];
+ links():{tag:string;inspected:ClothTagView|null;drafted:ClothTagView|null};
+ apply():Promise<PatchJobView|RebuildRefusal|null>;
+ shown(job:PatchJobView|RebuildRefusal|null):void;
+ status(text:string,error:boolean):void;busy(value:boolean):void;
+ restore():void;clear():void;sync():void;dispose():void;
+}
+const node=<T extends HTMLElement>(id:string)=>{const found=document.getElementById(id);if(!found)throw new Error(`Missing UI element: ${id}`);return found as T;};
+const make=<K extends keyof HTMLElementTagNameMap>(tag:K,props:Record<string,unknown>={},...children:(Node|string)[]):HTMLElementTagNameMap[K]=>{const item=document.createElement(tag);Object.assign(item,props);item.append(...children);return item;};
+const isObject=(v:unknown):v is Record<string,unknown>=>!!v&&typeof v==='object'&&!Array.isArray(v);
+
+export function bindClothPanel(deps:ClothPanelDeps):ClothPanel {
+ const state=node('cloth-panel-state'),toggle=node<HTMLButtonElement>('cloth-links'),picker=node<HTMLSelectElement>('cloth-tag'),declared=node<HTMLInputElement>('cloth-declared'),fields=node('cloth-fields'),pending=node('cloth-pending-list');
+ const applyButton=node<HTMLButtonElement>('cloth-apply'),resetButton=node<HTMLButtonElement>('cloth-reset'),statusOut=node('cloth-status'),readout=node('cloth-readout'),draft=node<HTMLTextAreaElement>('cloth-pending');
+ let status:ClothStatusView|null=null,reason:string|null=null,selected='',active=false,busy=false;
+ /** Per touched tag: every form field's text, and whether the tag's recipe is declared. */
+ let edits=new Map<string,{declared:boolean;values:Record<string,string>}>();
+ let drafted:ClothTagView[]=[];
+
+ const panelStatus=(text:string,error:boolean)=>{statusOut.textContent=text;statusOut.title=text;statusOut.classList.toggle('error',error);};
+ const recipe=(tag:string)=>isObject(status?.recipes)?status!.recipes![tag]:undefined;
+ const initial=(tag:string)=>({declared:recipe(tag)!==undefined,values:Object.fromEntries(RECIPE_FIELDS.map(f=>[f.key,fieldText(recipe(tag),f)]))});
+ const current=(tag:string)=>edits.get(tag)??initial(tag);
+ const touched=(tag:string)=>{const e=edits.get(tag),i=initial(tag);return !!e&&(e.declared!==i.declared||RECIPE_FIELDS.some(f=>(e.values[f.key]??'')!==(i.values[f.key]??'')));};
+ const save=()=>{draft.value=JSON.stringify({cloth:Object.fromEntries([...edits].filter(([tag])=>touched(tag)))});draft.dispatchEvent(new Event('input',{bubbles:true}));deps.saved();};
+ /** Every pending op, tag by tag in the reader's order; a field that does not read is named and stops the list. */
+ function allOps():PatchOp[] {
+  const config={cloth:status?.recipes??undefined},out:PatchOp[]=[];
+  for(const tag of status?.targets??[]){if(!touched(tag))continue;const e=current(tag);out.push(...recipeOps(config,tag,e.declared?recipeFromFields(e.values):null));}
+  return out;
+ }
+ const change=()=>{save();render();deps.changed();};
+
+ function renderFields(){
+  const tag=selected,e=current(tag),pendingKeys=new Set(edits.has(tag)?RECIPE_FIELDS.filter(f=>(e.values[f.key]??'')!==(initial(tag).values[f.key]??'')).map(f=>f.key):[]);
+  declared.checked=e.declared;declared.disabled=busy||!tag;
+  const input=(f:RecipeField)=>{
+   const value=e.values[f.key]??'';let control:HTMLInputElement|HTMLSelectElement;
+   if(f.kind==='bool'||f.kind==='shape'){const options=f.kind==='bool'?['','true','false']:['','linear','smooth'];control=make('select',{},...options.map(o=>make('option',{value:o,textContent:o||'(absent)'})));control.value=value;}
+   else control=make('input',{type:'text',value,autocomplete:'off',inputMode:f.kind==='names'?'text':'decimal',placeholder:f.kind==='pair'?'root, tip':f.kind==='list'||f.kind==='names'?'a, b, …':'(absent)'});
+   control.disabled=busy||!e.declared;control.dataset.clothField=f.key;control.setAttribute('aria-label',`${tag} ${f.label}`);
+   control.onchange=()=>{panel.set(f.key,control.value);};
+   return make('label',{className:pendingKeys.has(f.key)?'cloth-field pending':'cloth-field'},make('span',{textContent:f.label+(f.required?' *':'')}),control,make('code',{textContent:`/cloth/${tag}/${f.path.join('/')}`}));
+  };
+  fields.replaceChildren(...(tag?RECIPE_FIELDS.map(input):[make('p',{className:'hint',textContent:'No tag to edit.'})]));
+ }
+ function renderPending(){
+  let ops:PatchOp[]=[],error:string|null=null;
+  try{ops=allOps();}catch(err){if(err instanceof ClothFieldError)error=err.message;else throw err;}
+  const items=ops.map(o=>make('li',{},make('code',{textContent:`${o.op} ${o.path}`}),o.op==='remove'?'':` → ${JSON.stringify(o.value)}`));
+  const revert=[...edits.keys()].filter(touched).map(tag=>{const b=make('button',{type:'button',textContent:`Revert ${tag}`,disabled:busy});b.onclick=()=>{edits.delete(tag);change();};return make('li',{},b);});
+  pending.replaceChildren(...(error?[make('li',{className:'error',textContent:error})]:[]),...(items.length?items:[make('li',{className:'hint',textContent:'No pending ops.'})]),...revert);
+  applyButton.disabled=busy||!items.length||!!error||!!reason||!!status?.reason;resetButton.disabled=busy;
+  toggle.disabled=!status;toggle.setAttribute('aria-pressed',String(active));
+ }
+ function renderPicker(){
+  const tags=status?.targets??[];
+  picker.replaceChildren(...tags.map(t=>make('option',{value:t,textContent:`${t}${recipe(t)===undefined?' (no recipe)':''}${touched(t)?' · pending':''}`})));
+  if(!tags.includes(selected))selected=tags[0]??'';picker.value=selected;picker.disabled=busy||!tags.length;
+ }
+ function renderState(){
+  if(!status){state.textContent=reason??'CLOTH_UNAVAILABLE: no producer handoff';state.classList.add('error');return;}
+  const view=status.tags.find(t=>t.tag===selected),mapping=deps.mapping();
+  state.classList.toggle('error',!!status.reason||!mapping.available);
+  state.textContent=`${status.targets.length} tag(s) the installed reader accepts${status.targetsRead?'':' (its list was not readable: the tags the config declares)'} · ${selected||'—'}: ${view?`${view.parts.length} part(s) (${view.parts.join(', ')||'none'}), ${view.chains.length} chain(s) in the config`:'—'} · built by ${status.route==='build'?'rig-parts build (the config declares limbs)':'rig --config'}${status.keypoints?` · keypoints ${status.keypoints.path}`:''}${status.reason?` · Apply: ${status.reason}`:''}${mapping.available?'':` · ${mapping.reason}: no links are drawn`}`;
+ }
+ function render(){renderPicker();renderFields();renderPending();renderState();}
+
+ const setActive=(on:boolean)=>{active=on&&!!status;if(active)deps.pause();render();deps.changed();};
+ toggle.onclick=()=>setActive(!active);
+ picker.onchange=()=>{selected=picker.value;render();deps.changed();};
+ declared.onchange=()=>panel.declare(declared.checked);
+ applyButton.onclick=()=>{void panel.apply();};
+ resetButton.onclick=()=>{if(!busy)void deps.reset();};
+ const observer=new MutationObserver(()=>panel.sync());
+ for(const selector of document.querySelectorAll('[data-inspector]'))observer.observe(selector,{attributes:true,attributeFilter:['aria-pressed','aria-selected']});
+ const colors=()=>({stroke:deps.token('--rv-mesh-region'),fill:'transparent',handle:deps.token('--rv-mesh-handle'),ink:deps.token('--rv-bone-ink'),labelBg:deps.token('--rv-bone-label-bg'),pending:deps.token('--rv-bone-pending')});
+ const world=(p:[number,number])=>{const m=deps.mapping();return m.available?m.toWorld(p[0],p[1]):null;};
+ const restore=()=>{
+  let doc:unknown=null;try{doc=JSON.parse(draft.value||'null');}catch{doc=null;}
+  edits=new Map();
+  const kept=isObject(doc)&&isObject(doc.cloth)?doc.cloth:{};
+  for(const [tag,v] of Object.entries(kept))if((status?.targets??[]).includes(tag)&&isObject(v)&&typeof v.declared==='boolean'&&isObject(v.values))edits.set(tag,{declared:v.declared,values:Object.fromEntries(RECIPE_FIELDS.map(f=>[f.key,typeof (v.values as Record<string,unknown>)[f.key]==='string'?(v.values as Record<string,string>)[f.key]!:'']))});
+ };
+
+ const panel:ClothPanel={
+  load(next,why){status=next;reason=next?null:why;drafted=[];if(!next)active=false;restore();render();deps.changed();},
+  tag:()=>selected,
+  select(tag){selected=tag;render();deps.changed();},
+  values:(tag=selected)=>({...current(tag).values}),
+  set(key,text,tag=selected){const f=RECIPE_FIELDS.find(x=>x.key===key);if(!f)throw new Error(`CLOTH_FIELD_UNKNOWN: ${key}`);const e=current(tag);edits.set(tag,{declared:e.declared,values:{...e.values,[key]:text}});change();},
+  declare(on,tag=selected){const e=current(tag);edits.set(tag,{declared:on,values:{...e.values}});change();},
+  ops:allOps,
+  active:()=>active,setActive,
+  links(){return {tag:selected,inspected:status?.tags.find(t=>t.tag===selected)??null,drafted:drafted.find(t=>t.tag===selected)??null};},
+  overlayRegions(){
+   if(!active||!status)return [];const c=colors(),out:OverlayRegion[]=[];
+   // One label per set (the first chain carries it); every link joint is a handle square.
+   const draw=(view:ClothTagView|undefined,stroke:string,label:string)=>{let first=true;for(const chain of view?.chains??[]){const w=chain.points.map(world);if(w.some(p=>!p))continue;out.push({name:first?label:'',points:w as OverlayPoint[],stroke,fill:c.fill,handles:true,open:true,active:null,colors:{handle:stroke,ink:c.ink,labelBg:c.labelBg}});first=false;}};
+   const inspected=status.tags.find(t=>t.tag===selected),written=drafted.find(t=>t.tag===selected);
+   // The written chains are drawn over the config's; when they are the same links, one label says so.
+   const same=!!written&&JSON.stringify(written.chains)===JSON.stringify(inspected?.chains??[]);
+   draw(inspected,c.stroke,`${selected} · ${inspected?.chains.length??0} chain(s) · config${same?' = written':''}`);
+   if(!same)draw(written,c.pending,`${selected} · ${written?.chains.length??0} chain(s) · written`);
+   return out;
+  },
+  async apply(){
+   let ops:PatchOp[];try{ops=allOps();}catch(err){if(err instanceof ClothFieldError){panelStatus(err.message,true);return null;}throw err;}
+   if(!ops.length||busy){panelStatus('CLOTH_NOTHING_PENDING: no pending ops',true);return null;}
+   const result=await deps.apply(ops);panel.shown(result);return result;
+  },
+  shown(job){
+   if(!job){readout.replaceChildren();drafted=[];deps.changed();return;}
+   const lines:HTMLElement[]=[],line=(label:string,text:string,error=false)=>lines.push(make('div',{className:'physics-readout-line'},make('span',{className:'eyebrow',textContent:label}),make('code',{textContent:text,title:text,className:error?'error':''})));
+   if(!('id' in job)){line('REFUSED',job.error,true);readout.replaceChildren(...lines);return;}
+   const c=job.cloth;
+   for(const r of c?.refusals??[])line('REFUSED',r,true);
+   if(c?.line)line('WROTE',c.line);
+   if(c?.written){line('WRITTEN DIFF',`${c.written.count} path(s) against cloth.json${c.written.sections.length?` · ${c.written.sections.join(', ')}`:''}${c.written.outside.length?` · outside the drafted sections: ${c.written.outside.slice(0,8).join(', ')}`:' · every one under the drafted sections'}`,c.written.outside.length>0);for(const p of c.written.paths.slice(0,12))line('PATH',p);}
+   if(c)line('ROUTE',c.route==='build'?'rig-parts build --config config.json (the config declares limbs)':'rig-parts rig --config config.json');
+   for(const r of job.assembled?.refusals??[])line('REFUSED',r,true);
+   for(const r of job.assembled?.checkFails??[])line('CHECK FAIL',r,true);
+   if(job.status!=='built'&&job.producerLine&&!(c?.refusals??[]).length)line('REFUSED',job.producerLine,true);
+   if(job.status==='built'&&job.check?.line)line('CHECK',job.check.line,job.check.pass!==true);
+   drafted=job.status==='built'&&c?c.links:[];
+   readout.replaceChildren(...lines);deps.changed();
+  },
+  status:panelStatus,
+  busy(value){busy=value;render();},
+  restore(){restore();render();deps.changed();},
+  clear(){edits=new Map();change();},
+  sync(){renderState();if(active&&deps.inspector()!=='rig')setActive(false);},
+  dispose(){observer.disconnect();},
+ };
+ render();
+ return panel;
+}

package/web/compare.ts

@@ -49,6 +49,8 @@ let stripBusy = false;
 let persistence:PersistenceConnection|null=null,submittedBaseline:CompareSession|null=null,draftConflict=false;
 // First, before any URL use: take the `#cap=` handoff into memory/session storage and strip it.
 const access=pageInstanceAccess();let readOnly:string|null=null;
+/** Whether this instance serves agent control (`/api/access`); a plain open is never probed for it (#164). */
+let controlServed=true;
 let referenceFrames:VideoInfo|null=null;
 const presentation=new ComparePresentation();
 const rendererBadges={a:new RendererBadge(),b:new RendererBadge()};
@@ -393,9 +395,9 @@ function bind(): void {
 
 async function start(): Promise<void> {
   try {
-    let writes: { capabilityRequired: boolean };
-    [data, session, writes] = await Promise.all([api<CompareResponse>('/api/compare'), api<CompareSession>('/api/compare/session'), api<{ capabilityRequired: boolean }>('/api/access')]);
-    readOnly = readOnlyReason(access, writes.capabilityRequired); if (readOnly) message(readOnly, true);
+    let writes: { capabilityRequired: boolean; control?: boolean };
+    [data, session, writes] = await Promise.all([api<CompareResponse>('/api/compare'), api<CompareSession>('/api/compare/session'), api<{ capabilityRequired: boolean; control?: boolean }>('/api/access')]);
+    readOnly = readOnlyReason(access, writes.capabilityRequired); if (readOnly) message(readOnly, true); controlServed = writes.control !== false;
     submittedBaseline=structuredClone(session);
     if (data.id !== session.id || data.sourceHash !== session.sourceHash || JSON.stringify(data.binding) !== JSON.stringify(session.binding)) throw new Error('Comparison and submission session refer to different source identities. Reopen the review.');
     text('title', data.title); text('animation', `${data.animation} · A/B order and reference video hash are fixed`); document.title = data.title + ' · rig review compare'; select('status').value = session.status; provenance(); bind(); parts=new PartExplorer(el('parts-explorer'),el('selected-part'),previous=>{redrawOverlays(true);const part=parts?.value();if(part){activeCamera=part.side==='b'?'b':'a';workspace?.revealInspector();document.querySelector<HTMLButtonElement>('[data-inspector=rig]')?.click();renderCameraControls();}if(!cameraRestoring&&(previous?.side!==part?.side||previous?.slot!==part?.slot))cameraAction(()=>fitActiveCamera());persistence?.save();},part=>{select('side').value=part.side;select('target-kind').value='slot';renderFeedbackSelection();input('target-name').value=part.slot;document.querySelector<HTMLButtonElement>('[data-inspector=feedback]')?.click();}); updateStripControls(); stripStatus('Choose the entered start–end frames or all feedback ranges to download. Unsubmitted feedback is included; exporting does not submit the review.'); renderFeedbackSelection(); renderFeedback(); savedState();
@@ -410,7 +412,7 @@ async function start(): Promise<void> {
     input('scrub').max = String(domain.end); input('time-input').max = String(domain.end); text('domain', `Shared range 0–${domain.end} s · Neither side is independently clamped or looped`); ready = true;
     input('scrub').disabled = false; input('time-input').disabled = false; button('seek').disabled = false; button('play').disabled = domain.end === 0;
     await seekTo(0);activeCamera='a';if(cameraSync)alignCameras();fit();for(const id of ['layer-images','layer-mesh','layer-bones'])input(id).disabled=false;renderIdle();const restored=await setupPersistence();if(!restored&&canRepeatIdle())void playComparison().catch(error=>message(describe(error),true));
-    if(!readOnly)controlDispose=connectControl({sourceHash:data.sourceHash,mode:'compare',route:access.route,headers:()=>access.headers(),observe:controlState,apply:applyControl,onStatus:value=>text('control-state',value)});
+    if(!readOnly&&controlServed)controlDispose=connectControl({sourceHash:data.sourceHash,mode:'compare',route:access.route,headers:()=>access.headers(),observe:controlState,apply:applyControl,onStatus:value=>text('control-state',value)});
   } catch (error) { failPair(error); for (const side of ['a', 'b'] as const) if (!players[side]) text(`${side}-empty`, `${side.toUpperCase()} Could not open comparison rig.`); text('reference-empty', 'Check the reference video and comparison inputs.'); }
 }
 function sharedBox():PoseBounds|null {const a=assets.a?.stage??players.a?.bounds(),b=assets.b?.stage??players.b?.bounds();return a&&b?unionBounds(a,b):a??b??null;}
@@ -431,7 +433,7 @@ function showSurvivors():void {
  updateFeedbackAvailability();
  const state=renderPairLayout();activeCamera=state.effective==='b'?'b':state.effective==='reference'?'reference':'a';fit();
  message(`Comparison unavailable · ${state.reasons.compare??''}${state.effective&&state.effective!=='compare'?` · showing ${state.effective==='reference'?'the reference':state.effective.toUpperCase()} alone`:''}`,true);
- if(!readOnly)controlDispose=connectControl({sourceHash:data.sourceHash,mode:'compare',route:access.route,headers:()=>access.headers(),observe:controlState,apply:applyControl,onStatus:value=>text('control-state',value)});
+ if(!readOnly&&controlServed)controlDispose=connectControl({sourceHash:data.sourceHash,mode:'compare',route:access.route,headers:()=>access.headers(),observe:controlState,apply:applyControl,onStatus:value=>text('control-state',value)});
 }
 function paneFrame(target:CameraTarget,hidden=false):CameraFrame|null {
  const viewport=el(target+'-viewport');if(viewport.clientWidth<=0||viewport.clientHeight<=0)return hidden?cameraFrames[target]??null:null;

package/web/environment-world.ts

@@ -0,0 +1,42 @@
+/**
+ * The Environment block's "Use for readings" (issue #112), the DOM-free half: the controls as the exported
+ * `rigc-environment/1` schedule for a clip, its bytes and their hash, the feedback context that carries them, and the
+ * "Check under this world" rows (each readout bar under the default world beside the same bar under this one).
+ */
+import { scheduleSummary, scheduleText, sha256Hex, SCHEDULE_CONTEXT_SCHEMA, windSchedule, ScheduleError, type EnvironmentSchedule, type ScheduleContext, type WindScheduleExport } from '../src/environment-schedule.ts';
+import type { WindSnapshot } from '../src/environment.ts';
+import type { CheckSummary } from '../src/applied-context.ts';
+import { READOUT_BARS } from '../src/physics-tuning.ts';
+
+export const ENVIRONMENT_NOT_APPLIED = 'ENVIRONMENT_NOT_APPLIED: the player stands at the runtime start values (wind [1, 0], gravity [0, 1]), which check and render read without --environment; move a control first';
+export interface WorldExport { export: WindScheduleExport; schedule: EnvironmentSchedule; text: string; sha256: string; summary: string; animation: string }
+/** The controls as a schedule over `animation` (`duration` s), or why there is none. */
+export function worldExport(snapshot: WindSnapshot, gravity: number, applied: boolean, animation: string, duration: number): WorldExport | { error: string } {
+  if (!applied) return { error: ENVIRONMENT_NOT_APPLIED };
+  try {
+    const e = windSchedule(snapshot, gravity, duration), text = scheduleText(e.schedule), sha256 = sha256Hex(text);
+    return { export: e, schedule: e.schedule, text, sha256, summary: scheduleSummary(e, sha256), animation };
+  } catch (error) { if (error instanceof ScheduleError) return { error: error.message }; throw error; }
+}
+export const scheduleContext = (w: WorldExport, used: boolean): ScheduleContext => ({ schema: SCHEDULE_CONTEXT_SCHEMA, sha256: w.sha256, size: new TextEncoder().encode(w.text).length, text: w.text, usedForReadings: used });
+
+/** `POST /api/environment-check`'s job as the page reads it. */
+export interface EnvironmentCheckView {
+  id: string; status: 'running' | 'checked' | 'refused' | 'failed'; build: 'inspected' | 'scratch'; buildId: string | null;
+  schedule: { sha256: string; size: number; steps: number }; producer: { package: string; version: string };
+  exitCode: number | null; wallMs: number | null; check: CheckSummary | null;
+  environment: { path: string; sha256: string; steps: number } | null; environmentLine: string | null;
+  bars: { name: string; line: string }[]; error: string | null; lines: string[];
+}
+export interface EnvironmentRow { kind: 'label' | 'bar' | 'error'; text: string }
+/** The panel's lines: which schedule check read, then per bar the default world's line and this world's, or the refusal verbatim. */
+export function environmentCheckRows(job: EnvironmentCheckView, defaultLine: (name: string) => string, defaultLabel: string): EnvironmentRow[] {
+  if (job.status !== 'checked') return [{ kind: 'error', text: job.error ?? `ENVIRONMENT_CHECK_FAILED: ${job.status}` }];
+  const rows: EnvironmentRow[] = [{ kind: 'label', text: `${job.build} build · ${job.producer.package} ${job.producer.version} check --environment · ${job.environmentLine ?? `check.json environment sha256 ${job.environment?.sha256 ?? '?'}`}${job.wallMs !== null ? ` · ${(job.wallMs / 1000).toFixed(1)} s` : ''}` }];
+  for (const name of READOUT_BARS) {
+    rows.push({ kind: 'label', text: `${defaultLabel}: ${defaultLine(name)}` });
+    rows.push({ kind: 'bar', text: `this world: ${job.bars.find(b => b.name === name)?.line ?? `${name}: not in check summary`}` });
+  }
+  if (job.check?.line) rows.push({ kind: 'label', text: `this world · ${job.check.line}` });
+  return rows;
+}