figdown 0.4.0 → 0.4.1

package/dist/figdown.js

@@ -1,4 +1,4 @@
-// figdown.js — FigDown embeddable library (0.4.0)
+// figdown.js — FigDown embeddable library (0.4.1)
 // GENERATED FILE, DO NOT EDIT. Built from editor/figdown.html.
 // Regenerate with: node tools/make-lib.js
 (function (root, factory) {
@@ -10,7 +10,7 @@
   }
 }(typeof globalThis !== 'undefined' ? globalThis : this, function () {
   'use strict';
-var VERSION = "0.4.0";
+var VERSION = "0.4.1";
 
 // ---- engine (extracted verbatim from editor/figdown.html) ----
 var __engine = (function () {
@@ -24,7 +24,7 @@ const SHAPES = ['box','rounded','circle','ellipse','diamond','cylinder'];
 // input to that promise, and under core §13 a 0.x renderer may differ from
 // the next — which makes the recorded version the only thing that can
 // explain a diff between two renderings of one source.
-const FIGDOWN_VERSION = '0.4.0';
+const FIGDOWN_VERSION = '0.4.1';
 // `STATECHART-GENRE-SCOPE`: the language number moved for the first time. The dev
 // counter does NOT reset (core §13.0.4 — `N` counts source states of the
 // engine and only ever increases), so 0.1 is followed by
@@ -39,7 +39,7 @@ const FIGDOWN_VERSION = '0.4.0';
 // fixes only. No new features. The language does not move." Shipping `note=`
 // under `v0.2.z` would make `figdown 0.2` name two different languages: the one
 // `v0.2.0` published and the one with `note=`. So the language number moves.
-// `SEQUENCE-SOURCE-STANDARD`-R182: `figdown 0.4` joins the set, and it joins it for the
+// `SEQUENCE-GENRE-VOCABULARY`: `figdown 0.4` joins the set, and it joins it for the
 // same reason `0.2` did — a GENRE token is language surface, and core §13.0
 // makes added surface a `Y` and never a `Z`. `sequence` is that token. It adds
 // no keyword yet (see GENRES_BY_VERSION below), which is exactly `STATECHART-GENRE-SCOPE`'s shape:
@@ -52,7 +52,7 @@ const GENRES_BY_VERSION = {
   '0.1': ['block','topology','flowchart','bitfield','table','timing'],
   '0.2': ['block','topology','flowchart','bitfield','table','timing','statechart'],
   '0.3': ['block','topology','flowchart','bitfield','table','timing','statechart'],
-  // `SEQUENCE-SOURCE-STANDARD`-R182: `sequence` is dispatchable from here on. Like
+  // `SEQUENCE-GENRE-VOCABULARY`: `sequence` is dispatchable from here on. Like
   // `statechart` at `STATECHART-GENRE-SCOPE` it arrived with NO vocabulary of its own, and the
   // consequence was stated here rather than left to be discovered: there was no
   // `GENRE_KW.sequence` row, and the allowlist guard is written
@@ -60,7 +60,7 @@ const GENRES_BY_VERSION = {
   // row is NOT narrowed — a `figdown 0.4 sequence` document could write any
   // registered keyword and it parsed. The document that increment meant to
   // land was the header ALONE.
-  // `SEQUENCE-SOURCE-STANDARD`-R182: CLOSED. `GENRE_KW.sequence` exists below, so the
+  // `SEQUENCE-GENRE-VOCABULARY`: CLOSED. `GENRE_KW.sequence` exists below, so the
   // genre now constrains what it names — five keywords of its own, `class`,
   // and the genre-free core — and `flow`/`rank`/`group` are line errors under
   // it. The genre still has NO RENDERER: a valid `sequence` document parses to
@@ -374,7 +374,7 @@ const DIRECTIVE_OPTS={
   // keyed by the surface word an author actually wrote.
   flowline:['style','class','fill','stroke','label','taillabel','headlabel','note'],
   transition:['style','class','fill','stroke','label','taillabel','headlabel','note'],
-  // `SEQUENCE-SOURCE-STANDARD`-R182: the `sequence` genre's four own rows. `message` is
+  // `SEQUENCE-GENRE-VOCABULARY`: the `sequence` genre's four own rows. `message` is
   // the fourth connector spelling and takes the connector set — `fill=` and
   // the three retired label keys stay listed for the same reason they are
   // listed on the other three, so their dedicated diagnostics fire instead of
@@ -440,7 +440,7 @@ const DIRECTIVE_OPTS={
   cell:['fill','stroke','class'], width:[],
   signal:['data','fill','stroke'], gap:[]
 };
-// `SEQUENCE-SOURCE-STANDARD`-R182: the FIRST genre-conditional option row, and it
+// `SEQUENCE-GENRE-VOCABULARY`: the FIRST genre-conditional option row, and it
 // exists because `DIRECTIVE_OPTS` is keyed by the SURFACE WORD an author
 // wrote, while `GENRE-VOCABULARY-OBLIGATION` makes a surface word a per-genre declaration. Every other
 // shared spelling in the language names the same construct in every genre
@@ -1023,7 +1023,7 @@ const FLOWCHART_SUBJECT_KW=['external'];
 // none of the six; `external` is additionally UML 2.5.1 §14's own
 // `TransitionKind` literal and is reserved for it (`RESERVED-SPELLINGS`).
 const STATECHART_SUBJECT_KW=[];
-// `sequence` (EXPERIMENTAL, 0.4, `SEQUENCE-SOURCE-STANDARD`-R182): THREE, and the array is
+// `sequence` (EXPERIMENTAL, 0.4, `SEQUENCE-GENRE-VOCABULARY`): THREE, and the array is
 // this genre's whole declaration of what a sequence figure is OF. `state` and
 // `fragment` and `operand` describe referents UML clause 17 defines —
 // `StateInvariant` (§17.12.25), `CombinedFragment` (§17.12.3) and
@@ -1055,6 +1055,23 @@ const FLOWCHART_ROLE_KW=['process','decision','terminator'];
 // only its default drawing, and `shape=` on the same line overrides the
 // drawing without touching the role (§12.7).
 const ROLE_SHAPE={process:'box',decision:'diamond',terminator:'rounded'};
+// Geometry DERIVED from the NODE DIRECTIVE ITSELF, for a genre whose node has
+// exactly one kind and therefore no role to map (backlog 52).
+// `statechart`'s own §Defaults rules "do not encode state-ness in a shape (`SHAPE-ENUM-VOCABULARY`)
+// — the genre already says it", and until now the engine contradicted it: a
+// `state` fell through to `box`, so every author who obeyed the rule got
+// right-angle rectangles that read as ISO 5807 process boxes, and four of the
+// six shipped statechart figures wrote `shape=rounded` on EVERY state line to
+// get out of it — twenty-one hand-keyed presentation keys restating one genre
+// fact. The derivation is the same move `flowchart` already makes through
+// ROLE_SHAPE, one level up: there the ROLE picks the drawing, here the
+// DIRECTIVE does, because `state` is the whole model (`GENRE-NODE-SPELLING` — no role is
+// recorded and none is missing). `SHAPE-ENUM-VOCABULARY` is satisfied for the same reason it is
+// satisfied for `decision`: the SOURCE says what the thing is, and the shape
+// is only how that thing happens to be drawn. `shape=` on the same line stays
+// legal and still overrides the DRAWING ONLY (§12.7), exactly as on a
+// `decision` — a `state x "S" shape=box` is still a state in the model.
+const KW_SHAPE={state:'rounded'};
 
 // `GENRE-CONNECTOR-SPELLING`/`GENRE-NODE-SPELLING`: PER-GENRE NODE AND CONNECTOR SPELLINGS.
 // Each scene genre takes the word its own domain uses for the line between
@@ -1082,7 +1099,7 @@ const GENRE_NODE_KW={block:'node',topology:'node',flowchart:'node',statechart:'s
 const GENRE_CONNECTOR_KW={block:'edge',topology:'edge',flowchart:'flowline',statechart:'transition',sequence:'message'};
 const NODE_SPELLINGS=new Set(['node','state','lifeline']);
 const CONNECTOR_SPELLINGS=new Set(['edge','flowline','transition','message']);
-// `SEQUENCE-SOURCE-STANDARD`-R182: WHERE EACH GENRE'S NODE ROWS LIVE IN THE PARSED DOC.
+// `SEQUENCE-GENRE-VOCABULARY`: WHERE EACH GENRE'S NODE ROWS LIVE IN THE PARSED DOC.
 // `GENRE_NODE_KW` above says what the WORD is; this says which `doc`
 // collection the parser puts that word's rows in. The two are separate facts
 // and only one of them is `nodes`: `statechart` renames the word and keeps the
@@ -1091,11 +1108,11 @@ const CONNECTOR_SPELLINGS=new Set(['edge','flowline','transition','message']);
 // the form "is this id a thing this genre declares" has to ask through here.
 // Hand-writing `doc.nodes` is the defect it closes: the Fill/Delete/Raise/
 // Lower enablement asked `lastDoc.nodes` and so was permanently false under
-// `sequence`, greying out four buttons whose edits (`SEQUENCE-SOURCE-STANDARD`-R182) already worked.
+// `sequence`, greying out four buttons whose edits (`SEQUENCE-GENRE-VOCABULARY`) already worked.
 const GENRE_NODE_COLL={block:'nodes',topology:'nodes',flowchart:'nodes',
                        statechart:'nodes',sequence:'lifelines'};
 const docNodes=(doc)=>(doc&&doc[GENRE_NODE_COLL[doc.genre]||'nodes'])||[];
-// `SEQUENCE-SOURCE-STANDARD`-R182: the four `sequence` directives that have their own
+// `SEQUENCE-GENRE-VOCABULARY`: the four `sequence` directives that have their own
 // parser (`message` rides the connector scanner). The set is what dispatches
 // to `parseSeqDirective`, and it is scoped by `doc.genre` at the call site so
 // `state` still reaches `statechart`'s node parser under `statechart`.
@@ -1163,7 +1180,7 @@ const WORD_WHY={
   transition:'the connecting line in a statechart is a TRANSITION — the term UML 2.5.1 §14 uses for it',
   node:'this genre has more kinds of thing than it has words for, so `node` is the general one',
   state:'a statechart has exactly ONE kind of node and it is a STATE (UML 2.5.1 §14)',
-  // `SEQUENCE-SOURCE-STANDARD`-R182: both are WHOLE borrows from the genre's source
+  // `SEQUENCE-GENRE-VOCABULARY`: both are WHOLE borrows from the genre's source
   // standard, verified against the clause text rather than against a
   // secondary description (spec/standards-claims.tsv).
   lifeline:'a sequence figure has exactly ONE kind of participant column and it is a LIFELINE — the term UML 2.5.1 §17.3.3.1 defines and §17.3.4.1 draws',
@@ -1312,7 +1329,7 @@ const GENRE_KW={
   // chart is experimental and attaches to a table id in the same document
   table:new Set(GENRE_FREE_KW.concat(['class','table','chart'])),
   timing:new Set(GENRE_FREE_KW.concat(['class','timing'])),
-  // `SEQUENCE-SOURCE-STANDARD`-R182: `sequence` gets its row, and the row is what
+  // `SEQUENCE-GENRE-VOCABULARY`: `sequence` gets its row, and the row is what
   // closes the Batch-1 finding that the genre "states a reading and constrains
   // nothing". It is NOT built on `SCENE_HOST_KW`, and the three absences are
   // each a decision rather than an oversight:
@@ -1356,7 +1373,7 @@ function splitFigdownSections(text){
   return secs;
 }
 
-// `SEQUENCE-SOURCE-STANDARD`-R182: the `sequence` genre's DERIVED reading, in one
+// `SEQUENCE-GENRE-VOCABULARY`: the `sequence` genre's DERIVED reading, in one
 // function so the parser's checks and (from a later increment) the renderer
 // cannot disagree about what a document says.
 //
@@ -1455,7 +1472,7 @@ function parseOne(text){
   const doc={title:null,note:null,nodes:[],groups:[],edges:[],planes:[{id:'base',label:null,z:0}],
              flow:'right',ranks:[],pins:{},blocks:[],trunks:[],thresholds:[],bands:[],
              classes:[],boundaries:[],
-             // `SEQUENCE-SOURCE-STANDARD`-R182: the `sequence` model. FIVE collections,
+             // `SEQUENCE-GENRE-VOCABULARY`: the `sequence` model. FIVE collections,
              // one per keyword, and they are separate arrays rather than
              // aliases of `nodes`/`edges` because a message is not an edge: an
              // edge is a relation between two nodes and has no position, while
@@ -1609,7 +1626,7 @@ function parseOne(text){
       if(ro && ro[u2[0]]!==undefined) err(n,REFUSED_OPT_IN_GENRE(u2[0],doc.genre));
       else err(n,'unknown option "'+u2[0]+'="');
       return; }
-    // `SEQUENCE-SOURCE-STANDARD`-R182: `message` adds ONE trailing positional — the
+    // `SEQUENCE-GENRE-VOCABULARY`: `message` adds ONE trailing positional — the
     // quoted message label — to the connector grammar, because that is where
     // every sequence source in the corpus writes it and the `[mid]` form
     // reads as an annotation rather than as the message itself. Every other
@@ -1668,7 +1685,7 @@ function parseOne(text){
       if(!pc.ok){ err(n,pc.err); return; }
       ecls=pc.ids;
     }
-    // `SEQUENCE-SOURCE-STANDARD`-R182: the `sequence` fork. It is the SAME scanner with
+    // `SEQUENCE-GENRE-VOCABULARY`: the `sequence` fork. It is the SAME scanner with
     // a different reading, and the model it writes is a different collection:
     // a message is an OCCURRENCE with a place in the figure's total order
     // (draft §31), an edge is a relation with no position at all.
@@ -1708,7 +1725,7 @@ function parseOne(text){
                     plane:o2.plane||'base',line:n});
   }
 
-  // `SEQUENCE-SOURCE-STANDARD`-R182: the four `sequence` directives that are not the
+  // `SEQUENCE-GENRE-VOCABULARY`: the four `sequence` directives that are not the
   // connector. Reached only from the `doc.genre==='sequence'` dispatch, so
   // `state` under `statechart` never arrives here. Every option-VALUE check
   // (colours, `style=` enum, `class=` list, `in=` id spelling, `note=` and
@@ -1870,7 +1887,7 @@ function parseOne(text){
     // the dispatch cannot be narrowed to the genre's own word — a `flowline`
     // under `block` would then fall through to `unrecognized line`, which is
     // exactly the answer these rulings owe an author better than.
-    // `SEQUENCE-SOURCE-STANDARD`-R182: `message` is the FOURTH spelling scanned here,
+    // `SEQUENCE-GENRE-VOCABULARY`: `message` is the FOURTH spelling scanned here,
     // and it is derived from `CONNECTOR_SPELLINGS` rather than spelled again,
     // so a fifth genre's connector reaches the named diagnostic by joining
     // that set and not by remembering to edit a regex.
@@ -1916,7 +1933,7 @@ function parseOne(text){
     // Directives not in DIRECTIVE_OPTS (title's single quoted string, unknown
     // keywords) are handled by their own paths.
     const badOpts=(k)=>{
-      // `SEQUENCE-SOURCE-STANDARD`-R182: the row is read GENRE-FIRST. `state` is one
+      // `SEQUENCE-GENRE-VOCABULARY`: the row is read GENRE-FIRST. `state` is one
       // spelling with two declarations and two option sets (`GENRE-VOCABULARY-OBLIGATION`), and
       // `GENRE_DIRECTIVE_OPTS` is the only place that fact is recorded.
       const allowed=directiveOpts(k,doc.genre);
@@ -2476,7 +2493,7 @@ function parseOne(text){
       continue;
     }
 
-    // `SEQUENCE-SOURCE-STANDARD`-R182: the `sequence` genre's four own directives.
+    // `SEQUENCE-GENRE-VOCABULARY`: the `sequence` genre's four own directives.
     // Dispatched BEFORE the switch and scoped by `doc.genre`, which is what
     // keeps `state` reaching `statechart`'s node parser under `statechart` —
     // `GENRE-VOCABULARY-OBLIGATION` in the dispatcher, not only in the allowlist.
@@ -2557,8 +2574,10 @@ function parseOne(text){
       // `GENRE-NODE-SPELLING`: `state` joins the same case. It is `node` renamed
       // for one genre, not a role — a statechart node has exactly one kind,
       // so there is no role to record and `role` stays null, exactly as a
-      // bare `node` does. The DRAWING is unchanged too (`shape=box` default),
-      // which is what let the five corpus figures migrate byte-identically.
+      // bare `node` does. The DRAWING was unchanged too (`shape=box` default),
+      // which is what let the five corpus figures migrate byte-identically;
+      // 0.4 gave `state` its own derived geometry (KW_SHAPE, rounded)
+      // because the box default was making the genre's `SHAPE-ENUM-VOCABULARY` rule unfollowable.
       case 'process': case 'decision': case 'terminator':
       case 'state':
       case 'node': {
@@ -2571,7 +2590,7 @@ function parseOne(text){
         // DRAWING only. §12.7: presentation is not meaning on its own, so
         // `decision q "…" shape=box` is still a decision in the model — the
         // role is the model, the shape is how it happens to be drawn.
-        const shape=opts.shape||(role?ROLE_SHAPE[role]:'box');
+        const shape=opts.shape||(role?ROLE_SHAPE[role]:KW_SHAPE[kw]||'box');
         if(RETIRED_SHAPES[shape]){ err(n,RETIRED_SHAPES[shape]); break; }
         if(!SHAPES.includes(shape)){ err(n,'unknown shape "'+shape+'" ('+SHAPES.join('|')+')'); break; }
         if(pos[2]!==undefined&&!posq[2]){ err(n,kw+' label must be quoted: '+kw+' '+id+' "'+pos[2]+'" — '+Q_WHY); break; }
@@ -2984,7 +3003,7 @@ function parseOne(text){
     else if(groupIds.has(e.b)) errs.push('Line '+e.line+': edge endpoint "'+e.b+'" is a group — connect to a member node (group edges are not in v0.1)');
     if(e.plane && !planeIds.has(e.plane)) errs.push('Line '+e.line+': unknown plane "'+e.plane+'"');
   }
-  // ── `SEQUENCE-SOURCE-STANDARD`-R182: the `sequence` genre's semantic checks ────────
+  // ── `SEQUENCE-GENRE-VOCABULARY`: the `sequence` genre's semantic checks ────────
   // Everything here needs the WHOLE document, so none of it can live in
   // `parseSeqDirective`: forward references are legal (fixture 021 pins that
   // for the scene genres and the rule is language-wide), so an id can only be
@@ -3033,12 +3052,51 @@ function parseOne(text){
     // is never restated, so a genuine duplicate is always a mistake — and
     // because a transition is DERIVED from an adjacent pair, a reader
     // "tidying duplicates" could otherwise silently delete a fact.
+    //
+    // THE CHECK IS OPERAND-SCOPED (item 35, ruled 2026-08-17).
+    // It used to compare each occurrence with the previous one IN DECLARATION
+    // ORDER and never asked whether the two are reachable together, so an
+    // `alt` whose `granted` operand ends `state c "INIT"` and whose `refused`
+    // operand ends `state c "INIT"` was refused — while AT MOST ONE OF THOSE
+    // TWO EVER HAPPENS, so neither can restate the other. The diagnostic was
+    // right about the sequence and wrong about the figure, and
+    // `examples/sequence/dhcp-lease.fd` carried the fact it could not draw in
+    // a `description=` because of it.
+    //
+    // The scope is the CONTAINER (UML 2.5.1 §17.12.13: a StateInvariant is an
+    // InteractionFragment, and an InteractionOperand contains the fragments
+    // that occur when its branch is taken). So an occurrence is compared with
+    // the most recent occurrence in a scope that ENCLOSES OR IS its own —
+    // itself, its fragment, the document — and never with one in a SIBLING
+    // operand, which is on a path it is exclusive with. Two consequences are
+    // deliberate and are the answer to the "what is the lifeline in after the
+    // fragment" question the item asked: an occurrence in an operand still
+    // restates one written outside it (the outer state is on every path into
+    // the branch), and an occurrence AFTER a fragment is compared with the
+    // last one outside it, because which branch ran is exactly what the
+    // figure does not say. Outside operands nothing changes: the linear
+    // sequence is compared as before.
+    const scopeOwner={};
+    for(const o of doc.operands) scopeOwner[o.id]=o['in']||'';
+    for(const f of doc.fragments) scopeOwner[f.id]=f['in']||'';
+    const chainOf=id=>{
+      const out=[], seen=new Set();
+      let cur=id||'';
+      while(cur&&!seen.has(cur)){ seen.add(cur); out.push(cur); cur=scopeOwner[cur]||''; }
+      out.push('');
+      return out;
+    };
     const lastState={};
     for(const st of doc.states.slice().sort((a,b)=>a.line-b.line)){
-      if(lastState[st.ref]===st.name)
+      const chain=chainOf(st['in']);
+      const seen=lastState[st.ref]||(lastState[st.ref]={});
+      let prev=null;
+      for(const sc of chain){ const r=seen[sc]; if(r&&(!prev||r.line>prev.line)) prev=r; }
+      if(prev&&prev.name===st.name)
         errs.push('Line '+st.line+': lifeline "'+st.ref+'" is already in state "'+st.name+
-          '" — a state that has not changed is never restated, and a transition is derived from the adjacent pair, so a restatement would assert a transition that did not happen (draft §23.2)');
-      lastState[st.ref]=st.name;
+          '" — a state that has not changed is never restated, and a transition is derived from the adjacent pair, so a restatement would assert a transition that did not happen (draft §23.2)'+
+          (doc.operands.length?'. Occurrences in DIFFERENT operands of one fragment are exclusive and do not restate each other; this pair is not that':''));
+      seen[chain[0]]={name:st.name,line:st.line};
     }
     const SM=seqModel(doc);
     // A containment CYCLE is checked before anything that walks the chain, or
@@ -3586,7 +3644,33 @@ function cwMax(s){ return Math.max(...String(s).split('\n').map(cw)); }
 // glyph with it is what lets a reader recognise the box as an aside without a
 // legend entry). It is deliberately unlike a `node`: no rounded corners, a
 // paler wash, smaller type, and a corner no node shape has.
-const NOTE_FS=10, NOTE_PAD=6, NOTE_FOLD=9, NOTE_MAXCH=30;
+// NOTE_MAXW is the note's CORRIDOR: the widest line of note text the box will
+// hold, in pixels, measured in the type the note is actually SET in.
+//
+// It replaces `NOTE_MAXCH=30`, a CHARACTER count, and the character count was
+// wrong twice over (item 56a). It was width-blind — thirty `i`s and thirty
+// `W`s are not one measure — and, worse, the box built around it was sized by
+// `tw()`, which measures at the NODE font (13 px) and adds the NODE padding.
+// A note is set at 10 px. So a note wrapped at thirty characters was fitted
+// into a box a third wider than the text it wrapped for: `annotated-datapath`
+// broke "Only valid while the port is up." across two lines and then drew it
+// in a 250 px box with 70 px of empty paper on the right. A line that fits
+// its corridor now stays on one line, and the box is the text's own width.
+//
+// 230 px is chosen to KEEP the box the old rule produced (230 + padding +
+// fold = 251 px, the width every wide note in the corpus already draws at)
+// and make the wrap actually mean it. Measured over the whole corpus: the two
+// short notes lose 60 px of empty box each, "Only valid while the port is up."
+// goes from two lines to one, and the figure-level note from three to two.
+const NOTE_FS=10, NOTE_PAD=6, NOTE_FOLD=9, NOTE_MAXW=230;
+// The note's own per-unit advance: `CH` is calibrated for FONT (13 px), and a
+// note is set at NOTE_FS. One constant, so the wrap and the box cannot
+// disagree about how wide a line is.
+const NOTE_CH=CH*NOTE_FS/FONT;
+// A bold run is wider than the same glyphs regular. 6% is the usual figure for
+// a synthesised/duplexed weight and is charged so the target-label prefix
+// (item 56b) cannot overflow the corridor it was measured against.
+const NOTE_BOLD=1.06;
 const NOTE_FILL='#fdfaf0', NOTE_STROKE='#c9c4b2', NOTE_INK='#5c584c';
 // The leader is deliberately DARKER than the box outline. Drawn in the box's
 // own stroke it was legible in the SVG and invisible on the page at 1x — a
@@ -3598,24 +3682,46 @@ const NOTE_LEADER='#9c968a';
 // Deterministic greedy word wrap. Author newlines are honoured and never
 // merged; a run longer than the wrap width is broken only between words, so a
 // long identifier keeps its shape and simply widens the box.
-function noteWrap(text){
-  const out=[];
-  for(const para of String(text).split('\n')){
-    const words=para.split(/ +/).filter(w=>w.length);
-    if(!words.length){ out.push(''); continue; }
-    let cur=words[0];
-    for(let i=1;i<words.length;i++){
-      if((cur+' '+words[i]).length<=NOTE_MAXCH) cur+=' '+words[i];
-      else { out.push(cur); cur=words[i]; }
-    }
-    out.push(cur);
+// A wrapped line is a list of RUNS — {t: text, b: bold} — because a note may
+// open with its target's label in bold (item 56b) and the prefix can wrap into
+// the body like any other words. A note with no prefix is one regular run per
+// line, which is what every note was before.
+function noteRunW(r){ return cw(r.t)*NOTE_CH*(r.b?NOTE_BOLD:1); }
+function noteLineW(runs){ return runs.reduce((a,r)=>a+noteRunW(r),0); }
+// Deterministic greedy word wrap, measured in PIXELS against NOTE_MAXW.
+// Author newlines are honoured and never merged; a single word wider than the
+// corridor is never broken, so a long identifier keeps its shape and simply
+// widens the box.
+function noteWrap(text,prefix){
+  const words=[];
+  if(prefix) for(const w of String(prefix).split(/ +/).filter(w=>w.length)) words.push({t:w,b:true,br:false});
+  const paras=String(text).split('\n');
+  paras.forEach((para,pi)=>{
+    const ws=para.split(/ +/).filter(w=>w.length);
+    if(!ws.length){ words.push({t:'',b:false,br:pi>0}); return; }
+    ws.forEach((w,wi)=>words.push({t:w,b:false,br:pi>0&&wi===0}));
+  });
+  const SPW=cw(' ')*NOTE_CH;
+  const out=[]; let cur=[], curW=0;
+  const push=()=>{ out.push(cur.length?cur:[{t:'',b:false}]); cur=[]; curW=0; };
+  for(const w of words){
+    const ww=cw(w.t)*NOTE_CH*(w.b?NOTE_BOLD:1);
+    if(w.br&&cur.length) push();
+    const sp=cur.length?SPW:0;
+    if(cur.length&&curW+sp+ww>NOTE_MAXW){ push(); }
+    const gap=cur.length?' ':'';
+    const last=cur[cur.length-1];
+    if(last&&last.b===w.b) last.t+=gap+w.t;
+    else cur.push({t:gap+w.t,b:w.b});
+    curW+=(gap?SPW:0)+ww;
   }
+  push();
   return out;
 }
-function noteBox(text){
-  const lines=noteWrap(text);
+function noteBox(text,prefix){
+  const lines=noteWrap(text,prefix);
   const lh=NOTE_FS*1.35;
-  const w=Math.max(28, Math.max.apply(null,lines.map(tw))+NOTE_PAD*2+NOTE_FOLD);
+  const w=Math.max(28, Math.max.apply(null,lines.map(noteLineW))+NOTE_PAD*2+NOTE_FOLD);
   const h=lines.length*lh+NOTE_PAD*2-lh*0.15;
   return {w:Math.round(w*100)/100, h:Math.round(h*100)/100, lines, lh};
 }
@@ -3626,13 +3732,51 @@ function noteSvg(x,y,box,carrier){
   const F=NOTE_FOLD, w=box.w, h=box.h;
   const d='M'+x+' '+y+' H'+(x+w-F)+' L'+(x+w)+' '+(y+F)+' V'+(y+h)+' H'+x+' Z';
   const fold='M'+(x+w-F)+' '+y+' V'+(y+F)+' H'+(x+w)+' Z';
-  const out=['<g class="fd-note"'+(carrier&&carrier.kind?' data-note-on="'+carrier.kind+'"':'')+'>',
+  // `data-note-on` names the KIND; `data-note-for` names the TARGET (item 40b).
+  // Without the second attribute a machine reader holding only the drawing
+  // cannot recover WHICH element a note is about — it can see that a note is
+  // about "a group" and no more — so the association the source states was
+  // lost on the way to the page even when the placement was perfect. The pair
+  // (kind, ref) is unambiguous: `ref` is the element's identity in this very
+  // drawing — a `data-node` id, a `data-group` id, or the `data-edge` line
+  // number a connector is keyed by, since a connector has no id to carry.
+  // `title` is the one kind with no ref and needs none: it names the FIGURE,
+  // and there is exactly one. The attribute changes no pixel.
+  const ref=carrier&&carrier.ref!==undefined&&carrier.ref!==null?' data-note-for="'+esc(String(carrier.ref))+'"':'';
+  const out=['<g class="fd-note"'+(carrier&&carrier.kind?' data-note-on="'+carrier.kind+'"':'')+ref+'>',
     '<path d="'+d+'" fill="'+NOTE_FILL+'" stroke="'+NOTE_STROKE+'" stroke-width="1"/>',
     '<path d="'+fold+'" fill="'+NOTE_STROKE+'" fill-opacity="0.35" stroke="'+NOTE_STROKE+'" stroke-width="1"/>'];
   const first=y+NOTE_PAD+NOTE_FS*0.85;
+  // A line is a list of RUNS (item 56b): the target-label prefix is bold, the
+  // note's own words are regular. One `<text>` per line either way, so a note
+  // with no prefix emits exactly what it always did but for the tspan wrapper
+  // — and a single regular run is written bare, so those notes are unchanged
+  // byte for byte.
   box.lines.forEach((ln,i)=>{
-    out.push('<text x="'+(x+NOTE_PAD)+'" y="'+Math.round((first+i*box.lh)*100)/100+
-             '" font-size="'+NOTE_FS+'" text-anchor="start" fill="'+NOTE_INK+'">'+esc(ln)+'</text>');
+    const yy=Math.round((first+i*box.lh)*100)/100;
+    const runs=Array.isArray(ln)?ln:[{t:ln,b:false}];
+    let body;
+    if(runs.length===1&&!runs[0].b) body=esc(runs[0].t);
+    else {
+      // EVERY RUN CARRIES ITS OWN `x`. A bare `<tspan>` is supposed to
+      // continue where the last one stopped, and browsers do that — but a
+      // note is an ARTIFACT that outlives this engine and gets rasterised by
+      // whatever the reader has. Two library rasterisers restart each tspan
+      // at the parent's `x`, which draws the prefix and the sentence on top
+      // of each other. The advance is already measured (the wrap measured it
+      // to decide this line), so it is written down rather than inferred.
+      let off=0; const parts=[];
+      for(const r of runs){
+        const lead=/^ /.test(r.t)?1:0, t=lead?r.t.slice(1):r.t;
+        off+=lead*cw(' ')*NOTE_CH;
+        parts.push('<tspan x="'+Math.round((x+NOTE_PAD+off)*100)/100+'" y="'+yy+'"'+
+                   (r.b?' font-weight="600"':'')+'>'+esc(t)+'</tspan>');
+        off+=cw(t)*NOTE_CH*(r.b?NOTE_BOLD:1);
+      }
+      body=parts.join('');
+    }
+    out.push('<text x="'+(x+NOTE_PAD)+'" y="'+yy+
+             '" font-size="'+NOTE_FS+'" text-anchor="start" fill="'+NOTE_INK+'">'+body+'</text>');
   });
   out.push('</g>');
   return out.join('');
@@ -3640,7 +3784,7 @@ function noteSvg(x,y,box,carrier){
 // The leader is drawn ONLY when adjacency failed, and it is drawn AFTER the
 // box is placed, so it is correct by construction: it runs from the box edge
 // facing the carrier to the carrier's nearest point, and cannot be stale.
-function noteLeader(best,box,rect){
+function noteLeaderPts(best,box,rect){
   const bx=best.x, by=best.y, bw=box.w, bh=box.h;
   const cx=rect.x+rect.w/2, cy=rect.y+rect.h/2;
   let x1,y1;
@@ -3652,7 +3796,15 @@ function noteLeader(best,box,rect){
   // thing it points at
   const x2=Math.max(rect.x, Math.min(rect.x+rect.w, x1));
   const y2=Math.max(rect.y, Math.min(rect.y+rect.h, y1));
-  return '<line x1="'+x1+'" y1="'+y1+'" x2="'+(rect.w||rect.h?x2:cx)+'" y2="'+(rect.w||rect.h?y2:cy)+
+  return [[x1,y1],[rect.w||rect.h?x2:cx, rect.w||rect.h?y2:cy]];
+}
+// A LEADER IS INK AND A LATER NOTE MUST YIELD TO IT (item 40). The pass hands
+// the drawn segment back so the notes placed after this one are charged for
+// crossing it — a leader covered by the next note's box is a leader that is
+// not there, which is the same defect the LEADER's own colour was fixed for.
+function noteLeader(best,box,rect){
+  const [p,q]=noteLeaderPts(best,box,rect);
+  return '<line x1="'+p[0]+'" y1="'+p[1]+'" x2="'+q[0]+'" y2="'+q[1]+
          '" stroke="'+NOTE_LEADER+'" stroke-width="1" stroke-dasharray="4 3"/>';
 }
 // A band's optional edge stroke. `renderScene` has had this as a local since
@@ -4179,6 +4331,22 @@ function renderScene(doc,y0){
   // decided after, and a figure that suppresses and then declines draws
   // straight through its own boxes (bfd-session: score 30 -> 35 with a new
   // `thru`). That belongs with item 27's ordering change, priced.
+  // THE ADMISSIBILITY KEY, WRITTEN OUT (item 60). Members share a trunk only
+  // if they share the target, the label, the stroke, the dash AND THE CLASS
+  // SET. The first four were always tested; the class was implied by them,
+  // because the class cascade has already resolved `stroke=` and `style=` onto
+  // the edge by the time this runs — but "implied" is not "stated", and two
+  // classes that happen to paint alike are still two meanings. So the key says
+  // it. Same class (or all unclassed with identical labels) → admissible;
+  // MIXED CLASSES → refused, which is item 46's refusal and the reason
+  // `bfd-session`'s three returns into DOWN (advance/fail/admin, three
+  // different sentences) stay three lanes while its three `admin disable`
+  // transitions become one trunk. Narrowing only: no group admitted before is
+  // admitted less.
+  const clsKey=x=>{
+    const ids=(x.cls===undefined||x.cls===null)?[]:(Array.isArray(x.cls)?x.cls:[x.cls]);
+    return ids.slice().sort().join(',');
+  };
   const busGroups=[];
   {
     const g=new Map();
@@ -4187,11 +4355,52 @@ function renderScene(doc,y0){
       if(!A||!B||e.a===e.b||isBack.has(e)) continue;
       if(e.op!=='->'||e.tail||e.head) continue;
       if(pinned(e.a)||pinned(e.b)||B.rank<=A.rank) continue;
-      const k=e.b+' '+(e.mid||'')+' '+(e.stroke||'')+' '+(e.style||'');
+      const k=e.b+' '+(e.mid||'')+' '+(e.stroke||'')+' '+(e.style||'')+' '+clsKey(e);
       if(!g.has(k)) g.set(k,[]); g.get(k).push(e);
     }
     for(const [,m] of g) if(m.length>=3) busGroups.push(m);
   }
+  // ── RETURN MERGE BUS (item 46, and item 26's >=3 rule reaching the RETURNS) ──
+  // The forward bus (above) collapses three or more arrows arriving at one
+  // target into one trunk. The same statement is made just as often by RETURN
+  // edges — N states falling back to one — and the forward construct cannot
+  // reach them, because a return is drawn by the side-channel plan and not by
+  // the straight router (item 26 recorded `patterns/state-b`'s four `reset`
+  // edges as exactly this decline). `state-b` draws four CONCENTRIC RINGS, each
+  // labelled "reset", 818 px wide for a 500 px figure: four copies of one
+  // sentence.
+  //
+  // A return bus is the ring stack COLLAPSED ONTO ITS INNERMOST RING — not a
+  // new geometry. Every member drops from its own source to the shared rail,
+  // the rail and the trunk and the entry point are the innermost member's, one
+  // arrowhead lands on the target and one label rides the shared run. The
+  // members' own drops stay distinct and carry the junction dots, so the reader
+  // still counts the lines. Because the collapsed route is a route the
+  // innermost member already drew, no member can gain a crossing the figure did
+  // not already have — which is why this construct needs no adoption test where
+  // the forward rail (a NEW line across the figure) does.
+  //
+  // The admission rule is the forward bus's, unchanged, because the reasons are
+  // the same: ONE label (a trunk draws one, so members that say different things
+  // may not share it), ONE stroke and ONE dash (the trunk is stroked once per
+  // member; three colours on one line is three claims about one stroke, and in a
+  // classed figure those colours carry the legend's meaning), no endpoint
+  // labels, distinct sources. Measured over the corpus, exactly one group
+  // qualifies and two are refused for stated reasons — see the DONE note on 46.
+  const retBusGroups=[];
+  {
+    const g=new Map();
+    for(const e of doc.edges){
+      const A=byId[e.a], B=byId[e.b];
+      if(!A||!B||e.a===e.b||!isBack.has(e)) continue;
+      if(e.op!=='->'||e.tail||e.head) continue;
+      if(pinned(e.a)||pinned(e.b)) continue;     // the channel plan skips those
+      const k=e.b+' '+(e.mid||'')+' '+(e.stroke||'')+' '+(e.style||'')+' '+clsKey(e);
+      if(!g.has(k)) g.set(k,[]); g.get(k).push(e);
+    }
+    for(const [,m] of g)
+      if(m.length>=3&&new Set(m.map(e=>e.a)).size===m.length) retBusGroups.push(m);
+  }
   for(const e of doc.edges){
     const A=byId[e.a], B=byId[e.b];
     if(!A||!B||isBack.has(e)) continue;
@@ -4500,6 +4709,165 @@ function renderScene(doc,y0){
     if(o){ n.x=o.x+p.fx; n.y=o.y+p.fy; }
     else { n.x=p.fx; n.y=y0+20+p.fy; }
   }
+  // ── CORRIDOR BUDGETING (item 44) ─────────────────────────────────────────
+  // A SEAM IS ASKED WHAT LIVES IN IT. Until this pass, every gap in a scene —
+  // between two ranks, between two neighbours in one rank — was derived from
+  // NODE GEOMETRY ALONE: `GAPX`/`GAPY` plus, for horizontal flow only, the
+  // width of a mid label that rides on the edge. Nothing else in the drawing
+  // was ever asked for its area. But a gap is where a figure keeps most of its
+  // non-node ink: endpoint labels, bundle lassos and their captions, and the
+  // padded band a group draws around its members (whose TOP strip, `BAND.t`,
+  // exists precisely to hold the group's name). The reference topology figure
+  // is what that blindness costs — measured on the 0.4 artifact, the
+  // spine→leaf corridor was 4 px of clearance asked to house three lassos
+  // (2 x ry 26 each), eight endpoint labels, two bundle captions and the
+  // `Leaf` band's whole label strip; the l1—l2 gap was 56 px asked to house a
+  // 92 px-wide lasso, which therefore ate both node boxes.
+  //
+  // THE MODEL. For each seam the demand is derived FIRST, from ink alone —
+  // no coordinate is read to compute it:
+  //     need = max( bandGap , max(lasso, endpointLabels) + nameStrip )
+  // `bandGap` is what the two sides' group BANDS need of each other: the
+  // padding each projects into the seam plus `SEP_BAND` of white, so two bands
+  // read as two (nothing when one group spans the seam — its band covers the
+  // seam anyway). `lasso` is the breadth a bundle ring needs to cross the seam
+  // without reaching a node box, from the ring's own MINIMUM radii.
+  // `endpointLabels` is the tail/head labels an edge through the seam must
+  // stack. `nameStrip` is the ONE part of a band that is ink rather than
+  // backdrop — the strip carrying the group's NAME.
+  //
+  // WHY MAX AND NOT SUM. A band is a BACKDROP: every figure in this corpus
+  // draws edges across one, and a lasso crossing a band's fill is ordinary
+  // layering, not a collision. So the band requirement and the free-ink
+  // requirement are two claims on the same span and the binding one is the
+  // larger — only the band's NAME is ink the free ink must clear, and that is
+  // the term which adds. Summing them was built and measured first: it put the
+  // reference figure's corridor at 108 px, which then DETACHED the endpoint
+  // labels from their ports (they are anchored at a FRACTION of edge length —
+  // item 42 — so they drift as the seam deepens) and cost four new F5
+  // label-association defects on a figure that had none. A seam wide enough to
+  // break the ink it was widened for is the wrong answer; item 42's fixed-
+  // distance anchoring is what would lift that ceiling.
+  //
+  // IT IS APPLIED TO THE REALISED SEAM, NOT TO `mainGap`. A pre-coordinate
+  // widening cannot see a PIN: pins are absolute canvas coordinates, applied
+  // above, and the reference figure's spine pin spends 40 px of its own rank's
+  // gap — a `mainGap` bumped to 108 would have produced a 68 px corridor and
+  // reported success. So the demand is measured against the geometry that
+  // exists, here, after the pins have had their say.
+  //
+  // THREE THINGS IT DOES NOT DO, ON PURPOSE. It never moves a PINNED node
+  // (the group-band precedent: the coordinate is the author's word). It never
+  // NARROWS a seam — an adequate seam is left bit-for-bit alone, which is why
+  // 31 of the corpus's 34 scene figures are byte-identical across this change.
+  // And it changes no ROUTE and no SHAPE: edge paths, lasso radii and label
+  // anchors are all computed downstream from these coordinates and are
+  // untouched — they simply get room. The lasso that is still drawn as a
+  // near-circle regardless of its members' direction is item 43; the endpoint
+  // label still anchored by fraction rather than distance is item 42; the note
+  // and element-label association frontiers are items 40 and 45. This pass
+  // buys those fixes the space they need and deliberately leaves them open.
+  //
+  // WHERE IT DECLINES. If two ranks OVERLAP on the main axis — the author
+  // pinned them into each other, or into a different order than the ranking —
+  // there is no seam to budget and the pass says nothing. 39 of the corpus's
+  // 204 seams are that shape, all of them in substantially pinned scenes.
+  {
+    const SEP_BAND=6,      // white left between two distinct group bands
+          LASSO_CLEAR=6,   // a bundle ring's clearance from a node box
+          RY_MIN=26, RX_MIN=46,   // the ring's own floor radii (see doc.trunks)
+          EPL_H=13, EPL_PAD=4;    // an endpoint label's line box and its gutter
+    const mLo=n=>horiz?n.x:n.y,  mSz=n=>horiz?n.w:n.h;
+    const cLo=n=>horiz?n.y:n.x,  cSz=n=>horiz?n.h:n.w;
+    const mvM=(n,d)=>{ if(horiz) n.x+=d; else n.y+=d; };
+    const mvC=(n,d)=>{ if(horiz) n.y+=d; else n.x+=d; };
+    const ranked=nodes.filter(n=>!n.boundary&&n.rank!==undefined);
+    const byRank=new Map();
+    for(const n of ranked){ if(!byRank.has(n.rank)) byRank.set(n.rank,[]); byRank.get(n.rank).push(n); }
+    // Ranks are ordered by where they ACTUALLY sit, not by their index: `flow
+    // up`/`flow left` mirror the main axis after placement, so rank order and
+    // coordinate order are opposite there, and a seam is a fact about the
+    // drawing.
+    const rMid=r=>{ const a=byRank.get(r); return a.reduce((s,n)=>s+mLo(n)+mSz(n)/2,0)/a.length; };
+    const rks=[...byRank.keys()].sort((a,b)=>rMid(a)-rMid(b));
+    // A group's rank span, so a band that runs THROUGH a seam asks for nothing.
+    const gSpan={};
+    for(const g of doc.groups){
+      const m=ranked.filter(n=>n.group===g.id); if(!m.length) continue;
+      gSpan[g.id]={lo:Math.min(...m.map(n=>n.rank)), hi:Math.max(...m.map(n=>n.rank))};
+    }
+    const lblW=s=>(s===null||s===undefined||s==='')?0:lblPx(s);
+    // ── main axis: rank against rank ──────────────────────────────────────
+    for(let k=0;k+1<rks.length;k++){
+      const i=rks[k], j=rks[k+1];
+      const hiI=Math.max(...byRank.get(i).map(n=>mLo(n)+mSz(n)));
+      const loJ=Math.min(...byRank.get(j).map(n=>mLo(n)));
+      const actual=loJ-hiI;
+      if(actual<0) continue;                 // ranks interleave: not a seam
+      let bA=0,bB=0;
+      for(const id in gSpan){ const s=gSpan[id];
+        if(s.lo<=i&&s.hi>=j) continue;       // the band spans the seam itself
+        if(s.hi===i) bA=Math.max(bA,horiz?BAND.r:BAND.b);
+        if(s.lo===j) bB=Math.max(bB,horiz?BAND.l:BAND.t);
+      }
+      const bandGap=bA+bB+((bA&&bB)?SEP_BAND:0);
+      // The one piece of band padding that is INK rather than backdrop: under
+      // vertical flow the lower group's `BAND.t` strip is where its NAME is
+      // written, and a lasso or a label drawn through it lands on that name.
+      // Under horizontal flow the name strip is on the cross axis, so a
+      // main-axis seam does not contain it and the guard is nothing.
+      const guard=horiz?0:bB;
+      const spans=(a,b)=>{ const A=byId[a],B=byId[b];
+        return A&&B&&A.rank!==undefined&&B.rank!==undefined
+               &&Math.min(A.rank,B.rank)<=i&&Math.max(A.rank,B.rank)>=j; };
+      // A ONE-MEMBER bundle draws no ring (item 53), so it asks the seam for
+      // no ring breadth. Its caption is placed by the collision-aware label
+      // pass, which can use any white the figure already has.
+      let lasso=0;
+      for(const t of doc.trunks||[]) if(t.pairs.length>1) for(const [a,b] of t.pairs) if(spans(a,b))
+        lasso=Math.max(lasso, 2*(horiz?RX_MIN:RY_MIN)+2*LASSO_CLEAR,
+                              horiz?lblW(t.label)+2*LASSO_CLEAR:0);
+      let epl=0;
+      for(const e of doc.edges){ if(!spans(e.a,e.b)) continue;
+        const c=(e.tail?1:0)+(e.head?1:0); if(!c) continue;
+        epl=Math.max(epl, c*EPL_H+(c+1)*EPL_PAD); }
+      const d=Math.max(bandGap, Math.max(lasso,epl)+guard)-actual;
+      if(d<=0) continue;
+      // Everything at or beyond the far lip travels; a pinned node holds its
+      // ground. The movers are selected by POSITION, not by rank membership:
+      // boundary anchors and long-edge waypoints have ranks of their own that
+      // may hold no drawn node at all, and selecting by rank left the
+      // reference figure's `WAN` anchor behind while the leaf rank it hangs
+      // off moved 86 px away — the external's label then landed on the leaf
+      // group's name. `actual >= 0` guarantees no near-side node is past the
+      // lip, so this cannot pick up the rank the seam is measured from.
+      for(const n of lay) if(mLo(n)>=loJ-0.001&&!(n.id&&pinned(n.id))) mvM(n,d);
+    }
+    // ── cross axis: neighbour against neighbour inside one rank ───────────
+    for(const r of rks){
+      const lane=byRank.get(r).slice().sort((a,b)=>cLo(a)-cLo(b));
+      for(let q=0;q+1<lane.length;q++){
+        const A=lane[q], B=lane[q+1];
+        const actual=cLo(B)-(cLo(A)+cSz(A));
+        if(actual<0) continue;
+        let bandGap=0, guard=0;
+        if(A.group!==B.group){
+          const pa=A.group?(horiz?BAND.b:BAND.r):0, pb=B.group?(horiz?BAND.t:BAND.l):0;
+          bandGap=pa+pb+((pa&&pb)?SEP_BAND:0);
+          guard=horiz?pb:0;      // the name strip, on the cross axis this time
+        }
+        let lasso=0;
+        for(const t of doc.trunks||[]) if(t.pairs.length>1) for(const [a,b] of t.pairs)
+          if((a===A.id&&b===B.id)||(a===B.id&&b===A.id))
+            lasso=Math.max(lasso, 2*(horiz?RY_MIN:RX_MIN)+2*LASSO_CLEAR,
+                                  horiz?0:lblW(t.label)+2*LASSO_CLEAR);
+        const d=Math.max(bandGap, lasso?lasso+guard:0)-actual;
+        if(d<=0) continue;
+        const from=cLo(B);
+        for(const n of lay) if(n.rank===r&&cLo(n)>=from&&!(n.id&&pinned(n.id))) mvC(n,d);
+      }
+    }
+  }
   // ── GROUP BAND CONTIGUITY ────────────────────────────────────────────────
   // A group's band is the BOUNDING BOX of its members (see gBox below), and
   // until this pass nothing checked that the box contained only members. A
@@ -4651,6 +5019,55 @@ function renderScene(doc,y0){
     if(mem.length) gOrigin[g.id]={x:Math.min(...mem.map(n=>n.x)),
                                   y:Math.min(...mem.map(n=>n.y))};
   }
+  // ── A NODE THAT COVERS ANOTHER COMPLETELY IS A FALSE DRAWING (item 47b) ──
+  // The group-band precedent, one construct over. There the rule is: whoever
+  // chose the position bears responsibility, and an author pin that forces a
+  // drawing to state something the source does not is a GEOMETRY-TIME error,
+  // not a lint number. `examples/rpf-check.fd` is the case that asked the
+  // question: `pin drop at=(-30,0)` aged against a moving layout until
+  // `Drop (RPF fail)` sat entirely ON `Accept and forward` — PIN ROT — and the
+  // covered node was not merely crowded but INVISIBLE, which is the line
+  // between "ugly is not an error" and "wrong is". PARTIAL overlap stays on
+  // the `novlp` axis and is never an error: two boxes that clip each other are
+  // ugly and both readable, and drawing tools let them.
+  //
+  // THE MEASUREMENT NARROWED THE RULE, AND THE NARROWING IS THE FINDING.
+  // Over the corpus (59 figures, 231 nodes, 1640 ordered node pairs) full
+  // containment occurs 28 times and every one of them is `examples/rainbow.fd`
+  // — seven concentric pinned ellipses around a pinned core, the figure whose
+  // entire subject is that DOCUMENT ORDER IS PAINT ORDER (`PAINT-ORDER-CONSTRUCT`). So the
+  // premise a blanket rule would rest on ("if the cover is intentional the
+  // figure cannot state it — there is no z-order construct") is FALSE in this
+  // language: line order is that construct, and this corpus ships its
+  // reference figure. What distinguishes rainbow from rpf-check is not the
+  // geometry, which is identical, but WHO CHOSE IT: rainbow's covered node is
+  // pinned by the author on its own line, while rpf-check's was placed by the
+  // engine and drifted underneath. So the error fires when the cover is not
+  // wholly the author's: at least one of the two boxes is at a coordinate the
+  // author never wrote. Both pinned = an author statement in the one paint
+  // order the language has, and it is drawn.
+  {
+    const real=nodes.filter(n=>!n.boundary&&n.w>0&&n.h>0);
+    const inside=(a,b)=>a.x>=b.x-0.01&&a.y>=b.y-0.01
+                     &&a.x+a.w<=b.x+b.w+0.01&&a.y+a.h<=b.y+b.h+0.01;
+    const covered=new Set();
+    for(const a of real) for(const b of real){
+      if(a===b||covered.has(a.id+' '+b.id)) continue;
+      if(!inside(a,b)) continue;
+      if(pinned(a.id)&&pinned(b.id)) continue;      // both coordinates are the author's
+      covered.add(a.id+' '+b.id);
+      const who=pinned(b.id)?b.id:(pinned(a.id)?a.id:null);
+      const ln=who!==null?srcLine(doc.pins[who].line):srcLine(a.line);
+      gErrs.push('Line '+ln+': '+(who!==null?'pin puts':'the layout puts')+' "'+b.id+'" completely over "'
+        +a.id+'" — a node drawn entirely inside another is invisible, so the figure states that "'
+        +a.id+'" is not there. '+(who!==null
+          ? 'Move the pin off "'+a.id+'", or pin "'+a.id+'" too if the cover is deliberate — '
+            +'document order is paint order (`PAINT-ORDER-CONSTRUCT`), so two author-placed boxes may overlap however '
+            +'the author says.'
+          : 'Pin one of them clear of the other.')
+        +' Partial overlap is not this error; only a complete cover is.');
+    }
+  }
   // Boundary adjacency in pinned scenes (presentation-only): auto-layout ranks
   // a degree-1 boundary relative to the free lanes, so in a scene where the
   // real content is pinned to a compact box the boundary can drift to a far
@@ -4723,9 +5140,83 @@ function renderScene(doc,y0){
   // drawn as a full concentric ring — drop row, channel, return row and hub
   // entry nested in the same order, entering the hub's top edge on the
   // channel side — so fan-in hubs (N states -> IDLE reset) have no crossings.
+  // ── A RECIPROCAL PAIR RUNS ANTIPARALLEL-ADJACENT (item 58) ───────────────
+  // `A -> B` and `B -> A` between one node pair are ONE EXCHANGE: request
+  // beside reply, and reading it means reading them together. The engine
+  // already had the drawing — `apOff` below fans a same-pair straight group
+  // onto opposite sides of its own centre line, and the label pass puts each
+  // label on the OUTER flank of its own stroke — but it could not reach the
+  // common case, because the second direction of any pair CLOSES A CYCLE and
+  // is therefore a back edge, which the channel plan takes and routes the
+  // long way round the figure. `showcase/arp-resolution` is the case: the ARP
+  // reply left Host B, ran down under the whole figure and climbed back into
+  // Host A, 236 px of detour to say the thing the request says in 100.
+  //
+  // So a reciprocal partner is EXEMPTED FROM THE CHANNEL PLAN and drawn
+  // straight, which puts both members into `apOff` and gives the pair its
+  // two adjacent lines. Note what is NOT touched: `isBack` itself. That set
+  // ranks the figure — it is what breaks the cycle so the layers can be
+  // computed at all — and a rank DAG with the cycle put back has no layering.
+  // This is a ROUTING exemption and nothing else, so it is a second set that
+  // the three routing decisions consult and the ranking never sees.
+  //
+  // THE PAIR MUST BE EXACTLY A PAIR: one edge each way, neither a self-loop,
+  // and the forward member drawn straight itself (a multi-rank forward edge
+  // rides a waypoint chain, and a chain has no single centre line to fan a
+  // partner about). Anything else is a different figure and keeps the routing
+  // it had.
+  const recip=new Set();
+  {
+    const dir=new Map();
+    for(const e of doc.edges){
+      if(!byId[e.a]||!byId[e.b]||e.a===e.b) continue;
+      const k=e.a+'\t'+e.b;
+      if(!dir.has(k)) dir.set(k,[]); dir.get(k).push(e);
+    }
+    // A MERGE BUS OUTRANKS A PAIR. `state_a -> idle` is BOTH the return
+    // half of a reciprocal pair AND one of four returns that item 46 merges
+    // into one trunk, and only one of the two drawings can be on the page.
+    // The bus wins, on its own argument: it says something about FOUR edges
+    // ("all of these fall back to one place") that the pairwise reading
+    // cannot say, and `patterns/state-b` measured 397 ink/edge as four
+    // concentric rings against 101 as four straight lines — but the four
+    // straight lines are four separate statements where the figure makes
+    // one. Taking the pair here would also have silently deleted item 54's
+    // acceptance figure.
+    const inBus=new Set();
+    for(const m of busGroups) for(const e of m) inBus.add(e);
+    for(const m of retBusGroups) for(const e of m) inBus.add(e);
+    // EACH LABEL MUST FIT BESIDE ITS OWN LINE. This is not a nicety bolted
+    // on: it is the second half of the direction ("labels on outer flanks,
+    // each label unambiguously beside its own line"), and a label longer
+    // than the line it names cannot satisfy it — it overhangs both ends and
+    // lands on whatever is past them. Measured: `statechart/bfd-session`'s
+    // `INIT -> DOWN` carries a 200 px two-line label on an 80 px run, and
+    // forcing the pair there cost the figure 3 new label collisions, 3
+    // coincident lines and a label emitted off the canvas. 1.25 is the
+    // allowance — a quarter of the run may overhang, which is what a label
+    // centred on a short link needs and what a label that has nothing to do
+    // with the link exceeds.
+    const RECIP_FIT=1.25;
+    const fits=(e,len)=>!e.mid||lblPx(e.mid)<=len*RECIP_FIT;
+    for(const [k,fwd] of dir){
+      const [a,b]=k.split('\t');
+      const rev=dir.get(b+'\t'+a);
+      if(!rev||fwd.length!==1||rev.length!==1) continue;
+      if(chains.get(fwd[0])||chains.get(rev[0])) continue;
+      if(inBus.has(fwd[0])||inBus.has(rev[0])) continue;
+      const A=byId[a], B=byId[b];
+      const p=borderPoint(A,B.x+B.w/2,B.y+B.h/2), q=borderPoint(B,A.x+A.w/2,A.y+A.h/2);
+      const len=Math.hypot(q[0]-p[0],q[1]-p[1]);
+      if(!fits(fwd[0],len)||!fits(rev[0],len)) continue;
+      recip.add(fwd[0]); recip.add(rev[0]);
+    }
+  }
+  // A back edge the routing treats as straight, for item 58's reason.
+  const chBack=e=>isBack.has(e)&&!recip.has(e);
   const chPlan=new Map(); let chTop=0, chShift=0;
   {
-    const chList=doc.edges.filter(e=>byId[e.a]&&byId[e.b]&&isBack.has(e)&&!pinned(e.a)&&!pinned(e.b));
+    const chList=doc.edges.filter(e=>byId[e.a]&&byId[e.b]&&chBack(e)&&!pinned(e.a)&&!pinned(e.b));
     const near=e=>{ const A=byId[e.a]; return horiz?A.y+A.h/2:A.x+A.w/2; };
     const order=chList.map((e,i)=>({e,i}));
     order.sort((p,q)=>near(q.e)-near(p.e)||p.i-q.i);
@@ -4773,6 +5264,45 @@ function renderScene(doc,y0){
       const m=g.length;
       g.forEach((e,k)=>{ chPlan.get(e).ef=(m-k)/(m+1); });
     }
+    // RETURN BUS COLLAPSE (item 46). Every member of an admitted group takes
+    // the INNERMOST member's ring, slot, entry point and entry fraction, so the
+    // rail, the trunk and the arrival are one line instead of N nested ones.
+    // Deterministic: the innermost member is the one the sort above already put
+    // closest to the channel (lowest ring; ties by document order). The LAST
+    // member in document order draws the arrowhead, the junction dots and the
+    // single label; every other member draws its path only. The label rides the
+    // SHARED run rather than one member's source stub — a stub label would say
+    // the word names that one member, and what the bus asserts is that all of
+    // them say it.
+    //
+    // A group whose members disagree about `ringOK` is not collapsed: the two
+    // route forms enter the target on different edges of the box, so a part-ring
+    // part-channel bus would be two trunks, not one.
+    for(const m of retBusGroups){
+      if(!m.every(e=>chPlan.has(e))) continue;
+      const P0=chPlan.get(m.reduce((a,b)=>chPlan.get(a).ring<=chPlan.get(b).ring?a:b));
+      if(!m.every(e=>chPlan.get(e).ringOK===P0.ringOK)) continue;
+      // Two roles, and they are not the same member. The LABEL goes to the
+      // member whose own leg into the trunk is LONGEST — the forward bus's rule
+      // verbatim, and the reason is the same: the longest leg is the one whose
+      // longest segment is the shared rail, so the word lands on ink every
+      // member draws instead of on the return row above the figure (where the
+      // canvas, which grows right and down only, clips it). The ARROWHEAD and
+      // the junction dots go to the LAST member in document order, because the
+      // dots can only be drawn once every member's own join point exists.
+      const T=byId[m[0].b], tc=horiz?T.y+T.h/2:T.x+T.w/2;
+      let lead=m[0], bestD=-1;
+      for(const e of m){
+        const A2=byId[e.a], d=Math.abs((horiz?A2.y+A2.h/2:A2.x+A2.w/2)-tc);
+        if(d>bestD+0.5){ bestD=d; lead=e; }
+      }
+      const last=m[m.length-1];
+      for(const e of m){
+        const P=chPlan.get(e);
+        P.ring=P0.ring; P.slot=P0.slot; P.ex=P0.ex; P.ef=P0.ef;
+        P.bus=e.b; P.busLead=(e===lead); P.busTail=(e===last);
+      }
+    }
     // ring return rows run above the top rank; shift the whole scene down
     // when they would spill into the title band. The shift is uniform
     // (relative geometry, incl. pins, is preserved) and meta.top reports
@@ -4794,7 +5324,7 @@ function renderScene(doc,y0){
   // opposite sides; endpoints and labels shift together.
   const apOff=new Map();
   {
-    const straight=e=>byId[e.a]&&byId[e.b]&&!(isBack.has(e)&&!pinned(e.a)&&!pinned(e.b))&&!chains.get(e);
+    const straight=e=>byId[e.a]&&byId[e.b]&&!(chBack(e)&&!pinned(e.a)&&!pinned(e.b))&&!chains.get(e);
     const pk=e=>e.a<e.b?e.a+'\t'+e.b:e.b+'\t'+e.a;
     const pairN={}, seen={};
     for(const e of doc.edges) if(straight(e)){ const k=pk(e); pairN[k]=(pairN[k]||0)+1; }
@@ -4809,6 +5339,391 @@ function renderScene(doc,y0){
       apOff.set(e,[-dy/L*off, dx/L*off]);
     }
   }
+  // ── LONG-EDGE CORRIDOR ROUTER — SIDE BY OCCUPANCY, THEN LANES ────────────
+  // Items 41 and 46, and the approach-column half of item 26, for the long
+  // edges the side-channel plan above does not reach: multi-rank forward edges,
+  // and returns whose endpoints are PINNED (the channel plan takes only the
+  // unpinned ones, so a hand-placed statechart's returns were routed by the
+  // straight router and had no corridor at all).
+  //
+  // TWO DEFECTS, ONE MECHANISM.
+  //   41 — `patterns/flowchart-b` routes BOTH its long edges down the right of a
+  //        single-column spine and they cross, while the left margin is empty
+  //        for the figure's whole height. The router never asked which side was
+  //        free: the diagonal took the geometric straight line and the channel
+  //        defaults to one side, so two long edges on one side of one spine are
+  //        guaranteed to meet.
+  //   46 — `statechart/dhcp-client` sends `REQUESTING -> INIT` and
+  //        `BOUND -> INIT` over the top of the figure at near-identical y. They
+  //        read as ONE line with two label stacks.
+  // Both are the same missing question — WHICH corridor, at WHAT height — so
+  // they are answered by one pass: a long edge is offered an orthogonal
+  // corridor route on each margin, at a LANE within that corridor, and the
+  // figure keeps whichever costs least.
+  //
+  // THE COST, and it is item 26's, unchanged:
+  //     10000*(crossings + pierces) + 1000*corridor conflicts + 40*bends + ink
+  // Crossings and pierces dominate because a line through a box or through
+  // another line is a misreading; the CONFLICT term is what this pass adds —
+  // two routes running parallel within a lane width over more than 40 px are
+  // one line to the reader, which is exactly dhcp-client's defect and is
+  // invisible to a crossing count. Ink is charged 1/px so a corridor that buys
+  // nothing loses to the straight line. **The incumbent stays in the candidate
+  // set and is kept unless STRICTLY beaten**, which is what makes this pass
+  // monotone rather than a gamble: a figure whose long edges are already clean
+  // is byte-identical after it.
+  //
+  // THE LANE ORDER IS NOT A CHOICE — it is forced, and the rule is the one the
+  // ring plan above already states. Sources are ordered by DISTANCE FROM THE
+  // TARGET along the flow axis (ties by document order, so one document has one
+  // assignment); the NEAREST source takes lane 0, hard against the figure, and
+  // the FARTHEST takes the outermost lane. It has to be that way round: a far
+  // source on an inner lane has its long run cut by every nearer source's climb
+  // out to an outer lane. For the same reason the ARRIVAL fans across the
+  // target's border — an outer lane must land BEYOND where every inner lane
+  // stops, or it crosses them all on the way in.
+  //
+  // A GROUP IS (target, side of approach). Sources on opposite sides of one
+  // target are two corridors, not one, and laning them together would send a
+  // route the long way round the figure to reach a lane it has no reason to be
+  // in.
+  //
+  // THE LEFT MARGIN EXISTS NOW. The canvas grows right and down only, so a
+  // corridor on the low side needs the scene shifted — the uniform-shift
+  // pattern `bShift`/`chShift` already use, and the thing the self-loop note
+  // below records as missing. Relative geometry (pins included) is preserved
+  // and `meta.left`/`meta.top` report the shifted origin, so the editor's
+  // drag->pin round-trip stays stable.
+  const longPlan=new Map();          // edge -> {side, lane, frac}
+  let lShift=0, tShift=0;
+  if(nodes.length){
+    const CORR_GAP=26, LANE_PITCH=18, PAR_MIN=40;
+    // group bands, computed exactly as gBox draws them below
+    const gbb=[];
+    for(const g of doc.groups){
+      const mem=nodes.filter(n=>n.group===g.id); if(!mem.length) continue;
+      const x0=Math.min(...mem.map(n=>n.x))-BAND.l, x1=Math.max(...mem.map(n=>n.x+n.w))+BAND.r;
+      const yA=Math.min(...mem.map(n=>n.y))-BAND.t, yB=Math.max(...mem.map(n=>n.y+n.h))+BAND.b;
+      gbb.push({x:x0,y:yA,w:x1-x0,h:yB-yA});
+    }
+    const cLo=n=>horiz?n.y:n.x, cHi=n=>horiz?n.y+n.h:n.x+n.w;
+    const fC =n=>horiz?n.x+n.w/2:n.y+n.h/2;
+    const bLo=Math.min(...nodes.map(cLo), ...gbb.map(b=>horiz?b.y:b.x));
+    const bHi=Math.max(...nodes.map(cHi), ...gbb.map(b=>horiz?b.y+b.h:b.x+b.w));
+    const corrAt=(side,off)=>side<0?bLo-CORR_GAP-off:bHi+CORR_GAP+off;
+    // A LANE IS AS WIDE AS WHAT IT CARRIES. A fixed 18 px pitch put
+    // dhcp-client's second return straight through the first one's two-line
+    // label, which is the ink-blind spacing item 44 removed from ranks arriving
+    // again one axis over. The step between two lanes is therefore the inner
+    // lane's own LABEL extent — height when the corridor runs along the flow
+    // axis, width when it runs across it — floored at the bare pitch.
+    const lblExt=e=>Math.max(LANE_PITCH,
+      !e.mid?0:(horiz?String(e.mid).split('\n').length*13+10:lblPx(e.mid)+10));
+    // Lanes are allocated from a per-side pool, not per convergence: two
+    // components that were decided separately (their INCUMBENTS did not share a
+    // corridor) still share the corridor once both are adopted, and dhcp-client
+    // drew exactly that — `RENEWING -> INIT` and `REBINDING -> INIT` laid on one
+    // line along the bottom, `coinc 2`. The pool remembers every adopted run's
+    // span, so a later component takes the next free height over the stretch it
+    // actually occupies and nothing else.
+    const usedLanes=new Map();
+    const allocOff=(side,lo,hi,ext,taken)=>{
+      const list=(usedLanes.get(side)||[]).concat(taken||[]);
+      let off=0;
+      for(let guard=0;guard<64;guard++){
+        let clash=null;
+        for(const u of list)
+          if(Math.min(u.hi,hi)-Math.max(u.lo,lo)>PAR_MIN&&Math.abs(u.off-off)<Math.max(u.ext,ext)
+             &&(!clash||u.off>clash.off)) clash=u;
+        if(!clash) break;
+        off=clash.off+Math.max(clash.ext,ext);
+      }
+      return off;
+    };
+    // A CORRIDOR ROUTE IS BUILT ORTHOGONALLY OR NOT OFFERED AT ALL.
+    // The first cut handed the four-point L to `routeAround` when it hit
+    // something, which is the wrong tool here: Dijkstra over a visibility graph
+    // returns the SHORTEST clear polyline, not an orthogonal one, and on
+    // `patterns/block-b` it returned a five-bend zigzag that doubled back
+    // across the figure (0 -> 9 on the lint, 3 crossings and a `thru`). A
+    // corridor's whole claim is "this margin is free"; when it is not free for
+    // this edge, the honest answer is to withdraw the candidate, not to bend it
+    // until it fits.
+    //
+    // So a leg out of a node is one of exactly two shapes: straight across to
+    // the corridor, or — when something stands in that column — out of the
+    // node's FLOW side, along to the nearest clear column, and across. That is
+    // the escape the side-channel plan above already uses (`blockedV`/
+    // `blockedH`), in the same two forms, and it keeps every corridor route
+    // axis-aligned end to end. If neither shape is clear, `build` returns null
+    // and the figure keeps its incumbent.
+    //
+    // Because the planned route is clean of every node and every group band by
+    // construction, the draw pass runs NO detour on it: plan and drawing are the
+    // same polyline, which is what makes the cost above a prediction rather
+    // than a guess.
+    const P=(f,c)=>horiz?[f,c]:[c,f];
+    const fLoN=n=>horiz?n.x:n.y, fHiN=n=>horiz?n.x+n.w:n.y+n.h;
+    const cLoN=n=>horiz?n.y:n.x, cHiN=n=>horiz?n.y+n.h:n.x+n.w;
+    const oF=o=>horiz?[o.x,o.x+o.w]:[o.y,o.y+o.h];
+    const oC=o=>horiz?[o.y,o.y+o.h]:[o.x,o.x+o.w];
+    const blockCol=(f,c0,c1,obs)=>obs.some(o=>{
+      const [fa,fb]=oF(o), [ca,cb]=oC(o);
+      return f>fa-2&&f<fb+2&&Math.min(c1,cb)>Math.max(c0,ca)+0.5;
+    });
+    const blockRow=(c,f0,f1,obs)=>obs.some(o=>{
+      const [fa,fb]=oF(o), [ca,cb]=oC(o);
+      return c>ca-2&&c<cb+2&&Math.min(f1,fb)>Math.max(f0,fa)+0.5;
+    });
+    // the leg from node N (at flow position f) out to the corridor at cross c,
+    // ordered node-first; null when neither shape is clear
+    const legTo=(N,f,c,obs)=>{
+      const cb=c>cHiN(N)?cHiN(N):cLoN(N);
+      if(!blockCol(f,Math.min(cb,c),Math.max(cb,c),obs)) return [P(f,cb),P(f,c)];
+      const cc=(cLoN(N)+cHiN(N))/2, gs=[];
+      for(const o of obs){ const [fa,fb]=oF(o); gs.push(fa-10,fb+10); }
+      gs.sort((a,b)=>Math.abs(a-f)-Math.abs(b-f)||b-a);
+      for(const g of gs){
+        if(blockCol(g,Math.min(cc,c),Math.max(cc,c),obs)) continue;
+        if(blockRow(cc,Math.min(f,g),Math.max(f,g),obs)) continue;
+        return [P(g>f?fHiN(N):fLoN(N),cc),P(g,cc),P(g,c)];
+      }
+      return null;
+    };
+    const build=(e,q)=>{
+      const A=byId[e.a], B=byId[e.b], c=corrAt(q.side,q.off);
+      const obs=obsFor(A,B);
+      const la=legTo(A,fC(A),c,obs);
+      const lb=legTo(B,horiz?B.x+B.w*q.frac:B.y+B.h*q.frac,c,obs);
+      if(!la||!lb) return null;
+      const fa=la[la.length-1][horiz?0:1], fb=lb[lb.length-1][horiz?0:1];
+      if(blockRow(c,Math.min(fa,fb),Math.max(fa,fb),obs)) return null;
+      const pts=la.concat(lb.slice().reverse());
+      // drop a zero-length hop where the two legs meet on one column
+      for(let i=1;i<pts.length;i++)
+        if(Math.hypot(pts[i][0]-pts[i-1][0],pts[i][1]-pts[i-1][1])<0.5){ pts.splice(i,1); i--; }
+      return pts;
+    };
+    // TWO OBSTACLE SETS, AND THE DIFFERENCE IS DELIBERATE.
+    // `obsFor` — nodes AND foreign group bands — is what a corridor candidate
+    // must be CLEAR OF to be offered at all: a corridor drawn through a band it
+    // neither starts nor ends inside asserts a membership the document does not.
+    // `nodeObs` — nodes only — is what the pierce TERM charges, because that is
+    // what the drawing is measured on (`thru` counts node rectangles). Charging
+    // the incumbent for a band crossing instead made `patterns/block-b`'s `ptr`
+    // edge look two pierces worse than it is measured to be, and the corridor
+    // won a comparison the figure then paid for in crossings it did not have
+    // (0 -> 9). An edge crossing a foreign band is a real defect and it is
+    // backlog items 6 and 19; it is not this pass's to trade measured axes for.
+    const obsFor=(A,B)=>{
+      const o=nodeObs(A,B);
+      const inb=(b,q)=>q[0]>b.x&&q[0]<b.x+b.w&&q[1]>b.y&&q[1]<b.y+b.h;
+      const pa=[A.x+A.w/2,A.y+A.h/2], pb=[B.x+B.w/2,B.y+B.h/2];
+      for(const b of gbb) if(!inb(b,pa)&&!inb(b,pb)) o.push(b);
+      return o;
+    };
+    const nodeObs=(A,B)=>nodes.filter(n=>n!==A&&n!==B&&!n.boundary)
+      .map(n=>({x:n.x,y:n.y,w:n.w,h:n.h}));
+    // occupancy the channel plan will use, recomputed from the same inputs so
+    // the two cannot drift; the shift below moves both together.
+    let occRg=0, occBg=0;
+    for(const n of nodes){ occRg=Math.max(occRg,n.x+n.w); occBg=Math.max(occBg,n.y+n.h); }
+    for(const b of gbb){ occRg=Math.max(occRg,b.x+b.w); occBg=Math.max(occBg,b.y+b.h); }
+    if(!horiz) chains.forEach((chain,e)=>{ if(!e.mid) return;
+      const v=chain[1+Math.floor((chain.length-3)/2)];
+      occRg=Math.max(occRg, v.x+v.w/2+9+lblPx(e.mid)); });
+    // A channel route reconstructed as the draw pass will build it — the plain
+    // form of each of the three shapes. The blocked-detour variants are not
+    // reconstructed: they differ only in a short escape leg near an endpoint,
+    // and this is a comparison of corridors, not of stubs.
+    const chGuess=e=>{
+      const A=byId[e.a], B=byId[e.b], P=chPlan.get(e);
+      if(A===B) return null;
+      if(horiz){
+        const chY=occBg+28+P.slot;
+        return [[A.x+A.w/2,outSide(A,'b')],[A.x+A.w/2,chY],[B.x+B.w*P.ef,chY],[B.x+B.w*P.ef,outSide(B,'b')]];
+      }
+      if(P.ringOK){
+        const sx=A.x+A.w/2, gy=occBg+14+P.ring*12, chX=occRg+28+P.slot, topY=chTop-14-P.ring*12;
+        return [[sx,outSide(A,'b')],[sx,gy],[chX,gy],[chX,topY],[P.ex,topY],[P.ex,outSide(B,'t')]];
+      }
+      const chX=occRg+28+P.slot;
+      return [[outSide(A,'r'),A.y+A.h/2],[chX,A.y+A.h/2],[chX,B.y+B.h*P.ef],[outSide(B,'r'),B.y+B.h*P.ef]];
+    };
+    const guess=e=>{
+      const A=byId[e.a], B=byId[e.b];
+      if(!A||!B||A===B) return null;
+      if(longPlan.has(e)) return longPlan.get(e).pts;
+      if(chPlan.has(e)) return chGuess(e);
+      const ch=chains.get(e), pp=[];
+      if(ch) for(const v of ch.slice(1,-1)) pp.push([v.x+v.w/2,v.y+v.h/2]);
+      const f=pp.length?pp[0]:[B.x+B.w/2,B.y+B.h/2];
+      const l=pp.length?pp[pp.length-1]:[A.x+A.w/2,A.y+A.h/2];
+      const st=[borderPoint(A,f[0],f[1]),...pp,borderPoint(B,l[0],l[1])];
+      // THE INCUMBENT MUST BE GUESSED AS IT WILL BE DRAWN, DETOURS INCLUDED.
+      // Guessing the undetoured line charged the incumbent for pierces the
+      // drawing never contains, and the corridor then won a comparison it had
+      // not earned: `patterns/block-b`'s `ptr` edge scored the incumbent at two
+      // pierces (a chain run measured straight through `Unit B`, which the
+      // chain branch detours around) and took a top corridor that cost the
+      // figure 3 crossings and a `thru` — 0 -> 9. Every guess now runs the same
+      // routeAround pass the draw branches run.
+      const obs=obsFor(A,B);
+      if(st.length>2){
+        for(let i=0;i+1<st.length;i++){
+          const d=routeAround(st[i],st[i+1],obs);
+          if(!d) continue;
+          const ins=d.slice(1,-1); st.splice(i+1,0,...ins); i+=ins.length;
+        }
+        return st;
+      }
+      const rr=routeAround(st[0],st[1],obs);
+      if(!rr) return st;
+      rr[0]=borderPoint(A,rr[1][0],rr[1][1]);
+      rr[rr.length-1]=borderPoint(B,rr[rr.length-2][0],rr[rr.length-2][1]);
+      return rr;
+    };
+    const xseg=(a,b,c,d)=>{
+      const rx=b[0]-a[0], ry=b[1]-a[1], sx=d[0]-c[0], sy=d[1]-c[1];
+      const den=rx*sy-ry*sx; if(Math.abs(den)<1e-9) return false;
+      const t=((c[0]-a[0])*sy-(c[1]-a[1])*sx)/den, u=((c[0]-a[0])*ry-(c[1]-a[1])*rx)/den;
+      return t>1e-6&&t<1-1e-6&&u>1e-6&&u<1-1e-6;
+    };
+    const crossN=(r,o)=>{ let n=0;
+      for(let i=0;i+1<r.length;i++) for(let j=0;j+1<o.length;j++)
+        if(xseg(r[i],r[i+1],o[j],o[j+1])) n++;
+      return n; };
+    const pierceN=(r,A,B)=>{ const obs=nodeObs(A,B); let n=0;
+      for(let i=0;i+1<r.length;i++) if(segHitsObs(r[i],r[i+1],obs)) n++;
+      return n; };
+    const runsOf=r=>{ const out=[];
+      for(let i=0;i+1<r.length;i++){
+        const p=r[i], q=r[i+1], dx=q[0]-p[0], dy=q[1]-p[1];
+        if(Math.abs(dx)<0.5&&Math.abs(dy)>=PAR_MIN) out.push({v:1,c:p[0],lo:Math.min(p[1],q[1]),hi:Math.max(p[1],q[1])});
+        else if(Math.abs(dy)<0.5&&Math.abs(dx)>=PAR_MIN) out.push({v:0,c:p[1],lo:Math.min(p[0],q[0]),hi:Math.max(p[0],q[0])});
+      }
+      return out; };
+    const conflictN=(r,o)=>{ let n=0;
+      for(const a of runsOf(r)) for(const b of runsOf(o))
+        if(a.v===b.v&&Math.abs(a.c-b.c)<LANE_PITCH-1&&Math.min(a.hi,b.hi)-Math.max(a.lo,b.lo)>PAR_MIN) n++;
+      return n; };
+    const inkOf=r=>{ let s=0;
+      for(let i=0;i+1<r.length;i++){
+        const dx=r[i+1][0]-r[i][0], dy=r[i+1][1]-r[i][1], L=Math.hypot(dx,dy);
+        s+=(Math.abs(dx)<0.5||Math.abs(dy)<0.5)?L:L*1.7;
+      }
+      return s; };
+    const costOf=(r,e,peers)=>{
+      if(!r) return Infinity;
+      const A=byId[e.a], B=byId[e.b];
+      let cr=0, cf=0;
+      for(const q of peers){ if(q.e===e||!q.r) continue; cr+=crossN(r,q.r); cf+=conflictN(r,q.r); }
+      return 10000*(cr+pierceN(r,A,B))+1000*cf+40*Math.max(0,r.length-2)+inkOf(r);
+    };
+    const inBus=new Set();
+    for(const m of busGroups) for(const e of m) inBus.add(e);
+    for(const m of retBusGroups) for(const e of m) inBus.add(e);
+    const longE=doc.edges.filter(e=>{
+      const A=byId[e.a], B=byId[e.b];
+      return A&&B&&e.a!==e.b&&!inBus.has(e)&&!chPlan.has(e)
+        &&(isBack.has(e)||Math.abs(B.rank-A.rank)>1);
+    });
+    const grp=new Map();
+    for(const e of longE){
+      const A=byId[e.a], B=byId[e.b];
+      const k=e.b+'|'+(fC(A)>=fC(B)?'+':'-');
+      if(!grp.has(k)) grp.set(k,[]); grp.get(k).push(e);
+    }
+    // THE UNIT OF DECISION IS THE CONFLICT COMPONENT, not the whole convergence.
+    // Measured on dhcp-client: laning ALL FIVE returns to INIT costs 8 crossings
+    // and 9 conflicts against the incumbent's 3 and 2 — the five sources sit in
+    // three different rows, so four of them have to climb PAST the figure to
+    // reach one corridor and cross everything on the way. What is actually
+    // defective there is the PAIR whose runs already share a corridor
+    // (`REQUESTING -> INIT` and `BOUND -> INIT`, one line to the reader). So a
+    // group is split into connected components under "your incumbent route runs
+    // parallel to mine inside one lane width", and each component is decided on
+    // its own. A component of one is still decided — that is item 41's
+    // single-edge side choice, and flowchart-b is a component of one.
+    const comps=[];
+    for(const [,mem] of grp){
+      const inc0=new Map(); for(const e of mem) inc0.set(e,guess(e));
+      const par=mem.map((_,i)=>i);
+      const find=i=>par[i]===i?i:(par[i]=find(par[i]));
+      for(let i=0;i<mem.length;i++) for(let j=i+1;j<mem.length;j++)
+        if(conflictN(inc0.get(mem[i]),inc0.get(mem[j]))) par[find(j)]=find(i);
+      const byRoot=new Map();
+      mem.forEach((e,i)=>{ const r=find(i); if(!byRoot.has(r)) byRoot.set(r,[]); byRoot.get(r).push(e); });
+      for(const [,c] of byRoot) comps.push(c);
+    }
+    for(const mem of comps){
+      const T=byId[mem[0].b], tf=fC(T);
+      const ord=mem.map((e,i)=>({e,i}))
+        .sort((p,q)=>Math.abs(fC(byId[p.e.a])-tf)-Math.abs(fC(byId[q.e.a])-tf)||p.i-q.i)
+        .map(o=>o.e);
+      const nM=ord.length, up=fC(byId[ord[0].a])>=tf;
+      // arrival fractions: lane 0 lands nearest the sources, the outermost
+      // lane beyond every inner lane's turn-in
+      const fracs=ord.map((e,k)=>nM===1?0.5:(up?(nM-k)/(nM+1):(k+1)/(nM+1)));
+      const peerE=doc.edges.filter(x=>byId[x.a]&&byId[x.b]&&x.a!==x.b&&mem.indexOf(x)<0);
+      const peers=peerE.map(x=>({e:x,r:guess(x)}));
+      const inc=ord.map(e=>({e,r:guess(e)}));
+      const base=inc.reduce((s,q)=>s+costOf(q.r,q.e,peers.concat(inc)),0);
+      let best=null, bestC=base, bestSide=0;
+      for(const side of [-1,1]){
+        const taken=[], cand=[];
+        for(let k=0;k<ord.length;k++){
+          const e=ord[k], A=byId[e.a], B=byId[e.b], frac=fracs[k];
+          const a=fC(A), b=horiz?B.x+B.w*frac:B.y+B.h*frac;
+          const lo=Math.min(a,b), hi=Math.max(a,b), ext=lblExt(e);
+          const off=allocOff(side,lo,hi,ext,taken);
+          taken.push({off,lo,hi,ext});
+          const q={side,off,frac};
+          cand.push({e,q,r:build(e,q),u:{off,lo,hi,ext}});
+        }
+        if(cand.some(z=>!z.r)) continue;    // a corridor that is not free here
+        const c=cand.reduce((s,z)=>s+costOf(z.r,z.e,peers.concat(cand)),0);
+        if(c<bestC-1e-6){ bestC=c; best=cand; bestSide=side; }
+      }
+      if(best){
+        if(!usedLanes.has(bestSide)) usedLanes.set(bestSide,[]);
+        for(const z of best){ z.q.pts=z.r; longPlan.set(z.e,z.q); usedLanes.get(bestSide).push(z.u); }
+      }
+    }
+    // the low-side margin the adopted corridors need, taken as a uniform shift
+    let minC=Infinity;
+    for(const [,q] of longPlan) if(q.side<0) minC=Math.min(minC,corrAt(q.side,q.off));
+    if(minC!==Infinity){
+      if(horiz) tShift=Math.max(0,(y0+26)-minC);
+      else      lShift=Math.max(0,6-minC);
+    }
+    if(lShift||tShift){
+      for(const n of lay){ n.x+=lShift; n.y+=tShift; }
+      for(const k in gOrigin){ gOrigin[k].x+=lShift; gOrigin[k].y+=tShift; }
+      for(const [,q] of longPlan) q.pts=q.pts.map(z=>[z[0]+lShift,z[1]+tShift]);
+      chTop+=tShift;
+    }
+  }
+  // THE SOURCE STUB a long edge's label rides: the first stretch of the route as
+  // it LEAVES the source, capped so the box lands beside the box the line comes
+  // out of rather than halfway down the corridor. The cap scales with the LABEL
+  // (a stub shorter than the label puts the box back on top of the source
+  // whatever parameter is chosen), and it is shared by the channel routes and
+  // the corridor routes because both have the same problem: a long run whose
+  // far end is nowhere near either endpoint.
+  const srcStubOf=(pp,wpx)=>{
+    const a=pp[0], b=pp[1], L=Math.hypot(b[0]-a[0],b[1]-a[1])||1;
+    const k=Math.min(1,Math.max(64,wpx+24)/L);
+    return [a,[a[0]+(b[0]-a[0])*k, a[1]+(b[1]-a[1])*k]];
+  };
+  // THE DRAWN ROUTE IS THE PLANNED ROUTE, to the pixel. An earlier cut rebuilt
+  // the polyline at draw time from the final coordinates, and the rebuild was a
+  // SIMPLER builder than the planner's — it had no escape leg — so a corridor
+  // whose arrival the planner had routed around a node was redrawn straight
+  // through it (`dhcp-client` gained a `thru` that way). The plan carries its
+  // own points, translated once with the scene shift, and nothing recomputes
+  // them: whatever the cost function scored is exactly what the reader sees.
+  const longRoute=e=>{ const q=longPlan.get(e); return q?q.pts.map(z=>z.slice()):null; };
   let W=0,Hh=0;
   for(const n of lay){ W=Math.max(W,n.x+n.w); Hh=Math.max(Hh,n.y+n.h-y0-20); }
   if(W===0){W=480;} if(Hh===0){Hh=280;}
@@ -4842,6 +5757,230 @@ function renderScene(doc,y0){
     const [bx,by,bw,bh]=bandRect(f,B.x0,B.yA,B.x1,B.yB);
     gsvg.push('<rect x="'+bx+'" y="'+by+'" width="'+bw+'" height="'+bh+'" fill="'+f.fill+'" opacity="0.9"'+bandEdge(f)+'/>');
   }
+  // ── ELEMENT LABELS ARE INK, AND A ROUTE MUST GO ROUND THEM (item 45a) ─────
+  // §14.4's frontier, on the drawing side. `showcase/arp-resolution` ran the
+  // GREEN unicast shaft straight through `rest of the LAN (hosts C, D, ...)`,
+  // and the misreading it invites — that the unicast reaches the rest of the
+  // LAN — is the exact claim the figure exists to deny. The router's obstacle
+  // set was node boxes and group rects: geometry that is DRAWN AS A SHAPE. An
+  // external is never drawn as a shape (`EXTERNAL-EDGE-ENDPOINTS`) and a band NAME is not a shape at
+  // all, so both were invisible to routing while being fully visible on the
+  // page.
+  //
+  // The mechanism is the SMALLEST one consistent with the router that exists:
+  // these two label boxes join the obstacle list `routeAround` already takes,
+  // so a shaft detours around them exactly as it detours around a node. The
+  // alternative — making the LABEL yield — was rejected: an external's label
+  // has one meaningful place (beyond the open end, away from the figure, `EXTERNAL-EDGE-ENDPOINTS`)
+  // and a band's name has one place (the strip it names), so a yielding label
+  // has nowhere to go, and moving it would break the very adjacency that makes
+  // it readable. A node's own label needs nothing here: it lives inside the
+  // node box, which is already an obstacle.
+  //
+  // An external's label is NOT an obstacle to its OWN edge — that edge must
+  // reach the anchor the label names.
+  const extLbl=n=>{
+    const cx=n.x+n.w/2, cy=n.y+n.h/2, [bdx,bdy]=bDir(n);
+    const bw=lblPx(n.label), bl=String(n.label).split('\n').length, bh=13*bl;
+    let ox,oy;
+    if(Math.abs(bdx)>=Math.abs(bdy)){ ox=bdx>=0?cx+10:cx-10-bw; oy=cy+3.5-13*bl/2-1.5; }
+    else { ox=cx-bw/2; oy=(bdy>=0?cy+17:cy-10)-13*bl/2-1.5; }
+    return {x:ox,y:oy,w:bw,h:bh};
+  };
+  const extObs=[];
+  for(const n of nodes) if(n.boundary&&n.label) extObs.push(Object.assign(extLbl(n),{id:n.id}));
+  const nameObs=[];
+  for(const k in gBox){ const g=doc.groups.find(z=>z.id===k);
+    if(!g||!g.label) continue;
+    const B=gBox[k];
+    nameObs.push({x:B.x0+10, y:B.yA+16-11.5*0.85, w:cwMax(g.label)*6.5*11.5/11, h:11.5*1.1});
+  }
+  // The obstacle list a given edge must respect: every band name, plus every
+  // external label except the ones this edge itself terminates at.
+  // A label's ink is its glyphs plus the clearance that keeps a line from
+  // READING as struck through it. 4 px on every side — the same number the
+  // legibility floor uses for a label's association margin — so a shaft that
+  // grazes a name at 3 px is detoured rather than tolerated.
+  const LBL_PAD=4;
+  const padded=o=>({x:o.x-LBL_PAD,y:o.y-LBL_PAD,w:o.w+2*LBL_PAD,h:o.h+2*LBL_PAD});
+  const lblObs=e=>extObs.filter(o=>o.id!==e.a&&o.id!==e.b).map(padded)
+                        .concat(nameObs.map(padded));
+  // ── A BUNDLE RING IS ORIENTED BY ITS MEMBERS (item 43) ───────────────────
+  // Until now the ring was derived from the member links' MIDPOINTS and
+  // nothing else: `rx = max(46, x-spread + 38)`, `ry = max(26, y-spread + 22)`.
+  // Two facts about that formula are the defect. It is DIRECTION-BLIND — the
+  // axes are the canvas's, never the links' — and its floors are large enough
+  // that a bundle of two short legs draws a near-circle whatever the legs do.
+  // Measured on `patterns/topology-b`: rx 46 / ry 42.7, aspect
+  // 1.07, sitting on two legs that fan VERTICALLY, with the caption lying
+  // across the waist and on top of the `p3` endpoint label.
+  //
+  // The drawing convention for a link bundle is a loop THROUGH which the
+  // links run: narrow along the links, long across them. So the ring is now
+  // derived from the members' own frame.
+  //
+  //  1. DIRECTION. The mean UNDIRECTED direction of the members, by the
+  //     doubled-angle circular mean — doubling is what makes `a--b` and
+  //     `b--a` the same direction, so a bundle does not change shape when an
+  //     author writes a member the other way round (conformance 394).
+  //  2. THE BAND. The ring sits at the MIDPOINT OF THE MEMBERS' SHARED RUN
+  //     along that direction — the stretch of the corridor every member is
+  //     actually in. That is the placement rule because it is the only band
+  //     at which "the spread of the members" is a fact about all of them: a
+  //     fanning set (the reference topology's ECMP pair, which leaves two
+  //     different spines and arrives at one leaf) has a different spread at
+  //     every station, and the shared run is the interval over which the
+  //     question is even well posed. Members with no shared run at all fall
+  //     back to the mean of their midpoints, which is the old centre.
+  //  3. THE AXES. MINOR along the mean direction, sized to clear the strokes;
+  //     MAJOR across it, the members' spread at the band plus padding. A ring
+  //     needs a long axis to read as a ring, and it takes it from the spread
+  //     when the members fan (`rA >= rL`) and from its own RUN when they do
+  //     not — a single-member bundle (`reference/topology`'s multi-home link)
+  //     has zero spread, and the shape that hugs one link is an ellipse lying
+  //     ALONG it, never a circle straddling it.
+  //  4. NO NODE CONTACT. The ring is shrunk along its minor axis until it
+  //     clears every node box, and if it cannot it reverts to the pre-0.4
+  //     geometry rather than inventing a shape (no corpus figure does).
+  //
+  // The caption is NOT placed here — it is registered with the label pass
+  // below, so it can see the endpoint labels and the edges it has to avoid.
+  const rnd3=v=>Math.round(v*1000)/1000;   // ring coordinates, printed short
+  const RING_ALONG=15,      // semi-minor: the ring's body along the links
+        RING_ACROSS=20,     // clearance beyond the outermost member
+        RING_LONG=34,       // the long axis a ring needs to read as a ring
+        RING_FAN=2,         // below this spread the members are one line
+        RING_FLOOR=7,       // how thin the minor axis may be squeezed
+        RING_SOLO=4;        // a ONE-member bundle: the caption's stand-off
+  // ── A ONE-MEMBER BUNDLE IS ITS CAPTION (item 53) ─────────────────────────
+  // `bundle mh "multi-home" l1--l2` is legal and means something real (a
+  // one-link LAG, an Ethernet Segment with a single member), so the
+  // declaration is not an error and is not dropped. But a ring exists to
+  // UNITE lines, and around ONE line it unites nothing: it is ink that adds
+  // no fact, and on the reference topology it also bought the seam a 104 px
+  // corridor demand (2*RX_MIN + clearance) for a shape nobody had to see.
+  //
+  // So a single-member bundle DRAWS NO ELLIPSE. What it draws is its
+  // CAPTION, bundle-styled (the trunk's own stroke, the ring caption's type)
+  // and placed BY THE LINK — which is exactly the statement the construct
+  // makes: this link is the bundle, and here is its name. The frame below is
+  // therefore kept as a PLACEMENT frame and not as a drawing: the caption
+  // pass already sites a caption around a ring's rim, so a ring squeezed to
+  // `RING_SOLO` across gives the same pass a candidate family hugging the
+  // link. Nothing else in the pass changes.
+  //
+  // AN EMPTY CAPTION ON A ONE-MEMBER BUNDLE THEREFORE DRAWS NOTHING AT ALL.
+  // That is a real consequence and it is not hidden: the reference figure
+  // keeps `bundle unlabelled "" s2--l2` — it is the form demonstrator for
+  // the empty label — and states in a comment that this form is now
+  // MODEL-ONLY. The model still carries the trunk, `read` still reports it,
+  // and the drawing says nothing because there is nothing a ring around one
+  // unnamed line could say.
+  // Does the ring's disc meet an axis-aligned rect? Both are mapped into the
+  // frame where the ring is the unit circle; the rect becomes a convex quad,
+  // and the test is "is the quad within 1 of the origin".
+  const ringHitsRect=(R,RL,RA,b)=>{
+    const q=[[b.x,b.y],[b.x+b.w,b.y],[b.x+b.w,b.y+b.h],[b.x,b.y+b.h]].map(p=>{
+      const dx=p[0]-R.cx, dy=p[1]-R.cy;
+      return [(R.ux*dx+R.uy*dy)/RL, (R.vx*dx+R.vy*dy)/RA];
+    });
+    let inside=false;
+    for(let i=0,j=3;i<4;j=i++)
+      if((q[i][1]>0)!==(q[j][1]>0) &&
+         0 < (q[j][0]-q[i][0])*(0-q[i][1])/(q[j][1]-q[i][1])+q[i][0]) inside=!inside;
+    if(inside) return true;
+    for(let i=0,j=3;i<4;j=i++){
+      const vx=q[j][0]-q[i][0], vy=q[j][1]-q[i][1], L2=vx*vx+vy*vy;
+      const t=L2?Math.max(0,Math.min(1,-(q[i][0]*vx+q[i][1]*vy)/L2)):0;
+      if(Math.hypot(q[i][0]+t*vx, q[i][1]+t*vy)<1) return true;
+    }
+    return false;
+  };
+  const ringOf=t=>{
+    const segs=[];
+    for(const [a,b] of t.pairs){
+      const A=byId[a], B=byId[b]; if(!A||!B) continue;
+      const p=borderPoint(A,B.x+B.w/2,B.y+B.h/2), q=borderPoint(B,A.x+A.w/2,A.y+A.h/2);
+      if(Math.hypot(q[0]-p[0],q[1]-p[1])>1e-9) segs.push([p,q]);
+    }
+    if(!segs.length) return null;
+    // (1) mean undirected direction
+    let c2=0,s2=0;
+    for(const [p,q] of segs){
+      const L=Math.hypot(q[0]-p[0],q[1]-p[1]);
+      const c=(q[0]-p[0])/L, s=(q[1]-p[1])/L;
+      c2+=c*c-s*s; s2+=2*c*s;
+    }
+    const th=Math.hypot(c2,s2)<1e-9
+      ? Math.atan2(segs[0][1][1]-segs[0][0][1], segs[0][1][0]-segs[0][0][0])
+      : 0.5*Math.atan2(s2,c2);
+    const ux=Math.cos(th), uy=Math.sin(th), vx=-uy, vy=ux;
+    // (2) the band: the midpoint of the shared run
+    const iv=segs.map(([p,q])=>{
+      const a=ux*p[0]+uy*p[1], b=ux*q[0]+uy*q[1];
+      return a<=b?[a,b,p,q]:[b,a,q,p];
+    });
+    const lo=Math.max(...iv.map(z=>z[0])), hi=Math.min(...iv.map(z=>z[1]));
+    const s=lo<hi ? (lo+hi)/2 : iv.reduce((x,z)=>x+(z[0]+z[1])/2,0)/iv.length;
+    const P=iv.map(z=>{
+      const f=Math.min(1,Math.max(0,(s-z[0])/((z[1]-z[0])||1)));
+      return [z[2][0]+(z[3][0]-z[2][0])*f, z[2][1]+(z[3][1]-z[2][1])*f];
+    });
+    const cx=P.reduce((a,p)=>a+p[0],0)/P.length, cy=P.reduce((a,p)=>a+p[1],0)/P.length;
+    const spread=Math.max(...P.map(p=>Math.abs(vx*(p[0]-cx)+vy*(p[1]-cy))));
+    const runHalf=Math.min(...iv.map(z=>Math.min(s-z[0],z[1]-s)));
+    // (3) axes. Two shapes, and which one is drawn is decided by whether the
+    // members FAN at all. A set that fans is CROSSED by the ring: thin along
+    // the links, long enough across them to take the whole spread with room
+    // to spare, so each member passes through a part of the rim where the
+    // ring is still visibly open. A set that does not fan — one link, or
+    // members lying on top of each other — has no spread to take, and the
+    // shape that says "this link is the bundle" is an ellipse lying ALONG it.
+    let rA, rL;
+    if(spread<RING_FAN){ rL=Math.max(RING_ALONG,Math.min(RING_LONG,Math.max(0,runHalf))); rA=RING_ACROSS; }
+    else { rL=RING_ALONG; rA=Math.max(spread+RING_ACROSS,RING_LONG); }
+    const R={cx,cy,ux,uy,vx,vy,th};
+    // (0) ONE MEMBER (item 53): no ellipse is drawn, so this is a caption
+    // frame and not a shape. It is squeezed across to `RING_SOLO` so the
+    // caption pass's rim stations sit beside the link rather than a ring's
+    // radius away from it, and the node-clearance step below is skipped —
+    // there is no ink to keep out of a box.
+    if(segs.length===1){
+      R.solo=true; R.rL=rL; R.rA=RING_SOLO;
+      R.hw=Math.hypot(rL*ux, RING_SOLO*vx); R.hh=Math.hypot(rL*uy, RING_SOLO*vy);
+      return R;
+    }
+    // (4) out of every node box
+    const boxes=nodes.filter(n=>!n.boundary).map(n=>({x:n.x,y:n.y,w:n.w,h:n.h}));
+    if(boxes.some(b=>ringHitsRect(R,rL,rA,b))){
+      let ok=false;
+      for(let k=1;k<=24&&!ok;k++){
+        const RL=rL-(rL-RING_FLOOR)*k/24;
+        if(!boxes.some(b=>ringHitsRect(R,RL,rA,b))){ rL=RL; ok=true; }
+      }
+      // No orientation of this ring clears the drawing. Rather than publish a
+      // ring lying over a node, revert to the pre-0.4 derivation, which is at
+      // least the shape every earlier artifact recorded. No corpus figure
+      // takes this branch; it exists so that a hostile geometry degrades to
+      // the old defect instead of a new one.
+      if(!ok){
+        const M=segs.map(([p,q])=>[(p[0]+q[0])/2,(p[1]+q[1])/2]);
+        const mx=M.reduce((a,m)=>a+m[0],0)/M.length, my=M.reduce((a,m)=>a+m[1],0)/M.length;
+        const lx=Math.max(46,Math.max(...M.map(m=>Math.abs(m[0]-mx)))+38);
+        const ly=Math.max(26,Math.max(...M.map(m=>Math.abs(m[1]-my)))+22);
+        return {cx:mx, cy:my, ux:1, uy:0, vx:0, vy:1, th:0, legacy:true,
+                rL:lx, rA:ly, hw:lx, hh:ly};
+      }
+    }
+    R.rL=rL; R.rA=rA;
+    // the axis-aligned box the caption is placed beside and the canvas grows to
+    R.hw=Math.hypot(rL*ux, rA*vx); R.hh=Math.hypot(rL*uy, rA*vy);
+    return R;
+  };
+  const rings=new Map();
+  for(const t of doc.trunks||[]){ const R=ringOf(t); if(R) rings.set(t,R); }
+  // filled by the label pass below, consumed by the ring drawing further down
+  const ringLbl=new Map(), ringLeads=[];
   // edges (sorted by plane z, then doc order)
   const edges=zsort(doc.edges);
   const esvg=[], lblsvg=[];  // labels paint last = closest to the viewer
@@ -4862,6 +6001,12 @@ function renderScene(doc,y0){
   // (direction: from→tip). Geometry matches #arr marker (viewBox 0 0 10 10,
   // refX=9, refY=5, markerWidth=7, markerHeight=7, markerUnits=strokeWidth=1.6):
   //   arm = 9*(7/10)*1.6 ≈ 10.08 px, half-width = 5*(7/10)*1.6 ≈ 5.6 px.
+  // Which edge is currently drawing, and which `lblsvg` slots its arrowheads
+  // took. Item 55 recolours an edge AFTER the label pass has run, and an
+  // arrowhead in a different colour from its own shaft is not a discrimination
+  // aid, it is a bug. Recorded rather than inferred: the arrowhead carries no
+  // id of its own.
+  let arrowOwner=null; const arrowIdx=new Map();
   const arrowTri=(tip,from,col)=>{
     const dx=tip[0]-from[0], dy=tip[1]-from[1], L=Math.hypot(dx,dy)||1;
     const ux=dx/L, uy=dy/L;          // unit vector from→tip
@@ -4873,6 +6018,9 @@ function renderScene(doc,y0){
     arrowBox.push({x:Math.min(tip[0],lx,rx), y:Math.min(tip[1],ly,ry),
                    w:Math.max(tip[0],lx,rx)-Math.min(tip[0],lx,rx),
                    h:Math.max(tip[1],ly,ry)-Math.min(tip[1],ly,ry)});
+    if(arrowOwner){ let a=arrowIdx.get(arrowOwner);
+                    if(!a){ a=[]; arrowIdx.set(arrowOwner,a); }
+                    a.push(lblsvg.length-1); }
   };
   // back-edge side channel: beyond the occupied lanes (nodes AND group boxes)
   let occR=0, occB=0;
@@ -4924,6 +6072,9 @@ function renderScene(doc,y0){
   // figure where every convergence is a trunk, or none is, is one drawing
   // either way. There is deliberately no per-edge escape.
   const busRoute=new Map();
+  // Where each RETURN-BUS member's own leg meets the shared trunk, collected as
+  // the members draw so the last one can dot the joins (item 46).
+  const busJoins=new Map();
   {
     const RAIL_GAP=22, RAIL_CLEAR=12, RAIL_ROOM=30;
     const fLo=n=>horiz?n.x:n.y, fHi=n=>horiz?n.x+n.w:n.y+n.h;
@@ -4961,7 +6112,7 @@ function renderScene(doc,y0){
     for(const e of edges){
       if(!byId[e.a]||!byId[e.b]||e.a===e.b) continue;
       if(busMem.has(e)) continue;
-      if(isBack.has(e)&&!pinned(e.a)&&!pinned(e.b)) continue;   // channel routes: not reconstructible here
+      if(chBack(e)&&!pinned(e.a)&&!pinned(e.b)) continue;       // channel routes: not reconstructible here
       others.push(incumbent(e));
     }
     const xseg=(a,b,c,d)=>{
@@ -4995,6 +6146,51 @@ function renderScene(doc,y0){
     };
     const built=[];
     let figureOK=busGroups.length>0;
+    // ── TWO TRUNK FORMS, AND WHY THERE HAD TO BE A SECOND (item 60) ────────
+    // FORM 1, THE CROSS RAIL, is the construct as first built: the sources
+    // spread across the cross axis, each drops onto a shared rail just short
+    // of the target, and the rail carries them in. It assumes the sources are
+    // BESIDE one another. When they are not — when the figure is a ladder and
+    // the sources sit one above the other in a single column — the "drop"
+    // from the far source runs straight down the column and through every
+    // source between it and the target, so the form fails its own pierce test
+    // and the figure declined. `statechart/bfd-session` is exactly that shape:
+    // three purple dashed `admin disable` transitions, DOWN/INIT/UP -> ADMINDOWN,
+    // one class and one meaning, drawn as three separate lines in a few pixels
+    // of shared column with the one sentence written three times.
+    //
+    // FORM 2, THE COLUMN TRUNK, is the same statement rotated: each source
+    // leaves on its cross-facing border, runs the short way out to a trunk
+    // standing clear of the column, and the trunk runs ALONG the flow axis
+    // into the target's side. One trunk, one stroke, one arrowhead, junction
+    // dots at the interior joins, and item 54's per-leg labels at each origin
+    // block edge — the same drawing `patterns/state-b` makes with its four
+    // `reset` returns, which is the pattern the review named.
+    //
+    // Both forms face the same three tests, in the same order, and a form
+    // that fails any of them is not offered: every leg clears every node and
+    // band it does not touch; the form crosses no more of the figure than the
+    // routes it replaces; and — clause 3 of the figure-level style rule above
+    // — if NO form passes for ANY eligible group, the whole figure declines.
+    // The rail is offered first and ties go to it, so no figure that draws a
+    // rail today starts drawing a column instead.
+    const TRUNK_GAP=24;
+    // WHERE ON THE BORDER A BUS LEG LEAVES, AND WHY IT IS THREE EIGHTHS.
+    // Not the centre: every other route in and out of a box is anchored there,
+    // so a leg on the centre-line lies along whatever that border already
+    // sends the same way — measured on `bfd-session`, the three legs ran
+    // exactly down the three red teardown routes, coinc 0 -> 6 and F5 1 -> 8.
+    // Not a quarter either, and that is the same lesson one step further in:
+    // the side-channel plan spreads its own arrivals at k/(m+1) of a box's
+    // extent, so a box with three of them anchors at 1/4, 1/2 and 3/4 and a
+    // leg at 1/4 lands ON one — coinc 0 -> 2 (bfd's DOWN, 107 px of shared
+    // ink), also measured. 3/8 sits BETWEEN the plan's own stations, and it
+    // measures best of everything tried: leg fractions 1/8, 1/5, 1/4, 3/10,
+    // 3/8 and 2/5 give score 38, 20, 22, 16, 16, 16 on bfd, with 3/8 the
+    // middle of the three that tie. Toward the target, because that is the
+    // way the bus is going.
+    const BUS_OFF=3/8;
+    const crossLo=n=>horiz?n.y:n.x, crossHi=n=>horiz?n.y+n.h:n.x+n.w;
     for(const mem of busGroups){
       if(!figureOK) break;
       const T=byId[mem[0].b], src=mem.map(e=>byId[e.a]);
@@ -5005,37 +6201,120 @@ function renderScene(doc,y0){
       const railF=dir>0
         ? Math.min(fLo(T)-RAIL_CLEAR, Math.max(fLo(T)-RAIL_GAP, Math.max(...src.map(fHi))+RAIL_CLEAR))
         : Math.max(fHi(T)+RAIL_CLEAR, Math.min(fHi(T)+RAIL_GAP, Math.min(...src.map(fLo))-RAIL_CLEAR));
-      const tc=cC(T);
-      const cand=[]; let ok=true;
-      for(const e of mem){
-        const s=byId[e.a], cs=cC(s);
-        const j=P(railF,cs), h=P(railF,tc);
-        const pts=Math.abs(cs-tc)<0.5
-          ? [borderPoint(s,h[0],h[1]), h, borderPoint(T,h[0],h[1])]
-          : [borderPoint(s,j[0],j[1]), j, h, borderPoint(T,h[0],h[1])];
-        const obs=obsFor(s,T);
-        for(let i=0;i+1<pts.length;i++) if(segHitsObs(pts[i],pts[i+1],obs)) ok=false;
-        if(!ok) break;
-        cand.push({e,cs,pts});
+      // The trunk's ENTRY is off the target's centre-line for the same reason
+      // its legs are off their sources' (see the leg comment below): on
+      // `bfd-session` the entry ran back along the `admin enable` return
+      // leaving ADMINDOWN's own border centre, 92 px of shared ink and coinc 4.
+      // It enters a quarter of the box's flow extent on the side the bus comes
+      // FROM, which is the side a reader traces it back along.
+      const tc=cC(T), ftc0=(fLo(T)+fHi(T))/2;
+      const forms=[];
+      // FORM 1 — the cross rail. `u` is a member's position ALONG the trunk,
+      // which is the cross axis here and the flow axis in form 2; everything
+      // downstream (dots, lead) is written in `u` so it serves both.
+      {
+        const cand=[]; let ok=true;
+        for(const e of mem){
+          const s=byId[e.a], cs=cC(s);
+          const j=P(railF,cs), h=P(railF,tc);
+          const pts=Math.abs(cs-tc)<0.5
+            ? [borderPoint(s,h[0],h[1]), h, borderPoint(T,h[0],h[1])]
+            : [borderPoint(s,j[0],j[1]), j, h, borderPoint(T,h[0],h[1])];
+          const obs=obsFor(s,T);
+          for(let i=0;i+1<pts.length;i++) if(segHitsObs(pts[i],pts[i+1],obs)) ok=false;
+          if(!ok) break;
+          cand.push({e,u:cs,jp:j,pts});
+        }
+        if(ok) forms.push({cand,uT:tc,tp:P(railF,tc)});
+      }
+      // FORM 2 — the column trunk. The trunk stands one TRUNK_GAP clear of
+      // every box the run passes, on whichever side is cleaner; a band it
+      // cannot clear is caught by the same pierce test as a node.
+      {
+        const ftc=ftc0-dir*(fHi(T)-fLo(T))*BUS_OFF;
+        const runLo=Math.min(...src.map(fLo).concat([fLo(T)])),
+              runHi=Math.max(...src.map(fHi).concat([fHi(T)]));
+        const thru=nodes.filter(n=>!n.boundary&&fHi(n)>runLo+0.5&&fLo(n)<runHi-0.5);
+        // WHERE THE TRUNK STANDS, AND WHY "CLEAR OF THE BOXES" IS NOT ENOUGH.
+        // The first build put the trunk one gap outside the widest BOX in the
+        // run, and on `bfd-session` that is x=149 — straight through the
+        // waypoint detour the green DOWN -> UP advance edge takes at x=193.
+        // The bus crossed 3 where the three separate lines crossed 1, the
+        // never-worse test refused it, and the refusal was right: a trunk
+        // drawn across the figure's existing routes is not a tidier drawing.
+        // So each side offers TWO stations — one just outside the boxes, one
+        // outside every route the figure already draws across the same span —
+        // and the tight one is offered first so a figure only pays the extra
+        // width when the crossings say it must.
+        const oX=[];
+        for(const o of others) for(let i=0;i+1<o.length;i++){
+          const a=o[i], b=o[i+1], af=horiz?a[0]:a[1], bf=horiz?b[0]:b[1];
+          if(Math.max(af,bf)<runLo-0.5||Math.min(af,bf)>runHi+0.5) continue;
+          oX.push(horiz?a[1]:a[0], horiz?b[1]:b[0]);
+        }
+        const stations=[];
+        if(thru.length){
+          const nHi=Math.max(...thru.map(crossHi)), nLo=Math.min(...thru.map(crossLo));
+          stations.push(nHi+TRUNK_GAP, nLo-TRUNK_GAP);
+          if(oX.length){
+            const clearHi=Math.max(nHi,...oX)+TRUNK_GAP, clearLo=Math.min(nLo,...oX)-TRUNK_GAP;
+            if(clearHi>nHi+TRUNK_GAP+0.5) stations.splice(1,0,clearHi);
+            if(clearLo<nLo-TRUNK_GAP-0.5) stations.push(clearLo);
+          }
+        }
+        for(const trunkC of stations){
+          if(trunkC<TRUNK_GAP) continue;          // off the left/top margin
+          const cand=[]; let ok=true;
+          for(const e of mem){
+            // THE LEG DOES NOT LEAVE ON THE CENTRE-LINE. Every other route in
+            // and out of a box is anchored on its border centre, so a bus leg
+            // that leaves there lies along whatever that box already sends the
+            // same way: on `bfd-session` the three legs ran EXACTLY down the
+            // three red teardown routes leaving the same borders (coinc 0 -> 6,
+            // F5 1 -> 8, both measured). The leg therefore leaves a quarter of
+            // the box's flow extent TOWARD the target — the direction it is
+            // going anyway — which frees the centre-line for the traffic that
+            // has nowhere else to be.
+            const s=byId[e.a], fsc=(fLo(s)+fHi(s))/2+dir*(fHi(s)-fLo(s))*BUS_OFF;
+            const j=P(fsc,trunkC), h=P(ftc,trunkC);
+            // The leg leaves the border AT its own flow position, not at the
+            // point a ray from the box centre happens to cross: a bus is
+            // axis-aligned by construction (see the style decision above), and
+            // `borderPoint` would start the leg on the centre ray and slant it.
+            const ex0=P(fsc, trunkC>cC(s)?crossHi(s):crossLo(s));
+            const en0=P(ftc, trunkC>cC(T)?crossHi(T):crossLo(T));
+            const pts=[ex0, j, h, en0];
+            const obs=obsFor(s,T);
+            for(let i=0;i+1<pts.length;i++) if(segHitsObs(pts[i],pts[i+1],obs)) ok=false;
+            if(!ok) break;
+            cand.push({e,u:fsc,jp:j,pts});
+          }
+          if(ok) forms.push({cand,uT:ftc,tp:P(ftc,trunkC)});
+        }
       }
-      if(!ok){ figureOK=false; break; }             // a leg pierces something
-      const bpts=cand.map(c=>c.pts), ipts=mem.map(incumbent);
-      const bc=crossCount(bpts)+pierceCount(bpts,mem);
+      const ipts=mem.map(incumbent);
       const ic=crossCount(ipts)+pierceCount(ipts,mem);
-      if(bc>ic){
-        figureOK=false; break;                      // not beaten: keep the incumbents
+      let pick=null, pickC=Infinity;
+      for(const F of forms){
+        const bpts=F.cand.map(c=>c.pts);
+        const bc=crossCount(bpts)+pierceCount(bpts,mem);
+        if(bc>ic) continue;             // not beaten: keep the incumbents
+        if(bc<pickC-0.5){ pickC=bc; pick=F; }
       }
-      // junction dots mark the interior joins only: the two ends of the rail
+      if(!pick){ figureOK=false; break; }
+      const cand=pick.cand, uT=pick.uT;
+      // junction dots mark the interior joins only: the two ends of the trunk
       // are corners, not junctions, and a dot on a corner is wrong.
-      const xs=cand.map(c=>c.cs).concat([tc]);
-      const cLo=Math.min(...xs), cHi=Math.max(...xs);
+      const us=cand.map(c=>c.u).concat([uT]);
+      const uLo=Math.min(...us), uHi=Math.max(...us);
       const dots=[];
-      for(const c of cand) if(c.cs>cLo+0.5&&c.cs<cHi-0.5) dots.push(P(railF,c.cs));
-      if(tc>cLo+0.5&&tc<cHi-0.5&&!dots.some(d=>Math.abs(d[horiz?1:0]-tc)<0.5)) dots.push(P(railF,tc));
-      // one label and one arrowhead for the whole bus: the member whose rail
-      // run is longest carries the label, document order breaks the tie.
+      for(const c of cand) if(c.u>uLo+0.5&&c.u<uHi-0.5) dots.push(c.jp);
+      if(uT>uLo+0.5&&uT<uHi-0.5&&
+         !dots.some(d=>Math.hypot(d[0]-pick.tp[0],d[1]-pick.tp[1])<0.5)) dots.push(pick.tp);
+      // one arrowhead for the whole bus, and the member whose trunk run is
+      // longest leads it; document order breaks the tie.
       let lead=cand[0], best=-1;
-      for(const c of cand){ const d=Math.abs(c.cs-tc); if(d>best+0.5){ best=d; lead=c; } }
+      for(const c of cand){ const d=Math.abs(c.u-uT); if(d>best+0.5){ best=d; lead=c; } }
       built.push({T,cand,dots,lead});
     }
     // Nothing to undo when the figure declines: the bus is a routing pass and
@@ -5045,6 +6324,7 @@ function renderScene(doc,y0){
         dots:i===g.cand.length-1?g.dots:null, arrow:i===g.cand.length-1}));
   }
   for(const e of edges){
+    arrowOwner=e;
     const A=byId[e.a], B=byId[e.b]; if(!A||!B) continue;
     // an edge is pure stroke: `stroke=` and `fill=` name the same channel
     // (stroke= wins), `text=` colours the [tail]/[mid]/[head] labels.
@@ -5062,31 +6342,99 @@ function renderScene(doc,y0){
     const wantsStart=e.op==='<->'||e.op==='<-', wantsEnd=e.op==='<->'||e.op==='->';
     const m1='', m2='';   // markers removed — arrowTri() paints triangles above nodes in lblsvg
     const halo=' paint-order="stroke" stroke="#fff" stroke-width="3"';
-    const seg=(p,q,t,lbl,fs)=>reqLabel({p,q,t0:t,text:lbl,fs,col:ecol,halo,e,A,B,kind:'end'});
+    // ENDPOINT LABELS ANCHOR BY DISTANCE, NOT BY FRACTION (R? 0.4,
+    // engine-backlog item 42). A `[tail]`/`[head]` label exists to say WHICH
+    // END is called that; a placement at a FRACTION of the run says it only
+    // when the run is long. On `patterns/topology-a`'s 70 px edge both `p1`s
+    // landed mid-span, 23 px apart at the same y — two identical strings that
+    // named neither end. So the request no longer carries a preferred
+    // PARAMETER: it carries its OWN endpoint (`p`), the inward direction
+    // (`q`), the OTHER end of the whole edge (`other`) and the edge's total
+    // run (`tot`). The placement pass turns those into a fixed distance,
+    // clamped to half the edge, and refuses any candidate whose box centre is
+    // not strictly nearer its own endpoint than the other one.
+    const runLen=pp=>{let s=0;for(let i=0;i+1<pp.length;i++)s+=Math.hypot(pp[i+1][0]-pp[i][0],pp[i+1][1]-pp[i][1]);return s;};
+    // ── PORT MARKERS ARE THE TOPOLOGY CONVENTION (item 57) ────────────────
+    // On a network diagram the interface name is written INSIDE the device
+    // box, at the point the link crosses its border. That is not decoration:
+    // it is what makes the name unambiguous, because a port belongs to a
+    // DEVICE and the box is the device. `patterns/topology-a` is the case —
+    // six links, twelve `p*` labels, every one of them floating in the seam
+    // between two tiers where the reader has to decide by eye which box each
+    // belongs to, and Access Node 1's two are the pair that cannot be
+    // decided at all.
+    //
+    // So in the `topology` genre an endpoint label carries its OWN NODE, and
+    // the placement pass below anchors it at the BORDER CROSSING, just inside
+    // the box, instead of 16 px out along the shaft. Everything else about
+    // the request is unchanged — same kind, same font, same collision
+    // scoring, same `other`-end affinity filter — so the batch-2 machinery
+    // does the work and only the candidate family is new.
+    //
+    // The owner is read from the GEOMETRY rather than passed in: `p` is the
+    // point on a border and the owner is the box that border belongs to.
+    // Every `seg()` call passes the tail end with A's border point and the
+    // head end with B's, so this is the same answer with no call site to
+    // keep in step.
+    const portOwner=p=>{
+      if(doc.genre!=='topology'||!A||!B||A.boundary||B.boundary) return null;
+      const d=(N)=>Math.hypot(Math.max(N.x-p[0],0,p[0]-(N.x+N.w)),
+                              Math.max(N.y-p[1],0,p[1]-(N.y+N.h)));
+      return A===B ? A : (d(A)<=d(B)?A:B);
+    };
+    const seg=(p,q,lbl,fs,other,tot)=>reqLabel({p,q,text:lbl,fs,col:ecol,halo,e,A,B,kind:'end',
+                                                other,tot,port:portOwner(p)});
     const bus=busRoute.get(e);
     if(bus){
       const pts=bus.pts;
       // data-bus is written LAST so every reader that keys on the
       // `d=… fill=none stroke=… stroke-width=1.6` prefix is unaffected.
-      esvg.push('<path data-edge="'+e.line+'" d="'+roundPath(pts)+'" fill="none" stroke="'+col+'" stroke-width="1.6"'+dash+' data-bus="'+esc(bus.bus)+'"/>');
+      // ONE TRUNK, ONE DASH (item 60). The shared trunk is stroked once per
+      // member — that is the convention `data-bus` records — and each member's
+      // dash pattern starts at ITS OWN path start, so three members whose legs
+      // are different lengths lay three differently-phased dash patterns over
+      // the same trunk and the gaps fill in: `bfd-session`'s admin trunk drew
+      // SOLID purple under a legend that says the class is dashed, which is
+      // the drawing contradicting the key. Every member's path ENDS at the
+      // same point (the target's border), so aligning the phase there aligns
+      // it along the whole shared run: the offset is whatever brings the
+      // pattern to a period boundary at the path's end.
+      const per=e.style==='dashed'?10:(e.style==='dotted'?6:0);
+      const doff=per?' stroke-dashoffset="'+(((per-(runLen(pts)%per))%per).toFixed(2))+'"':'';
+      esvg.push('<path data-edge="'+e.line+'" d="'+roundPath(pts)+'" fill="none" stroke="'+col+'" stroke-width="1.6"'+dash+doff+' data-bus="'+esc(bus.bus)+'"/>');
       noteSegs(e,pts);
       for(const p of pts){ W=Math.max(W,p[0]+4); Hh=Math.max(Hh,p[1]+4-y0-20); }
       if(bus.dots) for(const d of bus.dots)
         lblsvg.push('<circle cx="'+d[0]+'" cy="'+d[1]+'" r="3" fill="'+col+'" stroke="none"/>');
-      // the trunk is drawn once by every member; the label and the arrowhead
-      // are drawn ONCE for the bus, which is the whole point of merging it.
-      if(bus.lead&&e.mid){          // longest rail run carries the one label
-        let bi=0,bl=-1;
-        for(let i=0;i+1<pts.length;i++){
-          const l=Math.hypot(pts[i+1][0]-pts[i][0],pts[i+1][1]-pts[i][1]);
-          if(l>bl){ bl=l; bi=i; }
-        }
-        reqLabel({p:pts[bi],q:pts[bi+1],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:bi===0});
-      }
+      // ── A MERGE-BUS LABELS AT EACH MEMBER'S OWN BLOCK EDGE (item 54) ───
+      // A merged bus used to carry ONE label, on the shared trunk, because
+      // that is what "they all say the same thing" seemed to mean. It reads
+      // wrong. The trunk is the part of the drawing that belongs to no
+      // member, and a word out there names the RAIL; what a reader wants to
+      // know at each exit is what LEAVING THIS BLOCK means, and the place
+      // they look for it is the connection point.
+      //
+      // So the text moves to the LEG and the trunk carries none: every
+      // member with a label registers it as an ENDPOINT-kind request on its
+      // own first segment, which anchors it 16 px from the source border —
+      // the same distance and the same machinery a port label uses. On
+      // `patterns/state-b` that is four small `reset` texts at the four
+      // exits and one unlabelled trunk.
+      //
+      // THE REPETITION IS THE POINT, NOT A DEFECT. The admission rule for a
+      // bus is that every member says the SAME thing (one label, one stroke,
+      // one dash), so per-leg labelling necessarily repeats that one word
+      // once per exit. That is the direction: the merge is about the INK of
+      // the route, not about suppressing the statement at each origin.
+      // the trunk is drawn once by every member; the arrowhead is drawn ONCE
+      // for the bus, which is the whole point of merging its ink.
+      if(e.mid)
+        reqLabel({p:pts[0],q:pts[1],text:e.mid,fs:11,col:lcol,halo,e,A,B,
+                  kind:'end',other:pts[pts.length-1],tot:runLen(pts)});
       if(bus.arrow&&wantsEnd) arrowTri(pts[pts.length-1],pts[pts.length-2],col);
       continue;
     }
-    if(isBack.has(e)&&!pinned(e.a)&&!pinned(e.b)){
+    if(chBack(e)&&!pinned(e.a)&&!pinned(e.b)){
       // ── ROUTING-CHANGE ARCHITECTURE NOTE (`SELF-EDGE-DRAWING`/`EDGE-BEND-RETENTION`) ──────────
       // Edge labels are DEFERRED: every label is registered against its
       // FINAL segment geometry (reqLabel/lblReq above) and placed by ONE
@@ -5154,8 +6502,8 @@ function renderScene(doc,y0){
         // is a placement a reader still reads as belonging to the loop.
         if(e.mid) reqLabel({p:sp[1],q:sp[2],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:false,
                             ts:[0.5,0.2,0.8,-0.7,1.7,-1.4,2.4],tw:10});
-        if(e.tail) seg(sp[0],sp[1],0.5,e.tail,10);
-        if(e.head) seg(sp[3],sp[2],0.5,e.head,10);
+        if(e.tail) seg(sp[0],sp[1],e.tail,10,sp[3],runLen(sp));
+        if(e.head) seg(sp[3],sp[2],e.head,10,sp[0],runLen(sp));
         if(wantsStart) arrowTri(sp[0],sp[1],col);
         if(wantsEnd)   arrowTri(sp[sp.length-1],sp[sp.length-2],col);
         continue;
@@ -5185,11 +6533,7 @@ function renderScene(doc,y0){
       // shorter than the label puts the box back on top of the source box
       // whatever parameter is chosen (bfd-session's "Detect expired, Echo
       // failed" is 169 px wide and a fixed 64 px stub buried it in INIT).
-      const srcStub=(pp,wpx)=>{
-        const a=pp[0], b=pp[1], L=Math.hypot(b[0]-a[0],b[1]-a[1])||1;
-        const k=Math.min(1,Math.max(64,wpx+24)/L);
-        return [a,[a[0]+(b[0]-a[0])*k, a[1]+(b[1]-a[1])*k]];
-      };
+      const srcStub=srcStubOf;
       if(horiz){             // channel runs below the lanes
         const chY=occB+28+P.slot;             // labels ride ON the channel
         const colR=r=>Math.max(...lane(r).map(n=>n.x+n.w));
@@ -5203,7 +6547,7 @@ function renderScene(doc,y0){
           const gx=colR(B.rank)+10+ring*7;
           pts.push([gx,chY],[gx,B.y+B.h*P.ef],[outSide(B,'r'),B.y+B.h*P.ef]);
         } else pts.push([tx,chY],[tx,outSide(B,'b')]);
-        if(e.mid){
+        if(e.mid&&!P.bus){
           const ss=srcStub(pts,lblPx(e.mid)), c1=pts.findIndex(p=>p[1]===chY);
           reqLabel({p:ss[0],q:ss[1],alt:[pts[c1],pts[c1+1]],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:false});
         }
@@ -5211,7 +6555,7 @@ function renderScene(doc,y0){
         const sx=A.x+A.w/2;
         const gy=occB+14+ring*12, chX=occR+28+P.slot, topY=chTop-14-ring*12;
         pts.push([sx,outSide(A,'b')],[sx,gy],[chX,gy],[chX,topY],[P.ex,topY],[P.ex,outSide(B,'t')]);
-        if(e.mid){
+        if(e.mid&&!P.bus){
           const ss=srcStub(pts,lblPx(e.mid)), c1=pts.findIndex(p=>p[0]===chX);
           reqLabel({p:ss[0],q:ss[1],alt:[pts[c1],pts[c1+1]],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:false});
         }
@@ -5228,18 +6572,45 @@ function renderScene(doc,y0){
           const gy=laneB(B.rank)+10+ring*7;
           pts.push([chX,gy],[B.x+B.w*P.ef,gy],[B.x+B.w*P.ef,outSide(B,'b')]);
         } else pts.push([chX,ty],[outSide(B,'r'),ty]);
-        if(e.mid){
+        if(e.mid&&!P.bus){
           const ss=srcStub(pts,lblPx(e.mid)), c1=pts.findIndex(p=>p[0]===chX);
           reqLabel({p:ss[0],q:ss[1],alt:[pts[c1],pts[c1+1]],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:false});
         }
       }
+      // A return-bus member's own leg is pts[0]->pts[1] on every form the plan
+      // builds above; pts[1] is therefore where it joins the shared trunk. It is
+      // recorded HERE, before the detour pass can splice points in front of it.
+      if(P.bus&&pts.length>1){
+        if(!busJoins.has(P.bus)) busJoins.set(P.bus,[]);
+        busJoins.get(P.bus).push(pts[1]);
+      }
       // non-incident nodes are obstacles for the channel runs too: a run
       // that would cut through a sibling (e.g. a pinned node parked on the
       // escape lane) detours around it instead of drawing across it. When
       // spanning the following corner point gives a shorter total run than
       // detour + remaining leg (a detour "spike"), the corner is dropped.
-      const obsN=nodes.filter(n=>n!==A&&n!==B&&!n.boundary).map(n=>({x:n.x,y:n.y,w:n.w,h:n.h}));
+      const obsN=nodes.filter(n=>n!==A&&n!==B&&!n.boundary).map(n=>({x:n.x,y:n.y,w:n.w,h:n.h}))
+        .concat(lblObs(e));
       const plen=pp=>{let s=0;for(let k=0;k+1<pp.length;k++)s+=Math.hypot(pp[k+1][0]-pp[k][0],pp[k+1][1]-pp[k][1]);return s;};
+      // A SHORTCUT THAT BUYS A CROSSING IS NOT A SHORTCUT (item 45a). The
+      // spike-prune below trades a planned channel corner for a straight span
+      // whenever the span is shorter. It measures LENGTH and nothing else, so
+      // on `showcase/arp-resolution` — where the element-label obstacle above
+      // is what first pushed the shaft off the label — it happily replaced the
+      // orthogonal channel corner with a long diagonal straight across the
+      // broadcast arrow. Ink went down, the reader's job got harder. The prune
+      // therefore also asks whether the span crosses a line already on the
+      // canvas; `edgeSegs` holds exactly those, in draw order.
+      const xseg=(a1,a2,b1,b2)=>{
+        const d=(p1,p2,p3)=>(p2[0]-p1[0])*(p3[1]-p1[1])-(p2[1]-p1[1])*(p3[0]-p1[0]);
+        const d1=d(a1,a2,b1), d2=d(a1,a2,b2), d3=d(b1,b2,a1), d4=d(b1,b2,a2);
+        return ((d1>0)!==(d2>0))&&((d3>0)!==(d4>0));
+      };
+      const spanCuts=pp=>{
+        for(let k=0;k+1<pp.length;k++)
+          for(const g of edgeSegs) if(g.e!==e&&xseg(pp[k],pp[k+1],g.p,g.q)) return true;
+        return false;
+      };
       for(let i=0;i+1<pts.length;i++){
         const d=routeAround(pts[i],pts[i+1],obsN);
         if(!d) continue;
@@ -5247,7 +6618,7 @@ function renderScene(doc,y0){
         if(i+2<pts.length){
           const span=segHitsObs(pts[i],pts[i+2],obsN)
             ?routeAround(pts[i],pts[i+2],obsN):[pts[i],pts[i+2]];
-          if(span&&plen(span)<plen(d)+Math.hypot(pts[i+2][0]-pts[i+1][0],pts[i+2][1]-pts[i+1][1])-1e-6){
+          if(span&&!spanCuts(span)&&plen(span)<plen(d)+Math.hypot(pts[i+2][0]-pts[i+1][0],pts[i+2][1]-pts[i+1][1])-1e-6){
             ins=span.slice(1,-1); drop=1;
           }
         }
@@ -5255,12 +6626,89 @@ function renderScene(doc,y0){
         i+=ins.length;
       }
       for(const p of pts){ W=Math.max(W,p[0]+4); Hh=Math.max(Hh,p[1]+16-y0-20); }
-      esvg.push('<path data-edge="'+e.line+'" d="'+roundPath(pts)+'" fill="none" stroke="'+col+'" stroke-width="1.6"'+dash+'/>');
+      // RETURN BUS (item 46): the collapsed members draw the same trunk, so the
+      // path carries `data-bus` for exactly the reason the forward bus does —
+      // it is what lets a reader (and `layout-lint`'s coincident term) tell a
+      // deliberate shared trunk from two lines hidden under each other. Written
+      // LAST, after stroke-width, so no existing reader breaks.
+      esvg.push('<path data-edge="'+e.line+'" d="'+roundPath(pts)+'" fill="none" stroke="'+col+'" stroke-width="1.6"'+dash
+        +(P.bus?' data-bus="'+esc(P.bus)+'"':'')+'/>');
       noteSegs(e,pts);
-      if(e.tail) seg(pts[0],pts[1],0.5,e.tail,10);
-      if(e.head) seg(pts[pts.length-1],pts[pts.length-2],0.5,e.head,10);
-      if(wantsStart) arrowTri(pts[0],pts[1],col);
-      if(wantsEnd)   arrowTri(pts[pts.length-1],pts[pts.length-2],col);
+      if(P.busTail){
+        // JUNCTION DOTS. Every member's OWN leg ends where the shared run
+        // begins — pts[1] on every route form the channel plan builds (the drop
+        // to the rail, the reach out to the trunk) — so the joins are collected
+        // as the members draw and the last one dots them. The join FARTHEST
+        // from the arrival is the rail's own end: a corner, not a junction, and
+        // the forward bus does not dot its corners either.
+        const jx=(busJoins.get(P.bus)||[]).slice(), tip=pts[pts.length-1];
+        if(jx.length>1){
+          let far=0;
+          for(let i2=1;i2<jx.length;i2++)
+            if(Math.hypot(jx[i2][0]-tip[0],jx[i2][1]-tip[1])>Math.hypot(jx[far][0]-tip[0],jx[far][1]-tip[1])) far=i2;
+          jx.splice(far,1);
+        }
+        for(const d of jx)
+          lblsvg.push('<circle cx="'+d[0]+'" cy="'+d[1]+'" r="3" fill="'+col+'" stroke="none"/>');
+      }
+      // ITEM 54: the label rides the member's OWN leg, at its origin block's
+      // edge, and the shared trunk carries none. See the forward bus above
+      // for why — the trunk belongs to no member, and the connection point
+      // is where a branch's meaning is read.
+      if(e.mid&&P.bus)
+        reqLabel({p:pts[0],q:pts[1],text:e.mid,fs:11,col:lcol,halo,e,A,B,
+                  kind:'end',other:pts[pts.length-1],tot:runLen(pts)});
+      if(e.tail) seg(pts[0],pts[1],e.tail,10,pts[pts.length-1],runLen(pts));
+      if(e.head) seg(pts[pts.length-1],pts[pts.length-2],e.head,10,pts[0],runLen(pts));
+      if(wantsStart&&(!P.bus||P.busTail)) arrowTri(pts[0],pts[1],col);
+      if(wantsEnd&&(!P.bus||P.busTail))   arrowTri(pts[pts.length-1],pts[pts.length-2],col);
+      continue;
+    }
+    // ── corridor route (items 41/46): side chosen by occupancy, lane by
+    //    distance from the shared target. Same detour and label discipline as
+    //    the channel routes — a corridor is a channel the figure chose.
+    const lrPts=longRoute(e);
+    if(lrPts){
+      for(const p of lrPts){ W=Math.max(W,p[0]+4); Hh=Math.max(Hh,p[1]+16-y0-20); }
+      esvg.push('<path data-edge="'+e.line+'" d="'+roundPath(lrPts)+'" fill="none" stroke="'+col+'" stroke-width="1.6"'+dash+'/>');
+      noteSegs(e,lrPts);
+      if(e.mid){
+        // WHICH LEG CARRIES THE LABEL, and it is the OPPOSITE of the channel
+        // router's answer. A channel run is the figure's outermost lane, so a
+        // label out there says nothing about which line it names and the stub
+        // wins. A CORRIDOR was chosen precisely because that margin is free —
+        // that is the whole selection rule — so its long run is the clear ink
+        // and the stub is the squeezed end, wedged between a source and the
+        // figure's edge. Measured on dhcp-client: stub-first put
+        // "server refuses / NAK -> drop IP" into the RENEWING/REBINDING corner
+        // and took `lblcol` 2 -> 5; run-first leaves it on the open margin. The
+        // stub stays as the ALTERNATE, so a corridor whose run is busy can
+        // still fall back to it.
+        const ss=srcStubOf(lrPts,lblPx(e.mid));
+        let bi=0,bl=-1;
+        for(let i=0;i+1<lrPts.length;i++){
+          const dxx=lrPts[i+1][0]-lrPts[i][0], dyy=lrPts[i+1][1]-lrPts[i][1];
+          if(Math.abs(dxx)>0.5&&Math.abs(dyy)>0.5) continue;   // axis-aligned runs only
+          const l=Math.hypot(dxx,dyy);
+          if(l>bl){ bl=l; bi=i; }
+        }
+        // ...WITH ONE EXCEPTION, AND IT IS THE FLOWCHART CONVENTION (`FLOWCHART-ROLE-KEYWORDS`).
+        // A short branch marker leaving a decision — `yes`, `no` — names that
+        // BRANCH, and it reads as the branch's name only next to the decision.
+        // The placement pass already knows this (its `branch` test), and it is
+        // reachable only from the FIRST segment, so a corridor whose label is a
+        // branch marker hands the stub back the primary carrier: flowchart-b's
+        // left-margin `no` otherwise sat halfway down the figure, level with the
+        // OTHER `no`, naming neither.
+        const branch=A.role==='decision'&&String(e.mid).length<=3&&!String(e.mid).includes('\n');
+        if(bl<0||branch) reqLabel({p:ss[0],q:ss[1],alt:bl<0?null:[lrPts[bi],lrPts[bi+1]],
+          text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:true});
+        else reqLabel({p:lrPts[bi],q:lrPts[bi+1],alt:[ss[0],ss[1]],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:false});
+      }
+      if(e.tail) seg(lrPts[0],lrPts[1],e.tail,10,lrPts[lrPts.length-1],runLen(lrPts));
+      if(e.head) seg(lrPts[lrPts.length-1],lrPts[lrPts.length-2],e.head,10,lrPts[0],runLen(lrPts));
+      if(wantsStart) arrowTri(lrPts[0],lrPts[1],col);
+      if(wantsEnd)   arrowTri(lrPts[lrPts.length-1],lrPts[lrPts.length-2],col);
       continue;
     }
     const chain=chains.get(e);
@@ -5354,8 +6802,8 @@ function renderScene(doc,y0){
       esvg.push('<path data-edge="'+e.line+'" d="'+roundPath(pts)+'" fill="none" stroke="'+col+'" stroke-width="1.6"'+dash+'/>');
       noteSegs(e,pts);
       if(midSeg) reqLabel({p:midSeg[0],q:midSeg[1],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:false});
-      if(e.tail) seg(p0,pts[1],0.4,e.tail,10);
-      if(e.head) seg(p1,pts[pts.length-2],0.4,e.head,10);
+      if(e.tail) seg(p0,pts[1],e.tail,10,p1,runLen(pts));
+      if(e.head) seg(p1,pts[pts.length-2],e.head,10,p0,runLen(pts));
       if(wantsStart) arrowTri(pts[0],pts[1],col);
       if(wantsEnd)   arrowTri(pts[pts.length-1],pts[pts.length-2],col);
       continue;
@@ -5370,7 +6818,8 @@ function renderScene(doc,y0){
     // (routeAround). Obstacle-free edges keep the plain line unchanged.
     let route=null;
     if(A!==B){
-      const obs=nodes.filter(n=>n!==A&&n!==B&&!n.boundary).map(n=>({x:n.x,y:n.y,w:n.w,h:n.h}));
+      const obs=nodes.filter(n=>n!==A&&n!==B&&!n.boundary).map(n=>({x:n.x,y:n.y,w:n.w,h:n.h}))
+        .concat(lblObs(e));
       for(const k in gBox){
         const b=gBox[k];
         const inG=(px,py)=>px>b.x0&&px<b.x1&&py>b.yA&&py<b.yB;
@@ -5394,8 +6843,8 @@ function renderScene(doc,y0){
         }
         reqLabel({p:route[bi],q:route[bi+1],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:bi===0});
       }
-      if(e.tail) seg(route[0],route[1],0.25,e.tail,10);
-      if(e.head) seg(route[route.length-1],route[route.length-2],0.25,e.head,10);
+      if(e.tail) seg(route[0],route[1],e.tail,10,route[route.length-1],runLen(route));
+      if(e.head) seg(route[route.length-1],route[route.length-2],e.head,10,route[0],runLen(route));
       if(wantsStart) arrowTri(route[0],route[1],col);
       if(wantsEnd)   arrowTri(route[route.length-1],route[route.length-2],col);
       for(const pP of route){ W=Math.max(W,pP[0]+4); Hh=Math.max(Hh,pP[1]+4-y0-20); }
@@ -5406,8 +6855,8 @@ function renderScene(doc,y0){
     if(e.mid)
       reqLabel({p:[x1,yy1],q:[x2,yy2],text:e.mid,fs:11,col:lcol,halo,e,A,B,kind:'mid',first:true});
     // endpoint labels at the tail/head positions (three-position model, `EDGE-LABEL-PLACEMENT`)
-    if(e.tail) seg([x1,yy1],[x2,yy2],0.18,e.tail,10);
-    if(e.head) seg([x1,yy1],[x2,yy2],0.82,e.head,10);
+    if(e.tail) seg([x1,yy1],[x2,yy2],e.tail,10,[x2,yy2],runLen([[x1,yy1],[x2,yy2]]));
+    if(e.head) seg([x2,yy2],[x1,yy1],e.head,10,[x1,yy1],runLen([[x1,yy1],[x2,yy2]]));
     if(wantsStart) arrowTri([x1,yy1],[x2,yy2],col);
     if(wantsEnd)   arrowTri([x2,yy2],[x1,yy1],col);
   }
@@ -5442,6 +6891,9 @@ function renderScene(doc,y0){
       else { ox=cx-bw/2; oy=(bdy>=0?cy+17:cy-10)-13*bl/2-1.5; }
       obst.push({x:ox,y:oy,w:bw,h:bh,n:null});
     }
+    // gap between two boxes, 0 when they touch or overlap (item 43's tie-break)
+    const boxGap=(a,b)=>Math.hypot(Math.max(0,Math.max(a.x-(b.x+b.w), b.x-(a.x+a.w))),
+                                   Math.max(0,Math.max(a.y-(b.y+b.h), b.y-(a.y+a.h))));
     const ovl=(a,b)=>{
       const ix=Math.min(a.x+a.w,b.x+b.w)-Math.max(a.x,b.x);
       const iy=Math.min(a.y+a.h,b.y+b.h)-Math.max(a.y,b.y);
@@ -5461,7 +6913,56 @@ function renderScene(doc,y0){
       }
       return t1>t0;
     };
+    // distance from a segment to a label box, measured to the box CENTRE —
+    // the same point F5 measures from, so the scorer and the gate agree.
+    const segBoxD=(p,q,b)=>{
+      const cx=b.x+b.w/2, cy=b.y+b.h/2;
+      const vx=q[0]-p[0], vy=q[1]-p[1], L2=vx*vx+vy*vy;
+      const t=L2?Math.max(0,Math.min(1,((cx-p[0])*vx+(cy-p[1])*vy)/L2)):0;
+      return Math.hypot(cx-(p[0]+t*vx), cy-(p[1]+t*vy));
+    };
+    // STANDOFF (item 59): the shortest distance from a carrying segment to the
+    // label's own box — 0 when the line enters it. This is the distance a
+    // reader crosses to get from the word to the line, and it is the quantity
+    // the cap below is written in. It is NOT `segBoxD`, which measures to the
+    // box CENTRE: a 117 px label beside a near-vertical shaft has its centre
+    // 57 px away and its nearest edge 6 px away, and only the second number
+    // says whether the two touch on the page.
+    const segBoxGap=(p,q,b)=>{
+      if(segHit(p,q,b)) return 0;
+      const ptRect=(x,y)=>Math.hypot(Math.max(b.x-x,0,x-(b.x+b.w)),
+                                     Math.max(b.y-y,0,y-(b.y+b.h)));
+      const segPt=(x,y)=>{
+        const vx=q[0]-p[0], vy=q[1]-p[1], L2=vx*vx+vy*vy;
+        const t=L2?Math.max(0,Math.min(1,((x-p[0])*vx+(y-p[1])*vy)/L2)):0;
+        return Math.hypot(x-(p[0]+t*vx), y-(p[1]+t*vy));
+      };
+      let d=Math.min(ptRect(p[0],p[1]), ptRect(q[0],q[1]));
+      for(const c of [[b.x,b.y],[b.x+b.w,b.y],[b.x,b.y+b.h],[b.x+b.w,b.y+b.h]])
+        d=Math.min(d,segPt(c[0],c[1]));
+      return d;
+    };
+    // THE CAP, AND WHERE THE NUMBER COMES FROM (item 59). Measured over the
+    // 137 mid-labels the corpus places: min 0.3 px, median
+    // 3.0, p75 5.3, p90 6.0, p95 6.0 — the base side offset is 6 px and nine
+    // labels in ten sit at it or inside it. Above that the DRAWN corpus uses
+    // 7.9, 11.0, 17.4 and 17.4 px (all four on `statechart/bfd-session`), and
+    // one figure reaches 32.6 — `layout-compare/srl-evpn-irb-auto`, which is
+    // refused at geometry time and never published.
+    //
+    // 18 px, and the corpus chose it. Caps of 8 and of 12 were both built and
+    // measured: each one pulls bfd's two 17.4 px labels ("rx Down" and
+    // "rx Init, rx Up") in to 6.0 px, where their own self-loop then draws
+    // through them — lblcol 2 -> 4 on that figure, in both runs. That relief
+    // is EARNED, so the cap has to sit above it; 18 is three times the base
+    // offset, just clear of the largest standoff the corpus can justify, and
+    // it still refuses a float half again as far. Past the cap a mid-label is
+    // not simply placed further out — it takes a LEADER (below), so the
+    // association is drawn rather than left to proximity.
+    const STANDOFF_CAP=18;
     const CLAMP=t=>Math.max(0.06,Math.min(0.94,t));
+    // Endpoint-label anchor distance (item 42). See the `kind==='end'` branch.
+    const END_D=16;
     // SLOPE CLEARANCE (`cl`): "3 px above the line" clears the line only where
     // the box touches it. The offsets are axis-aligned while the segment is
     // not, so on a diagonal the line keeps climbing across the box's WIDTH and
@@ -5473,27 +6974,111 @@ function renderScene(doc,y0){
     // below: a label 7 px further out to stop being struck is worth it, a
     // 90 px shove for a long label on a 45 degree line is not, and the scorer
     // decides which case it is holding.
-    const cand=(r,t,side,cl)=>{
+    const cand=(r,t,side,cl,ep)=>{
       const lines=String(r.text).split('\n'), n=lines.length;
       const w=Math.max(...lines.map(cw))*6.5*r.fs/11;
       const lh=r.fs*1.3, h=(n-1)*lh+r.fs*1.1;
       const up=(n-1)*lh/2+r.fs*0.85;          // baseline y = box top + up
       const mx=r.p[0]+(r.q[0]-r.p[0])*t, my=r.p[1]+(r.q[1]-r.p[1])*t;
       const sdx=Math.abs(r.q[0]-r.p[0]), sdy=Math.abs(r.q[1]-r.p[1]);
-      let ex=0;
+      let ex=ep||0;   // extra perpendicular push (endpoint labels' escape)
       if(cl){
-        if(side==='above'||side==='below') ex=sdx>1e-9?Math.min(1,sdy/sdx)*w/2:0;
-        else if(side==='right'||side==='left') ex=sdy>1e-9?Math.min(1,sdx/sdy)*h/2:0;
+        if(side==='above'||side==='below') ex+=sdx>1e-9?Math.min(1,sdy/sdx)*w/2:0;
+        else if(side==='right'||side==='left') ex+=sdy>1e-9?Math.min(1,sdx/sdy)*h/2:0;
       }
+      // FLUSH THE INK AGAINST THE SHAFT (item 59). `w` is an ESTIMATE — 6.5 px
+      // per character at font-size 11 — and it runs about a sixth wide of what
+      // the browser actually sets. That slack has to go somewhere, and until
+      // this release it went on whichever side the anchor left it: a `left`
+      // label was anchored `start` at the box's LEFT edge, so every pixel of
+      // over-estimate opened up between the last glyph and the line the label
+      // names. Measured on `showcase/tcp-state-machine`: both
+      // "CLOSE / delete TCB" boxes hug their purple shaft at the placement's
+      // own 6 px, and the TEXT stops 23 px short of it — which is the distance
+      // the maintainer's review calls a drift the tone pairing cannot rescue.
+      // A side label is therefore anchored on the edge that FACES its shaft:
+      // `end` on the left, `start` on the right, so the ragged edge falls away
+      // from the line and the estimate's slack can never be read as standoff.
+      // The BOX is unchanged, so nothing in the collision scoring moves.
       let bx,by,x,anchor=n>1?'middle':'start';
       if(side==='on')          { bx=mx-w/2; by=my-4-up;  anchor='middle'; }
       else if(side==='above')  { bx=mx-w/2; by=my-3-h-ex; anchor='middle'; }
       else if(side==='below')  { bx=mx-w/2; by=my+3+ex;  anchor='middle'; }
-      else if(side==='right')  { bx=mx+6+ex; by=my-h/2; }
-      else                     { bx=mx-6-w-ex; by=my-h/2; }
-      x=anchor==='middle'?bx+w/2:bx;
+      else if(side==='right')  { bx=mx+6+ex; by=my-h/2; anchor='start'; }
+      else                     { bx=mx-6-w-ex; by=my-h/2; anchor='end'; }
+      x=anchor==='middle'?bx+w/2:anchor==='end'?bx+w:bx;
       return {x,y:by+up,anchor,t,side,ex,box:{x:bx,y:by,w,h}};
     };
+    // ── PORT-MARKER CANDIDATES (item 57) ──────────────────────────────────
+    // The 16 px own-port anchor of item 42 becomes a BORDER-CROSSING anchor:
+    // the box sits just inside the node, on the side the link crosses, with
+    // its along-border position free so two ports on one border spread
+    // instead of stacking. `PORT_IN` is the gap from the border line to the
+    // marker (enough that the box does not sit ON the stroke); `PORT_END` is
+    // how near a corner a marker may be written; the offsets are one marker
+    // width apart, which is exactly the pitch two ports need to be two.
+    const PORT_IN=2, PORT_END=4, PORT_HUG=25, PORT_OUT=60;
+    // The node's own drawn label, computed by the SAME formulas the node pass
+    // emits it with (shrink-to-fit included), so the obstacle and the drawing
+    // cannot disagree about where a name is.
+    const nodeInk=n=>{
+      if(!n||!n.label) return null;
+      const nl=String(n.label).split('\n');
+      const need=Math.max(...nl.map(cw))*CH;
+      const avail=2*inscribedHalfW(shapeAxes(n),nl.length*8)-16;
+      const fs=(n.rigid&&need>avail)?Math.max(8,FONT*avail/need):FONT;
+      const lw=need*fs/FONT, lh=nl.length*fs*1.15;
+      return {x:n.x+n.w/2-lw/2, y:n.y+n.h/2-lh/2, w:lw, h:lh};
+    };
+    // A label's box is its LINE box: full leading above and below. Its INK is
+    // the glyph band inside that, and the two questions are different (see the
+    // own-name term in the scorer).
+    const inkBox=(b,fs)=>({x:b.x, y:b.y+fs*0.14, w:b.w, h:Math.max(1,b.h-fs*0.28)});
+    const portCands=r=>{
+      const N=r.port, P=r.p, out=[];
+      if(!N) return out;
+      const lines=String(r.text).split('\n'), nL=lines.length;
+      const w=Math.max(...lines.map(cw))*6.5*r.fs/11;
+      const lh=r.fs*1.3, h=(nL-1)*lh+r.fs*1.1, up=(nL-1)*lh/2+r.fs*0.85;
+      // Which border did the link cross? The nearest side of the box.
+      const dl=Math.abs(P[0]-N.x), dr=Math.abs(P[0]-(N.x+N.w)),
+            dt=Math.abs(P[1]-N.y), db=Math.abs(P[1]-(N.y+N.h));
+      const m=Math.min(dl,dr,dt,db);
+      const side=m===dt?'top':m===db?'bottom':m===dl?'left':'right';
+      const vert=(side==='top'||side==='bottom');
+      // ROOM. A marker that cannot be written between the two corners of the
+      // side it crosses has no inside form at all; the ordinary outside
+      // family is then the only one offered, which is the stated fallback.
+      const span=vert?N.w:N.h, need=(vert?w:h)+2*PORT_END;
+      if(span<need) return out;
+      const lo=(vert?N.x:N.y)+PORT_END, hi=(vert?N.x+N.w:N.y+N.h)-PORT_END;
+      const pitch=(vert?w:h)+4;
+      const u0=vert?P[0]:P[1];
+      // TWO RINGS OF CANDIDATES, AND BOTH ARE AT THE CROSSING.
+      //   in = inside the border, the convention proper;
+      //   out = the mirror image, just OUTSIDE the same border.
+      // The second exists because a small box genuinely runs out of room —
+      // `reference/topology`'s L1 is 42 x 36 and holds one port name, not two
+      // — and the alternative fallback (the ordinary 16 px-along-the-shaft
+      // family) puts the second name out in the seam BETWEEN the two shafts
+      // arriving at that box, which measured F5 margin 0.47 px: a label that
+      // has stopped saying which of two lines it names. Hugging the border it
+      // could not get inside keeps it on its own port, which is the fact it
+      // exists to state. It is surcharged, so it is taken only after inside
+      // has failed.
+      for(const inside of [true,false]) for(const k of [0,1,-1,2,-2]){
+        const u=Math.max(lo+(vert?w:h)/2, Math.min(hi-(vert?w:h)/2, u0+k*pitch));
+        let bx,by;
+        if(side==='bottom'){ bx=u-w/2; by=inside?N.y+N.h-PORT_IN-h:N.y+N.h+PORT_IN; }
+        else if(side==='top'){ bx=u-w/2; by=inside?N.y+PORT_IN:N.y-PORT_IN-h; }
+        else if(side==='left'){ bx=inside?N.x+PORT_IN:N.x-PORT_IN-w; by=u-h/2; }
+        else { bx=inside?N.x+N.w-PORT_IN-w:N.x+N.w+PORT_IN; by=u-h/2; }
+        out.push({x:bx+w/2, y:by+up, anchor:'middle', t:undefined, side,
+                  ex:Math.abs(k)*pitch, inPort:inside, hug:!inside,
+                  box:{x:bx,y:by,w,h}});
+      }
+      return out;
+    };
     const placed=[];
     // A request may name a SECOND carrying segment (`alt`). Back edges do: the
     // stub leaving the source is the preferred carrier because it says which
@@ -5504,17 +7089,36 @@ function renderScene(doc,y0){
     // flat surcharge so it is taken only when the stub really has nowhere.
     if(lblReq.length) for(const r0 of lblReq){
     const carriers=[[r0.p,r0.q]].concat(r0.alt?[r0.alt]:[]);
-    let best=null,bestS=Infinity;
+    let best=null,bestS=Infinity, anyBest=null,anyS=Infinity, offBest=null,offS=Infinity,
+        farBest=null,farS=Infinity;
     for(let ci=0;ci<carriers.length;ci++){
       const r=ci?Object.assign({},r0,{p:carriers[ci][0],q:carriers[ci][1]}):r0;
       const dx=r.q[0]-r.p[0], dy=r.q[1]-r.p[1];
       const across=Math.abs(dx)>=Math.abs(dy);
-      let sides, ts, tPref, apWant=null;
+      let sides, ts, tPref, apWant=null, tScale=r.tw||70;
       if(r.kind==='end'){
-        // endpoint labels keep their historical spot as first choice
+        // DISTANCE, NOT FRACTION (item 42). `END_D` is 16 px, chosen from the
+        // instrument rather than from taste: F5's own filter (2) treats a
+        // label within 18 px of a node border as one the reader ties to the
+        // NODE and not to an edge-edge ambiguity, and that is precisely the
+        // reading a port label wants. Anchoring at 16 px puts every endpoint
+        // label inside that reading on every edge long enough to hold it.
+        // The clamp is half the edge's whole run AND half the carrying
+        // segment: a label may never reach the middle of the thing it slides
+        // along, because the middle names no end. Below the clamp the label
+        // sits as near its port as the geometry allows.
+        const Lseg=Math.hypot(dx,dy)||1;
+        const cap=Math.min(0.5*(r.tot||Lseg), 0.5*Lseg);
+        const d0=Math.min(END_D,cap);
+        // The push set is in PIXELS along the edge, outward-biased: a label
+        // driven off its anchor by a collision walks INTO the span (it can
+        // never walk off the end), and it stops at the clamp.
+        const dset=[0,5,-4,10,-8,16,24].map(k=>d0+k).filter(d=>d>=2&&d<=cap+1e-9);
+        if(!dset.length) dset.push(Math.max(1,cap));
+        tPref=d0/Lseg;
+        ts=dset.map(d=>d/Lseg);
+        tScale=1.2*Lseg;   // the pull back to the anchor is priced in PIXELS
         sides=['on'].concat(across?['above','below']:['right','left']);
-        tPref=r.t0;
-        ts=[r.t0,r.t0-0.06,r.t0+0.06,r.t0-0.12,r.t0+0.12].map(CLAMP);
       } else {
         sides=across?['above','below']:['right','left'];
         // ANTI-PARALLEL PAIRS: the label belongs on the OUTSIDE of its own
@@ -5553,17 +7157,86 @@ function renderScene(doc,y0){
         tPref=branch?0.22:0.5;
         ts=r.ts?r.ts:(branch?[0.22,0.3,0.16,0.4,0.5,0.62]:[0.5,0.38,0.62,0.28,0.72]);
       }
-      for(let si=0;si<sides.length;si++) for(const t of ts) for(const cl of [0,1]){
-        const c=cand(r,t,sides[si],cl);
+      // The perpendicular escape (item 42). When every in-line position is
+      // blocked, an endpoint label must still be able to say which end it
+      // names, and the only remaining freedom is ACROSS the line. 9 px is one
+      // text line-height: enough to clear a co-located neighbour, priced per
+      // pixel below like every other displacement, so it is taken only when
+      // the in-line positions really have nowhere.
+      const eps=r.kind==='end'?[0,9]:[0];
+      // ── THE CANDIDATE FAMILY ──────────────────────────────────────────
+      // Normally: sides x parameters x slope-clearance x escape, as above.
+      // A PORT MARKER (item 57) adds a family in FRONT of it — positions
+      // just inside its own node's border at the crossing — and keeps the
+      // ordinary family behind, surcharged. That is the fallback the
+      // direction asks for, and it is a PRICE rather than a test, so a
+      // marker is pushed back outside exactly when inside is genuinely
+      // blocked (a box too narrow to hold the text, or the node's own name
+      // already there) and never merely because outside happens to be tidy.
+      const cs=[];
+      if(r.port) for(const c of portCands(r)) cs.push({c,si:0});
+      for(let si=0;si<sides.length;si++) for(const t of ts) for(const cl of [0,1]) for(const ep of eps)
+        cs.push({c:cand(r,t,sides[si],cl,ep),si,out:!!r.port});
+      for(const CS of cs){
+        const c=CS.c, si=CS.si, t=(c.t===undefined?tPref:c.t);
+        c.car=[r.p,r.q];          // the carrier this candidate rides (item 59)
+        // ENDPOINT AFFINITY IS A HARD FILTER, NOT A PRICE. A tail label whose
+        // box centre is nearer the head than the tail has stopped stating the
+        // one fact it exists to state, and no amount of collision relief buys
+        // that back. Candidates that fail are dropped; `bestAny` keeps the
+        // least-bad one so a figure with no legal position still draws.
+        let owns=true;
+        if(r.kind==='end'&&r.other){
+          const ccx=c.box.x+c.box.w/2, ccy=c.box.y+c.box.h/2;
+          owns=Math.hypot(ccx-r.p[0],ccy-r.p[1])<Math.hypot(ccx-r.other[0],ccy-r.other[1]);
+        }
         let s=0;
         for(const b of placed)   s+=3*ovl(c.box,b);
-        for(const o of obst)     s+=(o.n===r.A||o.n===r.B?6:2.4)*ovl(c.box,o);
+        // A PORT MARKER IS SUPPOSED TO BE INSIDE ITS OWN BOX (item 57), so
+        // that one node is not charged for it. Every other box still is, at
+        // the usual weights — a marker that has slid out of its own device
+        // and into a neighbour is the defect this convention exists to end.
+        for(const o of obst){ if(c.inPort&&o.n===r.port) continue;
+                              s+=(o.n===r.A||o.n===r.B?6:2.4)*ovl(c.box,o); }
+        // ...but the node's own NAME is ink, and a port written across it is
+        // the same misreading `band` captions were fixed for (item 49).
+        //
+        // MEASURED INK TO INK, not line box to line box. Everywhere else in
+        // this pass a label is its generous LINE box, which is right when the
+        // question is "is there room to put this somewhere". Here the two
+        // boxes are already inside one 36 px node and the question is whether
+        // the GLYPHS touch: a 13 px name's line box is 15 px tall and its
+        // letters are about 9, so the line boxes overlap by a pixel or two in
+        // every ordinary topology node and the marker was priced out of a box
+        // it fits in perfectly well. `topology-a` measured 4 of 12 markers
+        // inside on line boxes and 12 of 12 on ink.
+        if(c.inPort){ const li=nodeInk(r.port);
+          if(li) s+=6*ovl(inkBox(c.box,r.fs), {x:li.x,y:li.y+li.h*0.09,w:li.w,h:li.h*0.82}); }
+        // the marker leaves its box only under duress, and leaves its PORT
+        // only after that (PORT_HUG < PORT_OUT)
+        s+=CS.out?PORT_OUT:(c.hug?PORT_HUG:0);
         for(const a of arrowBox) s+=4*ovl(c.box,a);
         // The label's OWN edge is charged like any other. It used to be exempt
         // (`g.e!==r.e`), which made a label lying across the line it names FREE
         // — and that is the single commonest way a label stops saying which
         // line it belongs to, so the exemption was paying for the defect.
         for(const g of edgeSegs) if(segHit(g.p,g.q,c.box)) s+=26;
+        // THE PERPENDICULAR STEP STAYS CHEAP, AND THAT IS A MEASURED RESULT
+        // (item 59). The direction was "relief slides along the shaft first,
+        // steps away only within a cap", and the obvious way to write the
+        // first half is to make the step dearer than the slide — the slide is
+        // priced in parameter units, `tScale`/L per pixel, which is 0.35/px on
+        // a 200 px run, exactly what the step costs. Tripling the step to
+        // 0.9/px was built and measured, and the corpus refused it:
+        // `showcase/tcp-state-machine` went lblcol 0 -> 4 and
+        // `patterns/erd-a` 0 -> 1. The reason is that a mid-label's ENTIRE
+        // perpendicular displacement is slope clearance — the smallest step
+        // that gets the box off its own diagonal shaft — and a strike costs
+        // 26 in this scorer, so at 0.9/px any clearance over 29 px is outbid
+        // by lying across the line the label names. Pricing the step above
+        // the strike buys strikes. So the along-first half of item 59 is
+        // carried by the CAP below (a step can never exceed it) and by the
+        // along-shaft candidate family, not by this coefficient.
         s+=0.35*c.ex;             // price of the slope-clearance displacement
         s+=ci*30;                 // price of leaving the preferred carrier
         // Two identical texts sitting side by side is the defect in its purest
@@ -5579,16 +7252,203 @@ function renderScene(doc,y0){
         // offers parameters outside [0,1] states its own weight so its escape
         // positions cost what they are worth in pixels rather than being
         // priced out by the length of the thing they slide along.
-        s+=(r.tw||70)*Math.abs(t-tPref)+si*10;
-        if(c.box.x<2) s+=400;                 // would fall off the left margin
-        if(s<bestS-1e-9){ bestS=s; best=c; }
+        s+=tScale*Math.abs(t-tPref)+si*10;
+        // ASSOCIATION MARGIN, IN THE SCORER AT LAST (F5, §14).
+        // The legibility floor asks how much NEARER a label is to the line it
+        // names than to the next line, and until now that question was only
+        // ever asked after the fact, by the lint. Two positions can both be
+        // collision-free and one of them still sit in the gap BETWEEN two
+        // lines, where the reader has to guess; nothing in the score saw the
+        // difference and the side-order term then decided by index.
+        // Measured on `showcase/arp-resolution` (item 58's acceptance
+        // figure): `1: heard, ignored` scored 0 above its line and 0 below
+        // it, took `above` by index, and parked in the 9.4 px gap between the
+        // broadcast line and the reciprocal pair — which then left the ARP
+        // REPLY's own 221 px label no clean position on a 194 px run, and it
+        // drew struck. With the margin priced, that label takes the open
+        // paper below and the reply's label follows it: `lblcol` 1 -> 0.
+        // The bonus is capped so it can break a tie between two legal
+        // positions and nothing more — it can never outrank an overlap,
+        // which is an AREA and unbounded.
+        { let own=Infinity, oth=Infinity;
+          const perEdge=new Map();
+          for(const g of edgeSegs){
+            const d=segBoxD(g.p,g.q,c.box);
+            if(g.e===r.e){ if(d<own) own=d; } else if(d<oth) oth=d;
+            const cur=perEdge.get(g.e);
+            if(cur===undefined||d<cur) perEdge.set(g.e,d);
+          }
+          if(own<Infinity&&oth<Infinity) s-=0.4*Math.min(45,Math.max(0,oth-own));
+          // ...AND THE SCORER ALSO ASKS THE GATE'S OWN QUESTION (item 60).
+          // The bonus above rewards a position that is NEARER ITS OWN line
+          // than to the next one, and it is clamped at zero — so between two
+          // positions that are BOTH nearer a foreign line, it says nothing,
+          // and the figure falls back to the side-order index. The legibility
+          // floor's F5 does not ask about ownership at that point: it asks
+          // whether the two NEAREST lines are within M of each other, because
+          // that is the reading where a human cannot tell which line the word
+          // belongs to at all. Measured on `statechart/bfd-session` once the
+          // admin transitions merged into one trunk (item 60): the green
+          // "rx Init, rx Up" label sat 40.0 px from INIT's self-loop and
+          // 40.0 px from UP's — margin 0.0, a coin toss — while sliding along
+          // its own shaft to t=0.2 makes those 27 px and 53 px. Nothing in the
+          // score could see the difference. The penalty is a CONSTANT, in the
+          // band the identical-text and wrong-side terms already use, so it
+          // can break the choice between two collision-free positions and can
+          // never outbid an overlap.
+          if(perEdge.size>1){
+            const ds=[...perEdge.values()].sort((a,b)=>a-b);
+            if(ds[1]-ds[0]<4) s+=26;
+          } }
+        // OFF THE CANVAS IS NOT A BAD PLACEMENT, IT IS NO PLACEMENT.
+        // The canvas grows right and down and has no mechanism here to grow
+        // up or left, so a box past those two margins is CLIPPED AWAY and the
+        // text the author wrote is never seen. This was a score term worth
+        // 400, and the note pass already records why a constant cannot do the
+        // job: every other penalty is an AREA and grows without bound, so a
+        // crowded right-hand alternative outbids the constant and the label
+        // goes over the edge. Measured on `statechart/bfd-session` at
+        // 0.4: "rx AdminDown / Detect expired, Echo failed" was
+        // emitted at x = -88.6 and simply did not appear.
+        // So it is a FILTER with its own fallback: an off-canvas candidate is
+        // kept only as the last resort, behind every position that is on the
+        // page at all, and behind the affinity filter for the same reason.
+        // The LEFT margin only, which is the margin this pass has always
+        // judged. The top is left alone deliberately: the two corridor labels
+        // `statechart/dhcp-client` parks above its top rank sit at the canvas
+        // origin BY DESIGN (the return rows run above the figure and the
+        // scene is shifted down to make room), and filtering on `y` pushed
+        // them into one band and cost an F5.
+        const offCanvas=(c.box.x<2);
+        if(offCanvas){ if(s<offS-1e-9){ offS=s; offBest=c; } continue; }
+        // THE CAP IS A FILTER, NOT A PRICE (item 59), for the reason the
+        // off-canvas term above records: every other penalty here is an AREA
+        // and grows without bound, so a constant surcharge on distance is
+        // always outbid by a crowded near position and the label goes for a
+        // walk. A mid-label further from its own shaft than STANDOFF_CAP is
+        // therefore held back behind every position that is inside the cap,
+        // and if one of them wins anyway — the geometry really had nothing
+        // closer — it is drawn with a LEADER back to the shaft. Never a free
+        // float. Endpoint labels are exempt: their distance is governed by
+        // the 16 px anchor and the affinity filter, both of item 42's.
+        if(r.kind!=='end'&&segBoxGap(c.car[0],c.car[1],c.box)>STANDOFF_CAP){
+          if(s<farS-1e-9){ farS=s; farBest=c; } continue; }
+        if(s<anyS-1e-9){ anyS=s; anyBest=c; }
+        if(owns&&s<bestS-1e-9){ bestS=s; best=c; }
       }
     }
+      if(!best) best=anyBest||farBest||offBest;  // no legal position — least bad
+      r0.win=best;                     // kept for item 55's recolour pass
       lblsvg[r0.idx]=textEl(best.x,best.y,r0.fs,best.anchor,r0.col,r0.text,r0.halo);
+      // THE LEADER (item 59). A mid-label that had to be placed past the cap
+      // states its line explicitly: a hairline from the nearest point of its
+      // box to the nearest point of its own carrying segment, in the label's
+      // own colour. It is drawn UNDER nothing and over nothing — it is 1 px,
+      // it starts at the box and it stops at the shaft — so it adds no ink
+      // anywhere the reader is not already looking for the association.
+      if(r0.kind!=='end'&&best.car&&segBoxGap(best.car[0],best.car[1],best.box)>STANDOFF_CAP){
+        const b=best.box, cx=b.x+b.w/2, cy=b.y+b.h/2;
+        const P0=best.car[0], Q0=best.car[1];
+        const vx=Q0[0]-P0[0], vy=Q0[1]-P0[1], L2=vx*vx+vy*vy;
+        const t=L2?Math.max(0,Math.min(1,((cx-P0[0])*vx+(cy-P0[1])*vy)/L2)):0;
+        const fx=P0[0]+t*vx, fy=P0[1]+t*vy;
+        // the box's own boundary point on the ray toward that foot
+        const dx=fx-cx, dy=fy-cy, ax=Math.abs(dx)||1e-9, ay=Math.abs(dy)||1e-9;
+        const k=Math.min((b.w/2+2)/ax,(b.h/2+2)/ay);
+        r0.leadIdx=lblsvg.length;
+        lblsvg.push('<line x1="'+(cx+dx*k)+'" y1="'+(cy+dy*k)+'" x2="'+fx+'" y2="'+fy+
+                    '" stroke="'+r0.col+'" stroke-width="1" opacity="0.6"/>');
+      }
       placed.push(Object.assign({text:r0.text},best.box));
       W=Math.max(W, best.box.x+best.box.w+4);
       Hh=Math.max(Hh, best.box.y+best.box.h+4-y0-20);
     }
+    // ── A BUNDLE CAPTION SITS BESIDE ITS RING (item 43) ────────────────────
+    // It used to be written at the ring's CENTRE, which is the one place on a
+    // bundle ring that is guaranteed to be occupied: the waist is where the
+    // member links cross. On `reference/topology` the `ECMP uplink set`
+    // caption lay across three edge segments; on `patterns/topology-b`
+    // `Link Bundle 1` lay on top of the `p3` endpoint label.
+    //
+    // So it is placed like every other free label in this pass, against the
+    // same `placed` / `obst` / `arrowBox` / `edgeSegs` evidence, and it enters
+    // AFTER the edge labels: a port label names one end of one link and has
+    // one place to be, while a caption names a ring and has a whole rim to
+    // choose from, so the caption is the one that yields. (Notes still enter
+    // last — nothing yields to a note.)
+    //
+    // The candidate set is twelve stations around the RIM, in the ring's own
+    // frame, so the family follows the ring's orientation instead of the
+    // canvas's. `40*|cos phi|` prices the two stations at the ring's ENDS: the
+    // ends are where the member links leave and where their nodes are, so a
+    // caption there is reaching across the very links the ring encircles. The
+    // flanks — across the members — are free, and between the two the
+    // evidence decides which is clearer. A second tier, 30 px out with a short
+    // dashed leader, exists for the figure where no flank is clear; it is
+    // priced high enough that it is taken only when every rim station is
+    // genuinely occupied.
+    for(const t of doc.trunks||[]){
+      const R=rings.get(t);
+      if(!R||t.label===null||t.label===undefined||t.label==='') continue;
+      const lines=String(t.label).split('\n'), nL=lines.length;
+      const w=Math.max(...lines.map(cw))*6.5*11.5/11, lh=11.5*1.3;
+      const h=(nL-1)*lh+11.5*1.1, up=(nL-1)*lh/2+11.5*0.85;
+      let best=null, bestS=Infinity;
+      for(const tier of [0,1]){
+        const gap=tier?30:7;
+        for(let k=0;k<12;k++){
+          const ph=k*Math.PI/6, cp=Math.cos(ph), sp=Math.sin(ph);
+          const dx=R.ux*cp+R.vx*sp, dy=R.uy*cp+R.vy*sp;
+          const rim=1/Math.hypot(cp/R.rL, sp/R.rA);
+          const out=rim+gap+Math.abs(dx)*w/2+Math.abs(dy)*h/2;
+          const cb={x:R.cx+dx*out-w/2, y:R.cy+dy*out-h/2, w, h};
+          let sc=0;
+          for(const b of placed)   sc+=3*ovl(cb,b);
+          for(const o of obst)     sc+=2.4*ovl(cb,o);
+          // a group's NAME is ink too (item 45), and a caption written over it
+          // reads as that band's second line
+          for(const o of nameObs)  sc+=2.4*ovl(cb,o);
+          for(const a of arrowBox) sc+=4*ovl(cb,a);
+          for(const g of edgeSegs) if(segHit(g.p,g.q,cb)) sc+=26;
+          // A caption lying across ANOTHER bundle's ring has stopped saying
+          // which bundle it names — F5's mechanism again, between two rings
+          // this time. It is charged like a strikethrough because that is
+          // what it is, and measured against the ring's OUTLINE rather than
+          // its bounding box: a tilted ring's box is mostly empty paper, and
+          // charging the box drove the reference figure's caption off a clear
+          // corner and onto an endpoint label. Its OWN ring is never charged
+          // — being beside that one is the whole point.
+          for(const [t2,R2] of rings)
+            if(t2!==t&&!R2.solo&&ringHitsRect(R2,R2.rL,R2.rA,cb)) sc+=26;
+          sc+=40*Math.abs(cp);          // the ring's ENDS belong to the links
+          // THE CLEARER FLANK, when two flanks are equally legal. Both of
+          // `patterns/topology-b`'s across-stations score exactly 0 — the
+          // caption fits above the ring and below it — and "first index wins"
+          // then chose by the loop's order rather than by the drawing. This
+          // term is the tie-break and only the tie-break: a bonus of at most
+          // 2, for the candidate with the most white around it, capped so it
+          // can never outrank a single overlap, let alone a strikethrough.
+          let clr=40;
+          for(const b2 of placed) clr=Math.min(clr,boxGap(cb,b2));
+          for(const o of obst)    clr=Math.min(clr,boxGap(cb,o));
+          for(const o of nameObs) clr=Math.min(clr,boxGap(cb,o));
+          sc-=0.05*Math.max(0,clr);
+          sc+=tier*400;                 // the leader is a last resort
+          if(cb.x<2||cb.y<y0) sc+=400;  // off the top or left margin
+          if(sc<bestS-1e-9){ bestS=sc; best={cb,tier,dx,dy,rim,gap}; }
+        }
+      }
+      ringLbl.set(t,best);
+      if(best.tier){
+        const p=[R.cx+best.dx*best.rim, R.cy+best.dy*best.rim];
+        const q=[R.cx+best.dx*(best.rim+best.gap), R.cy+best.dy*(best.rim+best.gap)];
+        ringLeads.push([p,q,t]);
+      }
+      placed.push({text:t.label, x:best.cb.x, y:best.cb.y, w, h});
+      best.tx=best.cb.x+w/2; best.ty=best.cb.y+up;
+      W=Math.max(W, best.cb.x+w+4);
+      Hh=Math.max(Hh, best.cb.y+h+4-y0-20);
+    }
     // ── note placement (`DRAWN-ANNOTATION-FORM`) — the SAME pass, entered LAST ────────────────
     // Four rules, and they are in the spec rather than only here because two
     // engines have to agree on them:
@@ -5624,11 +7484,12 @@ function renderScene(doc,y0){
     // metaclass the spelling is borrowed from (RULE 4.1).
     const noteCarriers=[];
     for(const n of nodes) if(n.note!==undefined&&n.note!==null&&!n.boundary)
-      noteCarriers.push({line:n.line,text:n.note,kind:'node',rect:{x:n.x,y:n.y,w:n.w,h:n.h},n});
+      noteCarriers.push({line:n.line,text:n.note,kind:'node',ref:n.id,rect:{x:n.x,y:n.y,w:n.w,h:n.h},n,
+                         lbl:n.label});
     for(const g of doc.groups) if(g.note!==undefined&&g.note!==null){
       const B=gBox[g.id]; if(!B) continue;
-      noteCarriers.push({line:g.line,text:g.note,kind:'group',
-                         rect:{x:B.x0,y:B.yA,w:B.x1-B.x0,h:B.yB-B.yA}});
+      noteCarriers.push({line:g.line,text:g.note,kind:'group',ref:g.id,
+                         rect:{x:B.x0,y:B.yA,w:B.x1-B.x0,h:B.yB-B.yA},lbl:g.label});
     }
     for(const e of doc.edges) if(e.note!==undefined&&e.note!==null){
       // An edge is a polyline, not a rect. Its carrier POINT is the midpoint of
@@ -5640,11 +7501,148 @@ function renderScene(doc,y0){
       const segs=edgeSegs.filter(g=>g.e===e); if(!segs.length) continue;
       const m=segs[Math.floor((segs.length-1)/2)];
       const cx=(m.p[0]+m.q[0])/2, cy=(m.p[1]+m.q[1])/2;
-      noteCarriers.push({line:e.line,text:e.note,kind:'edge',rect:{x:cx,y:cy,w:0,h:0},e});
+      noteCarriers.push({line:e.line,text:e.note,kind:'edge',ref:e.line,rect:{x:cx,y:cy,w:0,h:0},e});
     }
     noteCarriers.sort((a,b)=>a.line-b.line);
+    // ── ADJACENCY MUST BE DISCRIMINABLE (item 40) ─────────────────────────
+    // "Adjacency where it can, a leader only when adjacency fails" was always
+    // the rule; what was missing is that the failure test never asked whether
+    // the adjacency SAYS ANYTHING. `annotated-datapath` — the `note=`
+    // demonstrator itself — put the `mac` group note and the `pause` node note
+    // at the same y, 3 px apart, one continuous strip that reads as a caption
+    // row and binds neither box. Each was near-adjacent to the OTHER's target.
+    //
+    // This is F5's mechanism, a THIRD time (edge-label/edge = F5,
+    // endpoint-label/endpoint = item 42, note/element = here): nearest versus
+    // SECOND-nearest. A note is adjacent to its target only when
+    //   (a) it sits substantially OVER its target's span on the axis across
+    //       the side it takes — beside means beside THIS thing, and a box that
+    //       overhangs its target is already reaching for a neighbour; and
+    //   (b) its own target is the NEAREST annotatable element, by at least
+    //       NOTE_M, to the second-nearest.
+    // `annotatable` is the set of things a note can be written ON — nodes,
+    // groups, connectors — because those are exactly the readings a reader can
+    // mistake it for. When both tests pass the note simply sits there, as
+    // before. When either fails, adjacency has FAILED and the candidate is not
+    // offered at all, so the pass falls through to the far tiers, which is
+    // where the dashed leader already lives. No new drawing machinery.
+    //
+    // NOTE_M = 12 px, not F5's 4: a note is a BOX tens of pixels tall, and the
+    // eye ties it to a neighbour long before the gap closes to a hair. 12 px
+    // is one note line-height (NOTE_FS * 1.35 rounded) — below one line of the
+    // note's own text, two elements are not told apart.
+    const NOTE_M=12;
+    const noteLeads=[];
+    const annot=[];
+    for(const n of nodes) if(!n.boundary) annot.push({k:'node',id:n.id,rect:{x:n.x,y:n.y,w:n.w,h:n.h}});
+    for(const g of doc.groups){ const B=gBox[g.id];
+      if(B) annot.push({k:'group',id:g.id,rect:{x:B.x0,y:B.yA,w:B.x1-B.x0,h:B.yB-B.yA}}); }
+    const rdist=(px,py,r)=>Math.hypot(Math.max(r.x-px,0,px-(r.x+r.w)),Math.max(r.y-py,0,py-(r.y+r.h)));
+    const ptSegD=(px,py,p,q)=>{
+      const vx=q[0]-p[0], vy=q[1]-p[1], L2=vx*vx+vy*vy;
+      const t=L2?Math.max(0,Math.min(1,((px-p[0])*vx+(py-p[1])*vy)/L2)):0;
+      return Math.hypot(px-(p[0]+t*vx), py-(p[1]+t*vy));
+    };
+    // A connector is annotatable too, and it is measured as the polyline it is.
+    const edgeDist=(px,py,e)=>{ let d=Infinity;
+      for(const g of edgeSegs) if(g.e===e)
+        d=Math.min(d,ptSegD(px,py,g.p,g.q));
+      return d; };
+    const noteEdges=[];
+    for(const e of doc.edges) if(edgeSegs.some(g=>g.e===e)) noteEdges.push(e);
+    // Does this candidate box read as belonging to THIS carrier and no other?
+    //
+    // The test is on SPANS, not on centre-to-centre distance, because that is
+    // how the eye reads a note: it looks back along the side the box sits on
+    // and takes the first thing it lands on. So a competitor is any
+    // annotatable element whose PROJECTION across that side overlaps the note
+    // — the reading the filed case describes exactly, the `pause` note's left
+    // edge reaching "under the `mac` band's horizontal projection" — and the
+    // margin is measured along the side, own gap versus second-nearest gap.
+    const spanOf=(r,across)=>across?[r.y,r.y+r.h]:[r.x,r.x+r.w];
+    const gapTo=(cb,r,side)=>side==='below'?cb.y-(r.y+r.h)
+                            :side==='above'?r.y-(cb.y+cb.h)
+                            :side==='right'?cb.x-(r.x+r.w)
+                            :r.x-(cb.x+cb.w);
+    const discriminable=(cb,c,side)=>{
+      const across=(side==='left'||side==='right');
+      // (a) the note sits substantially OVER its target's span. `beside` means
+      // beside THIS thing; a box that hangs off its target is already halfway
+      // to the neighbour. The denominator is the SMALLER of the two spans, so
+      // a wide note fully covering a narrow target passes and a note sliding
+      // off the end of a wide target fails.
+      const [nA,nB]=spanOf(cb,across), [tA,tB]=spanOf(c.rect,across);
+      const denom=Math.min(nB-nA,tB-tA);
+      if(denom>1&&(Math.min(nB,tB)-Math.max(nA,tA))/denom<0.6) return false;
+      // (b) nearest versus second-nearest, along the side, among the elements
+      // whose projection the note actually lies across.
+      const claim=r=>{ const [rA,rB]=spanOf(r,across);
+        return Math.min(nB,rB)>Math.max(nA,rA); };
+      let own=gapTo(cb,c.rect,side), second=Infinity;
+      if(own<0) return false;                // the note overlaps its own target
+      for(const a of annot){
+        if(c.kind===a.k&&c.ref===a.id) continue;
+        if(!claim(a.rect)) continue;
+        const g=gapTo(cb,a.rect,side);
+        if(g>=-1) second=Math.min(second,g);
+      }
+      for(const e of noteEdges){
+        if(c.kind==='edge'&&c.e===e) continue;
+        for(const g0 of edgeSegs){ if(g0.e!==e) continue;
+          const r={x:Math.min(g0.p[0],g0.q[0]),y:Math.min(g0.p[1],g0.q[1]),
+                   w:Math.abs(g0.q[0]-g0.p[0]),h:Math.abs(g0.q[1]-g0.p[1])};
+          if(!claim(r)) continue;
+          const g=gapTo(cb,r,side);
+          if(g>=-1) second=Math.min(second,g);
+        }
+      }
+      return own+NOTE_M<=second;
+    };
+    // ── AN ADJACENCY NOTE NAMES ITS TARGET; A LEADER NOTE DOES NOT (item 56b) ──
+    // A note sited by ADJACENCY carries its whole association in a gap: the
+    // box is beside a thing, and the reader has to guess which thing. The
+    // drawing already knows the answer — `data-note-for` has carried the
+    // resolved target since item 40b — so the note says it, in words: the
+    // target's LABEL, bold, then a colon, then the note's own sentence
+    // ("MAC layer: Runs on the recovered RX clock…"). It is derived, never
+    // authored: `DOMAIN-CONVENTION-DIRECTIVES` keeps the drawing convention with the engine.
+    //
+    // A note with a DRAWN LEADER does not take the prefix, and that is the
+    // whole of the split. The leader IS the association — a line from the box
+    // to the thing — and repeating it in the text is ink for a fact the
+    // drawing already states unambiguously.
+    //
+    // ONLY A LABELLED NODE OR GROUP can be named this way. A connector has no
+    // id and no name (`data-note-for` carries its source LINE, which is not a
+    // thing a reader can see), and the figure-level note on `title` names the
+    // FIGURE — there is exactly one and it needs no naming.
+    //
+    // ORDER, because the two decisions are circular (the prefix changes the
+    // box, the box changes whether adjacency succeeds): the note is sited
+    // WITH the prefix first, since adjacency is the preferred outcome and the
+    // prefixed box is the one that has to fit. If that siting takes a leader,
+    // the note is re-sited WITHOUT the prefix, and THAT placement stands —
+    // there is no third pass. It terminates by construction and it is
+    // deterministic, which is what `RENDERING-DETERMINISM` needs of it.
+    const notePrefix=c=>((c.kind==='node'||c.kind==='group')&&c.lbl&&String(c.lbl).trim()
+                         ?String(c.lbl).replace(/\n/g,' ')+':':null);
     for(const c of noteCarriers){
-      const box=noteBox(c.text);
+      const pfx=notePrefix(c);
+      let box=noteBox(c.text,pfx), sited=siteNote(c,box);
+      if(pfx&&sited.best&&sited.best.far){ box=noteBox(c.text,null); sited=siteNote(c,box); }
+      let best=sited.best;
+      // Only if EVERY candidate was off-canvas: take the least-bad one and
+      // clamp it on. It may overlap something; visible and overlapping is
+      // recoverable by an author, invisible is not.
+      if(!best){ best=sited.fallback; best.x=Math.max(0,best.x); best.y=Math.max(y0,best.y); }
+      lblsvg.push(noteSvg(best.x,best.y,box,c));
+      if(best.far){ lblsvg.push(noteLeader(best,box,c.rect));
+                    noteLeads.push(noteLeaderPts(best,box,c.rect)); }
+      placed.push({x:best.x,y:best.y,w:box.w,h:box.h});
+      W=Math.max(W, best.x+box.w+4);
+      Hh=Math.max(Hh, best.y+box.h+4-y0-20);
+    }
+    function siteNote(c,box){
       // Adjacency first, then the same four sides pushed out far enough that a
       // leader is legible. `si` orders the sides; `far` is what decides the
       // leader, and it costs enough that adjacency wins every time adjacency is
@@ -5678,6 +7676,11 @@ function renderScene(doc,y0){
             by=side==='below'?c.rect.y+c.rect.h+gap:c.rect.y-gap-box.h;
           }
           const cb={x:bx,y:by,w:box.w,h:box.h};
+          // ADJACENCY THAT SAYS NOTHING IS NOT ADJACENCY (item 40). Tier 0 is
+          // the no-leader tier; a candidate there must actually bind the note
+          // to its carrier. If it does not, it is withdrawn and the far tiers
+          // — which draw the dashed leader — are what remain.
+          if(!far&&!discriminable(cb,c,side)) continue;
           let s=0;
           // A NOTE YIELDS; NOTHING YIELDS TO A NOTE. `placed` holds the edge
           // labels and the notes already sited, and its weight is the HIGHEST
@@ -5690,6 +7693,7 @@ function renderScene(doc,y0){
           for(const o of obst)     s+=6*ovl(cb,o);
           for(const a of arrowBox) s+=8*ovl(cb,a);
           for(const g of edgeSegs) if(segHit(g.p,g.q,cb)) s+=26;
+          for(const g of noteLeads) if(segHit(g[0],g[1],cb)) s+=26;
           for(const g of doc.groups){ const B=gBox[g.id];
             if(B) s+=1.2*ovl(cb,{x:B.x0,y:B.yA,w:B.x1-B.x0,h:B.yB-B.yA}); }
           s+=si*12;
@@ -5719,19 +7723,176 @@ function renderScene(doc,y0){
           if(s<bestS-1e-9){ bestS=s; best={x:bx,y:by,far,side}; }
         }
       }
-      // Only if EVERY candidate was off-canvas: take the least-bad one and
-      // clamp it on. It may overlap something; visible and overlapping is
-      // recoverable by an author, invisible is not.
-      if(!best){ best=fallback; best.x=Math.max(0,best.x); best.y=Math.max(y0,best.y); }
-      lblsvg.push(noteSvg(best.x,best.y,box,c));
-      if(best.far) lblsvg.push(noteLeader(best,box,c.rect));
-      placed.push({x:best.x,y:best.y,w:box.w,h:box.h});
-      W=Math.max(W, best.x+box.w+4);
-      Hh=Math.max(Hh, best.y+box.h+4-y0-20);
+      return {best,fallback};
+    }
+    // ── TONE PAIRING FOR CROWDED UNCLASSED EDGES (item 55) ────────────────
+    // Where several plain lines cross the middle of a figure, every one of
+    // them is `#555` and every one of their labels is `#555`, so the reader
+    // pairs word to line by tracing. `statechart/dhcp-client` is the case:
+    // five long diagonals through one region, five two-line labels sitting
+    // among them.
+    //
+    // The engine assigns those lines DISTINCT TONES, and each label takes its
+    // own line's tone. That is all the tones do.
+    //
+    // THE `PRESENTATION-AS-MEANING-CARRIER` BOUNDARY, and it is the whole reason the palette looks like
+    // this. `PRESENTATION-AS-MEANING-CARRIER` says presentation is never the sole carrier of meaning: a
+    // reader must never have to read a colour to learn a fact. These tones
+    // carry NO fact. They are not derived from anything the author wrote,
+    // they earn NO legend entry, no `class` and no `stroke=` names them, and
+    // a reader who goes looking for what "the olive one" means finds nothing
+    // stated anywhere — because there is nothing. They are DISCRIMINATION,
+    // the same job a fan-out offset does when two messages share a node pair,
+    // and the palette is what keeps them readable as that: four MUTED hues,
+    // none of them a signal colour and none of them one of the plane or
+    // class colours a legend can name. A classed edge is never touched, because there
+    // the colour DOES carry the legend's meaning and a second scheme on top
+    // of it would be two claims about one stroke.
+    //
+    // ELIGIBILITY. An edge takes a tone only if it (a) joins no class,
+    // (b) sets no `stroke=` of its own — both would be an authored choice —
+    // (c) draws a `mid` label, since a line with nothing to pair needs no
+    // pairing, and (d) is not a merge-bus member, whose whole construct is
+    // that several edges are ONE line.
+    //
+    // CROWDING is measured on the FINISHED drawing, after every label is
+    // sited: an eligible edge is crowded when its label box comes within
+    // TONE_PROX of another edge's shaft or another edge's label. 30 px is the
+    // threshold — a little over two label line-heights, the distance at which
+    // a reader stops being able to sweep from word to line without crossing
+    // something else.
+    //
+    // ASSIGNMENT is a greedy pass in DOCUMENT ORDER, and it asks about the
+    // EYE rather than about the array: "not the same as its neighbour" was
+    // never the requirement — the palette this replaced had two entries 8.7
+    // apart in CIE L*a*b*, which is different and still not TELLABLE apart at
+    // a glance, and that was the whole job. Every crowded edge takes a tone
+    // clearly apart from every neighbour already assigned, and among those
+    // the least-spent one, so a figure uses its whole palette instead of
+    // ping-ponging between two extremes (see the choice below). Ordering by
+    // source line and breaking ties by palette index makes it deterministic:
+    // same source, same tones.
+    {
+      const TONE_PROX=30;
+      // The palette (item 61). Four muted hues at essentially ONE lightness —
+      // L* 38.6, 39.7, 38.9, 40.9 — so they differ by HUE and nothing else,
+      // and no tone can be read as heavier or more important than another:
+      //   slate blue #3f5b8c   warm brown #7a5638
+      //   olive drab #55611f   steel      #206a72
+      // Pairwise separation in CIE L*a*b* is 28.6 to 68.1, against the 8.7 of
+      // the four slate-greys this replaced (a just-noticeable difference is
+      // about 2.3, so those two were "different" and not tellable apart).
+      // Because a label takes its line's tone and a label is TEXT, every one
+      // is legible as type on white: 6.80, 6.53, 6.74 and 6.24 to 1, all above
+      // the 4.5:1 floor for body text. A tone that discriminates by being too
+      // faint to read has traded one defect for a worse one. None of them is
+      // near a plane or class colour, and none is near the #555 default an
+      // untoned line keeps: the nearest approach is warm brown at 26.
+      const TONES=['#3f5b8c','#7a5638','#55611f','#206a72'];
+      const busMem=new Set();
+      for(const [e2] of busRoute) busMem.add(e2);
+      for(const [e2,P2] of chPlan) if(P2.bus) busMem.add(e2);
+      const lblOf=new Map();
+      for(const q of lblReq) if(q.kind==='mid'&&q.win&&!lblOf.has(q.e)) lblOf.set(q.e,q.win.box);
+      const elig=[];
+      for(const e2 of edges){
+        if(e2.stroke!==undefined||busMem.has(e2)) continue;
+        const cl=e2.cls; if(cl!==undefined&&cl!==null&&(!Array.isArray(cl)||cl.length)) continue;
+        if(!lblOf.has(e2)) continue;
+        elig.push(e2);
+      }
+      const segD=(b,e2)=>{ let d=Infinity;
+        for(const g of edgeSegs) if(g.e===e2) d=Math.min(d,segBoxD(g.p,g.q,b));
+        return d; };
+      const crowded=new Set(), near=new Map();
+      for(const e2 of elig){
+        const b=lblOf.get(e2);
+        for(const f of edges){
+          if(f===e2) continue;
+          const hit=segD(b,f)<TONE_PROX ||
+                    (lblOf.has(f)&&boxGap(b,lblOf.get(f))<TONE_PROX);
+          if(!hit) continue;
+          crowded.add(e2);
+          if(elig.indexOf(f)>=0){
+            if(!near.has(e2)) near.set(e2,new Set()); near.get(e2).add(f);
+            if(!near.has(f))  near.set(f,new Set());  near.get(f).add(e2);
+          }
+        }
+      }
+      // DISTANCE IS MEASURED IN THE EYE, NOT IN THE ARRAY (item 61). The old
+      // palette was ordered by darkness, so "furthest position in the list"
+      // was a fair proxy for "most tellable apart". A palette that separates
+      // by HUE has no such order — steel is not "between" slate blue and
+      // olive — so the assignment asks the question directly, in CIE L*a*b*,
+      // where a difference of about 2.3 is the just-noticeable one and these
+      // four sit 28.6 to 68.1 apart.
+      const tLab=h=>{
+        const v=[1,3,5].map(i=>parseInt(h.slice(i,i+2),16)/255)
+                       .map(c=>c<=0.03928?c/12.92:Math.pow((c+0.055)/1.055,2.4));
+        let X=(0.4124*v[0]+0.3576*v[1]+0.1805*v[2])/0.95047,
+            Y=(0.2126*v[0]+0.7152*v[1]+0.0722*v[2]),
+            Z=(0.0193*v[0]+0.1192*v[1]+0.9505*v[2])/1.08883;
+        const f=t=>t>0.008856?Math.cbrt(t):(7.787*t+16/116);
+        const fx=f(X), fy=f(Y), fz=f(Z);
+        return [116*fy-16, 500*(fx-fy), 200*(fy-fz)];
+      };
+      const LAB=TONES.map(tLab);
+      const dE=(i,j)=>Math.hypot(LAB[i][0]-LAB[j][0],LAB[i][1]-LAB[j][1],LAB[i][2]-LAB[j][2]);
+      const tone=new Map(), used=TONES.map(()=>0);
+      for(const e2 of elig.slice().sort((p,q)=>p.line-q.line)){
+        if(!crowded.has(e2)) continue;
+        const nb=[];
+        for(const f of (near.get(e2)||[])) if(tone.has(f)) nb.push(TONES.indexOf(tone.get(f)));
+        // ENOUGH IS ENOUGH, AND THEN SPREAD. Taking the FURTHEST tone from
+        // each neighbour sounds right and collapses the palette: with one
+        // assigned neighbour the furthest is always the same antipode, so a
+        // figure whose crowding graph is a set of pairs paints itself in two
+        // hues and the other two are never seen (dhcp-client, measured: 2 of
+        // 4). Every pair in this palette is at least 28.6 apart — an order of
+        // magnitude over the ~2.3 just-noticeable difference — so "furthest"
+        // buys nothing a reader can use, while a THIRD identity in a crowded
+        // corner buys a great deal. So: any tone clearly apart from every
+        // neighbour (>= TONE_SEP) is admissible, and among the admissible the
+        // LEAST-SPENT one wins; ties to the lowest index, so the same source
+        // always paints the same figure. If nothing clears the bar — a future
+        // palette with closer entries, or more crowding than tones — it falls
+        // back to the plain furthest-from-the-neighbours choice.
+        const TONE_SEP=25;
+        let pick=-1, bestU=-1;
+        for(let i=0;i<TONES.length;i++){
+          const d=nb.length?Math.min(...nb.map(j=>dE(i,j))):Infinity;
+          if(d<TONE_SEP) continue;
+          const u=used[i];                       // how many lines already wear it
+          if(pick<0||u<bestU){ bestU=u; pick=i; }
+        }
+        if(pick<0){ let bestD=-1; pick=0;
+          for(let i=0;i<TONES.length;i++){
+            const d=nb.length?Math.min(...nb.map(j=>dE(i,j))):Infinity;
+            if(d>bestD+1e-9){ bestD=d; pick=i; }
+          } }
+        tone.set(e2, TONES[pick]);
+        used[pick]++;
+      }
+      if(tone.size>1) for(const [e2,col2] of tone){
+        const key='data-edge="'+e2.line+'"';
+        for(let i=0;i<esvg.length;i++)
+          if(esvg[i].indexOf(key)>=0) esvg[i]=esvg[i].replace('stroke="#555"','stroke="'+col2+'"');
+        for(const i of (arrowIdx.get(e2)||[]))
+          lblsvg[i]=lblsvg[i].replace('fill="#555"','fill="'+col2+'"');
+        for(const q of lblReq) if(q.e===e2&&q.win){
+          lblsvg[q.idx]=textEl(q.win.x,q.win.y,q.fs,q.win.anchor,col2,q.text,q.halo);
+          // a standoff leader (item 59) is part of the label, so it takes the
+          // label's tone with it — otherwise the one line drawn to state the
+          // association would be the one line still painted the old colour.
+          if(q.leadIdx!==undefined)
+            lblsvg[q.leadIdx]=lblsvg[q.leadIdx].replace('stroke="'+q.col+'"','stroke="'+col2+'"');
+        }
+      }
     }
   }
   // nodes on top (each wrapped in a draggable, identifiable group)
   const nsvg=[];
+  const nodeLbl=new Map();   // node id -> its drawn label's box (item 49)
   for(const n of nodes){
     if(n.boundary){
       // never drawn as a shape (`EXTERNAL-EDGE-ENDPOINTS`): the edge already ended open at the
@@ -5789,32 +7950,43 @@ function renderScene(doc,y0){
     const avail=2*inscribedHalfW(shapeAxes(n),nl.length*8)-16;
     if(n.rigid && need>avail) fs=Math.max(8, FONT*avail/need);
     nsvg.push(textEl(n.x+n.w/2, n.y+n.h/2+fs*0.35, fs, 'middle', txt, n.label));
+    // The node's own label as INK, for whoever else wants to write inside this
+    // box — today the zone-band captions (item 49). Recorded here rather than
+    // recomputed there, because `fs` is the shrink-to-fit size and only this
+    // scope knows it.
+    { const lw=need*fs/FONT, lh=nl.length*fs*1.15;
+      nodeLbl.set(n.id,{x0:n.x+n.w/2-lw/2, x1:n.x+n.w/2+lw/2,
+                        y0:n.y+n.h/2-lh/2, y1:n.y+n.h/2+lh/2}); }
     nsvg.push('</g>');
   }
   // trunk rings (semantic LAG/ES bundles): the ellipse is DERIVED from the
-  // member links' midpoints — drag a node and the ring follows
+  // member links — drag a node and the ring follows. Its geometry is computed
+  // above (`ringOf`, item 43) because the caption has to be placed by the
+  // label pass, which runs before this one; here the ring is only drawn.
+  // `rL` is the semi-axis ALONG the members and `rA` the one ACROSS them, so
+  // the SVG's rx/ry are the ring's own axes rotated onto the canvas.
   const tsvg=[];
   for(const t of zsort(doc.trunks)){
-    const mids=[];
-    for(const [a,b] of t.pairs){
-      const A=byId[a], B=byId[b]; if(!A||!B) continue;
-      const [x1,yy1]=borderPoint(A,B.x+B.w/2,B.y+B.h/2);
-      const [x2,yy2]=borderPoint(B,A.x+A.w/2,A.y+A.h/2);
-      mids.push([(x1+x2)/2,(yy1+yy2)/2]);
-    }
-    if(!mids.length) continue;
-    const cx=mids.reduce((s,m)=>s+m[0],0)/mids.length;
-    const cy=mids.reduce((s,m)=>s+m[1],0)/mids.length;
-    const rx=Math.max(46, Math.max(...mids.map(m=>Math.abs(m[0]-cx)))+38);
-    const ry=Math.max(26, Math.max(...mids.map(m=>Math.abs(m[1]-cy)))+22);
+    const R=rings.get(t); if(!R) continue;
     // 0.1 (§8.4): the ring has no interior — `stroke=` is the one
     // name for its channel; `fill=` on a bundle is now a line error, so the
     // model field is always absent and the old `t.fill` fallback is gone.
     const col=t.stroke||'#64748b';
-    tsvg.push('<ellipse cx="'+cx+'" cy="'+cy+'" rx="'+rx+'" ry="'+ry+'" fill="transparent" stroke="'+(t.stroke||col)+'"'+dashOf(t.style,'6 4')+' stroke-width="1.6"/>');
-    tsvg.push(textEl(cx, cy+4, 11.5, 'middle', col, t.label,' paint-order="stroke" stroke="#fff" stroke-width="3"'));
-    W=Math.max(W,cx+rx); Hh=Math.max(Hh,cy+ry-y0-20);
+    const deg=R.th*180/Math.PI;
+    const rot=Math.abs(deg)<0.05?'':' transform="rotate('+rnd3(deg)+' '+rnd3(R.cx)+' '+rnd3(R.cy)+')"';
+    // ONE MEMBER = NO ELLIPSE (item 53). The caption below is the whole
+    // drawing, and an unlabelled one-member bundle draws nothing.
+    if(!R.solo){
+      tsvg.push('<ellipse cx="'+rnd3(R.cx)+'" cy="'+rnd3(R.cy)+'" rx="'+rnd3(R.rL)+'" ry="'+rnd3(R.rA)+'" fill="transparent" stroke="'+(t.stroke||col)+'"'+dashOf(t.style,'6 4')+' stroke-width="1.6"'+rot+'/>');
+      W=Math.max(W,R.cx+R.hw); Hh=Math.max(Hh,R.cy+R.hh-y0-20);
+    }
+    const L=ringLbl.get(t);
+    if(L) tsvg.push(textEl(rnd3(L.tx), rnd3(L.ty), 11.5, 'middle', col, t.label,' paint-order="stroke" stroke="#fff" stroke-width="3"'));
   }
+  // the caption's leader, when no rim station was clear (item 43)
+  for(const [p,q,t] of ringLeads)
+    tsvg.push('<line x1="'+rnd3(p[0])+'" y1="'+rnd3(p[1])+'" x2="'+rnd3(q[0])+'" y2="'+rnd3(q[1])
+      +'" stroke="'+(t.stroke||'#64748b')+'" stroke-width="1" stroke-dasharray="3 3"/>');
   // threshold markers + labels (top layer). The target is a GROUP box or,
   // a single NODE box — the same two scopes `band` has always
   // taken (§2.6, `AUTHORING-INTENT-OVER-RENDERING`); a node's box is spelled in the gBox coordinate shape.
@@ -5839,17 +8011,84 @@ function renderScene(doc,y0){
   // band already owns an area, so the name needs no gutter and the canvas box
   // does not grow — W and Hh are untouched, which is why adding the label moves
   // no existing geometry in any figure.
+  // ── A BAND CAPTION CLEARS THE NAME OF THE THING IT IS DRAWN INSIDE ──────
+  // (item 49.) Centred-in-the-band is right when the band is the
+  // only ink in that area and wrong when the band is drawn INSIDE a node,
+  // because the node's own label is already centred there: `block-experimental`
+  // put "Drained", "Q2" and "Headroom" on one baseline 1.6 px apart and the
+  // reader got `DrainedQ2Headroom`. This is item 44/45's finding at the
+  // intra-node scale — ink-blind placement — so the answer is theirs: the node
+  // label, and every caption already placed on the same node, are OBSTACLES.
+  //
+  // The caption keeps its band-centred position unless that box comes within
+  // 4 px of one (F6's margin, and F6 is the axis that would charge it). It
+  // then slides by the SMALLEST amount that opens the gap — along the band's
+  // OWN long axis first, which keeps it inside the band it names, then across
+  // — staying within the host node. Only when the interior can hold no such
+  // position does it move OUTSIDE, just beyond the band's outer edge, which is
+  // where a threshold's caption already goes. A group- or region-scope band is
+  // untouched: there is no centred label in the middle of a group box, and
+  // every such figure in the corpus is byte-identical.
+  const bandBoxes=new Map();
   for(const f of zsort(doc.bands)){
     const bn=byId[f.target];
     const B=gBox[f.target] || (bn ? {x0:bn.x, x1:bn.x+bn.w, yA:bn.y, yB:bn.y+bn.h} : null);
     if(!B) continue;
     const [bx,by,bw,bh]=bandRect(f,B.x0,B.yA,B.x1,B.yB);
-    tsvg.push(textEl(bx+bw/2, by+bh/2+4, 11, 'middle', labelInk(f.fill,'#334155'), f.label,
+    let tx=bx+bw/2, ty=by+bh/2+4, anchor='middle';
+    const lw=cwMax(f.label)*6.5, M=4;
+    const obst=[];
+    if(bn){
+      const nl=nodeLbl.get(bn.id); if(nl) obst.push(nl);
+      for(const o of (bandBoxes.get(bn.id)||[])) obst.push(o);
+    }
+    const boxAt=(x,y)=>({x0:x-lw/2, x1:x+lw/2, y0:y-4-7.5, y1:y-4+3.5});
+    const clear=b=>!obst.some(o=>b.x0<o.x1+M&&b.x1>o.x0-M&&b.y0<o.y1+M&&b.y1>o.y0-M);
+    if(obst.length && !clear(boxAt(tx,ty))){
+      // long axis first: a vertical slab slides up/down, a horizontal one
+      // left/right. Inside the host node either way.
+      const vert=(f.dir==='left'||f.dir==='right');
+      const dirs=vert?[[0,-1],[0,1],[-1,0],[1,0]]:[[-1,0],[1,0],[0,-1],[0,1]];
+      let done=false;
+      for(let d=1; d<=160 && !done; d+=1){
+        for(const [ux,uy] of dirs){
+          const x=tx+ux*d, y=ty+uy*d, b=boxAt(x,y);
+          // containment is asked of the axis being MOVED ALONG only. A
+          // caption is routinely wider than the slab it names (a 30% band on
+          // an 84 px node against a 45 px word), and it always was — sliding
+          // it vertically must not be refused for an overhang the centred
+          // placement already had.
+          if(uy&&(b.y0<B.yA+1||b.y1>B.yB-1)) continue;
+          if(ux&&(b.x0<B.x0+1||b.x1>B.x1-1)) continue;
+          if(clear(b)){ tx=x; ty=y; done=true; break; }
+        }
+      }
+      if(!done){
+        // SIDE PLACEMENT: the interior cannot hold both, so the caption
+        // leaves the node on the band's own outer side and keeps its
+        // adjacency from outside.
+        // `extend=` names the direction the band GROWS, so its outer side is
+        // the edge it grew FROM: an `extend=right` band starts at the left
+        // edge and leaves by the left.
+        if(f.dir==='right')      { anchor='end';    tx=B.x0-6; ty=by+bh/2+4; }
+        else if(f.dir==='left')  { anchor='start';  tx=B.x1+6; ty=by+bh/2+4; }
+        else if(f.dir==='up')    { anchor='middle'; tx=bx+bw/2; ty=B.yB+13; }
+        else                     { anchor='middle'; tx=bx+bw/2; ty=B.yA-6; }
+        W=Math.max(W, anchor==='end'?tx:tx+(anchor==='start'?lw:lw/2));
+        Hh=Math.max(Hh, ty+4-y0-20);
+      }
+    }
+    if(bn){
+      const b=boxAt(anchor==='middle'?tx:(anchor==='end'?tx-lw/2:tx+lw/2), ty);
+      if(!bandBoxes.has(bn.id)) bandBoxes.set(bn.id,[]);
+      bandBoxes.get(bn.id).push(b);
+    }
+    tsvg.push(textEl(tx, ty, 11, anchor, labelInk(f.fill,'#334155'), f.label,
                      ' paint-order="stroke" stroke="#fff" stroke-width="3"'));
   }
   const yEnd=y0+20+Hh+10;
   return {svg:gsvg.join('')+esvg.join('')+nsvg.join('')+tsvg.join('')+lblsvg.join(''), y:yEnd, w:W+2,
-          meta:{W:W, top:y0+20+chShift, Hh:Hh, left:bShift}, errs:gErrs};
+          meta:{W:W, top:y0+20+chShift+tShift, Hh:Hh, left:bShift+lShift}, errs:gErrs};
 }
 // borderPoint: where the ray from n's centre toward (tx,ty) leaves the shape.
 // It must leave the DRAWN outline: a rectangle clip on a diamond or an ellipse
@@ -6022,7 +8261,7 @@ function edgeRuns(v, p, n, span, ownAt){
 //   `lifeline` declaration order is the COLUMN axis, left to right. Both axes
 //   are declaration-ordered, and that is why this genre has no `flow` and no
 //   `rank`: a key that reordered the drawing would make the picture disagree
-//   with the text (`SEQUENCE-SOURCE-STANDARD`-R182). `fragment` and `operand` lines are
+//   with the text (`SEQUENCE-GENRE-VOCABULARY`). `fragment` and `operand` lines are
 //   DECLARATIONS and carry no time position of their own; a container's drawn
 //   extent is the span of its members' positions. Implementation: every
 //   element carries its source line number, so the row order is recovered by
@@ -6960,6 +9199,25 @@ function shade(hex,f){
   return '#'+c(((v>>16)&255)*f)+c(((v>>8)&255)*f)+c((v&255)*f);
 }
 const CHART_PALETTE=['#3b82f6','#22c55e','#f59e0b','#ef4444','#a855f7','#14b8a6','#eab308','#64748b'];
+// Does an axis-aligned box overlap a CONVEX polygon? Separating-axis test:
+// two convex shapes miss each other iff some edge normal of either separates
+// them. The bar faces this is asked about are quads by construction (three
+// per bar), so the test is exact and needs no clipping library.
+function chartQuadHitsBox(poly,box){
+  const bx=[[box.x0,box.y0],[box.x1,box.y0],[box.x1,box.y1],[box.x0,box.y1]];
+  const shapes=[poly,bx];
+  for(const sh of shapes){
+    for(let i=0;i<sh.length;i++){
+      const a=sh[i], c=sh[(i+1)%sh.length];
+      const nx=-(c[1]-a[1]), ny=(c[0]-a[0]);
+      let a0=Infinity,a1=-Infinity,b0=Infinity,b1=-Infinity;
+      for(const q of poly){ const d=q[0]*nx+q[1]*ny; if(d<a0)a0=d; if(d>a1)a1=d; }
+      for(const q of bx){   const d=q[0]*nx+q[1]*ny; if(d<b0)b0=d; if(d>b1)b1=d; }
+      if(a1<b0||b1<a0) return false;
+    }
+  }
+  return true;
+}
 function renderChart(b,y0,doc){
   const t=doc.blocks.find(x=>x.type==='table'&&x.id===b.tid);
   const rows=t.rows.map(r=>r.cells.slice(1).map(c=>parseFloat(c.v)||0));
@@ -6984,41 +9242,114 @@ function renderChart(b,y0,doc){
   // gutter costs only the width it actually uses (0 when no label overhangs,
   // so every chart whose labels already fitted is byte-unchanged).
   const rLabPx=l=>cwMax(l)*6.5*10/11;          // textEl draws these at font-size 10
-  const ox0=R*W2+8;
-  const gut=Math.max(0,...rLab.map((l,r)=>rLabPx(l)+4-(ox0-(r+0.65)*W2)));
-  const ox=ox0+gut, oy=y0+18+ZS*zmax+6;
-  const P=(r,c,z)=>[ox+(c-r)*W2, oy+(c+r)*H2-z*ZS];
-  const svg=[];
+  const oy=y0+18+ZS*zmax+6;
+  // EVERYTHING BELOW IS COMPUTED IN A FRAME WHOSE x IS RELATIVE TO THE FLOOR
+  // ORIGIN `ox`, because the gutter that fixes `ox` is not known until the
+  // labels have been placed, and label placement is invariant to it: a nudge
+  // is a shift relative to the bars, and the bars shift with the origin.
+  const PR=(r,c,z)=>[(c-r)*W2, oy+(c+r)*H2-z*ZS];
+  const svg=[], lsvg=[];
   svg.push('<text x="0" y="'+(y0+14)+'" font-size="13" font-weight="600">'+esc(t.label)+' — bar3d</text>');
-  // floor grid edges
-  const F=[P(0,0,0),P(R,0,0),P(R,C,0),P(0,C,0)];
-  svg.push('<polygon points="'+F.map(p=>p.join(',')).join(' ')+'" fill="#f6f5ef" stroke="#d6d4cc"/>');
-  // bars, far to near
-  const order=[];
+  // bars, far to near — polygons kept for the label occlusion test below
+  const order=[], faces=[];
   for(let r=0;r<R;r++)for(let c=0;c<C;c++)order.push([r,c]);
   order.sort((a,b2)=>(a[0]+a[1])-(b2[0]+b2[1]));
+  const bars=[];
   for(const [r,c] of order){
     const h=rows[r][c]; if(h<=0) continue;
     const col=CHART_PALETTE[c%CHART_PALETTE.length];
     const i0=r+(1-BAR)/2, i1=r+(1+BAR)/2, j0=c+(1-BAR)/2, j1=c+(1+BAR)/2;
-    const A=P(i0,j0,h),Bp=P(i1,j0,h),Cp=P(i1,j1,h),D=P(i0,j1,h);
-    const B0=P(i1,j0,0),C0=P(i1,j1,0),D0=P(i0,j1,0);
-    svg.push('<polygon points="'+[Bp,Cp,C0,B0].map(p=>p.join(',')).join(' ')+'" fill="'+shade(col,0.72)+'"/>');
-    svg.push('<polygon points="'+[Cp,D,D0,C0].map(p=>p.join(',')).join(' ')+'" fill="'+shade(col,0.55)+'"/>');
-    svg.push('<polygon points="'+[A,Bp,Cp,D].map(p=>p.join(',')).join(' ')+'" fill="'+col+'"/>');
+    const A=PR(i0,j0,h),Bp=PR(i1,j0,h),Cp=PR(i1,j1,h),D=PR(i0,j1,h);
+    const B0=PR(i1,j0,0),C0=PR(i1,j1,0),D0=PR(i0,j1,0);
+    bars.push([Bp,Cp,C0,B0],[Cp,D,D0,C0],[A,Bp,Cp,D]);
+    faces.push([[Bp,Cp,C0,B0],shade(col,0.72)],[[Cp,D,D0,C0],shade(col,0.55)],[[A,Bp,Cp,D],col]);
+  }
+  // AXIS LABELS ARE PLACED LAST AND PAINTED LAST (backlog 48).
+  // They used to be emitted in WORLD space at the floor's edge and then left
+  // where they landed, which put them inside the projection's own footprint:
+  // a tall bar rises up-and-left across exactly the row line whose name sits
+  // out there, so the categories a tall bar celebrates were the ones it hid
+  // (`telemetry-export`: "Sampler" on the 12000 bar; `queue-heatmap`: P0, P1
+  // and P2 on the bar field, and the Q captions under the bar feet). Paint
+  // order alone does not fix it — dark grey on a saturated fill is unread
+  // whichever is on top — so the label LEANS OUT along its own grid line,
+  // the one direction that keeps it a label OF that row or column: a row
+  // name travels outward at constant r (decreasing c), a column name outward
+  // at constant c (increasing r), each stepping 2 px until its box clears
+  // every bar face. Leaning out is bounded (40 px); the halo is what carries
+  // the rare label that cannot fully clear. The nudge changes no bar, no
+  // floor and no ruler — only where a name sits on the line it already
+  // belonged to.
+  const HALO=' paint-order="stroke" stroke="#fff" stroke-width="3"';
+  const LEAN=2, LEAN_MAX=96, CEIL=y0+18;
+  function leanBox(px,py,wpx,anchor){
+    return {x0:anchor==='end'?px-wpx:px, x1:anchor==='end'?px:px+wpx, y0:py-8, y1:py+2.5};
   }
-  // axis labels
-  rLab.forEach((l,r)=>{ const p=P(r+0.5,-0.15,0); svg.push(textEl(p[0]-4,p[1]+10,10,'end','#6f6e69',l)); });
-  cLab.forEach((l,c)=>{ const p=P(R+0.15,c+0.5,0); svg.push(textEl(p[0]+4,p[1]+10,10,'start','#6f6e69',l)); });
+  function leanOut(x,y,wpx,anchor,dx,dy){
+    const n=Math.hypot(dx,dy), ux=dx/n, uy=dy/n;
+    let last=[x,y,leanBox(x,y,wpx,anchor),false];
+    for(let k=0;k<=LEAN_MAX/LEAN;k++){
+      const px=x+ux*k*LEAN, py=y+uy*k*LEAN;
+      const box=leanBox(px,py,wpx,anchor);
+      // never lean up past the section's own caption line: a name that
+      // escapes the bars by leaving the chart is not a fix.
+      if(box.y0<CEIL) break;
+      last=[px,py,box];
+      // 3 px of air, so "clear" reads as clear rather than as a name
+      // ruled off by the bar it is standing against.
+      const pad={x0:box.x0-3,x1:box.x1+3,y0:box.y0-2,y1:box.y1+2};
+      let hit=false;
+      for(const q of bars) if(chartQuadHitsBox(q,pad)){ hit=true; break; }
+      // an axis label already placed is ink too: the column captions of
+      // `telemetry-export` are 20 px apart in x and 10 px in y, so two long
+      // ones ("Rate (pps)", "Drops/min") overlap by a line's descender unless
+      // each leans clear of the last.
+      if(!hit) for(const o of laid)
+        if(pad.x0<o.x1&&pad.x1>o.x0&&pad.y0<o.y1&&pad.y1>o.y0){ hit=true; break; }
+      if(!hit) return [px,py,box,true];
+    }
+    return [last[0],last[1],last[2],false];
+  }
+  let overhang=0, farRight=-Infinity, farDown=-Infinity;
+  const placed=[], laid=[];
+  rLab.forEach((l,r)=>{
+    const p=PR(r+0.5,-0.15,0);
+    const [x,y,box,ok]=leanOut(p[0]-4,p[1]+10,rLabPx(l),'end',-W2,-H2);
+    placed.push([x,y,'end',l,ok]); laid.push(box);
+    overhang=Math.max(overhang,-box.x0); farRight=Math.max(farRight,box.x1); farDown=Math.max(farDown,box.y1);
+  });
+  cLab.forEach((l,c)=>{
+    const p=PR(R+0.15,c+0.5,0);
+    const [x,y,box,ok]=leanOut(p[0]+4,p[1]+10,rLabPx(l),'start',-W2,H2);
+    placed.push([x,y,'start',l,ok]); laid.push(box);
+    overhang=Math.max(overhang,-box.x0); farRight=Math.max(farRight,box.x1); farDown=Math.max(farDown,box.y1);
+  });
+  const ox=Math.max(R*W2+8, overhang+4);
+  for(const [poly,fill] of faces)
+    svg.push('<polygon points="'+poly.map(p=>(p[0]+ox)+','+p[1]).join(' ')+'" fill="'+fill+'"/>');
+  // THE HALO IS THE LAST RESORT, NOT THE HABIT. A label that found clear air
+  // is drawn plainly: `tools/layout-lint.js` tells an EDGE label from every
+  // other label by the halo twin (two <text> at one point), so haloing a chart
+  // axis caption enrols it in F5's denominator, and an axis whose denominator
+  // silently absorbs five non-edge labels is measuring something other than
+  // what it prints. Only a caption the lean could not clear keeps the halo,
+  // which is the one case where it is carrying the legibility.
+  for(const [x,y,anchor,l,ok] of placed)
+    lsvg.push(textEl(x+ox,y,10,anchor,'#6f6e69',l,ok?'':HALO));
+  // floor grid edges — drawn UNDER the bars, so it is spliced in ahead of them
+  const F=[PR(0,0,0),PR(R,0,0),PR(R,C,0),PR(0,C,0)];
+  svg.splice(1,0,'<polygon points="'+F.map(p=>(p[0]+ox)+','+p[1]).join(' ')+'" fill="#f6f5ef" stroke="#d6d4cc"/>');
   // z ruler at the right-back corner
-  const zr=P(0,C,0);
+  const zr=[PR(0,C,0)[0]+ox, PR(0,C,0)[1]];
   svg.push('<line x1="'+(zr[0]+14)+'" y1="'+zr[1]+'" x2="'+(zr[0]+14)+'" y2="'+(zr[1]-zmax*ZS)+'" stroke="#8a8880"/>');
   for(const z of [0, Math.round(zmax/2), Math.round(zmax)]){
     svg.push('<line x1="'+(zr[0]+11)+'" y1="'+(zr[1]-z*ZS)+'" x2="'+(zr[0]+17)+'" y2="'+(zr[1]-z*ZS)+'" stroke="#8a8880"/>');
     svg.push(textEl(zr[0]+21, zr[1]-z*ZS+3.5, 9.5, 'start', '#6f6e69', String(z)));
   }
-  const w=P(R,C,0)[0]+70, hgt=P(R,C,0)[1]+24-y0;
-  return {svg:svg.join(''), y:y0+hgt, w:w};
+  const near=[PR(R,C,0)[0]+ox, PR(R,C,0)[1]];
+  const w=Math.max(near[0]+70, farRight+ox+4);
+  const hgt=Math.max(near[1]+24, farDown+6)-y0;
+  return {svg:svg.join('')+lsvg.join(''), y:y0+hgt, w:w};
 }
 
 // ---- timing ----