umlimator 0.17.0 → 0.18.0

package/lib/umlimator-all.js

@@ -62,6 +62,7 @@ function typedProblems(model) {
   arr(m.edges).forEach((e, i) => { if (typedEdge(e)) { element(e, `edges[${i}]`, 'edge'); typeOf(e, `edges[${i}]`, true); } });
   const typedView = v => v.diagram != null && v.diagram !== 'map'; // a view with diagram 'map' is a map: the map's checks
   views.forEach((v, i) => { if (!typedView(v)) return;
+    arr(v.nodes).forEach((n, j) => element(n, `views[${i}].nodes[${j}]`, 'node'));
     arr(v.edges).forEach((e, j) => { if (isObj(e)) { element(e, `views[${i}].edges[${j}]`, 'edge'); typeOf(e, `views[${i}].edges[${j}]`, true); } });
     arr(v.fragments).forEach((f, j) => element(f, `views[${i}].fragments[${j}]`, 'fragment'));
     ['changes', 'constraints'].forEach(k => arr((v.timeline || {})[k]).forEach((c, j) => element(c, `views[${i}].timeline.${k}[${j}]`, 'time'))); });
@@ -85,17 +86,18 @@ function typedProblems(model) {
   views.forEach((v, i) => { if (!typedView(v)) return; const at = `views[${i}]`;
     if (typeof v.diagram !== 'string' || !/^[a-z0-9]+(\.[a-z0-9-]+)?$/.test(v.diagram)) warn(at + '.diagram', `diagram ${name(v.diagram)} is not <notation> or <notation>.<kind> (uml.class)`);
     if (v.direction != null && !['right', 'down'].includes(v.direction)) warn(at + '.direction', `direction ${name(v.direction)} is not right or down: drawn right`);
-    arr(v.nodeIds).forEach((id, j) => { if (!nodeIds.has(id)) err(`${at}.nodeIds[${j}]`, `${name(id)} is not a node`); });
-    const mine = new Set(arr(v.containers).map(c => isObj(c) && c.id));
-    arr(v.edges).forEach((e, j) => { if (typeof e === 'string') { if (kindOf.get(e) !== 'edge') err(`${at}.edges[${j}]`, `${name(e)} is not a typed edge`); } else if (isObj(e)) ends(e, `${at}.edges[${j}]`, mine); });
+    arr(v.nodeIds).forEach((id, j) => { if (!nodeIds.has(id) && !arr(v.nodes).some(n => isObj(n) && n.id === id)) err(`${at}.nodeIds[${j}]`, `${name(id)} is not a node`); });
+    const mine = new Set(arr(v.containers).map(c => isObj(c) && c.id)), T = diagramOf(v); // an item (the type's items; else no ends) is no line
+    const item = e => (T ? arr(T.items).includes(e.type) : e.from == null && e.to == null);
+    arr(v.edges).forEach((e, j) => { if (typeof e === 'string') { if (kindOf.get(e) !== 'edge') err(`${at}.edges[${j}]`, `${name(e)} is not a typed edge`); } else if (isObj(e) && !item(e)) ends(e, `${at}.edges[${j}]`, mine); });
     if (v.subject != null && !has(v.subject)) err(at + '.subject', `subject ${name(v.subject)} is not an element`);
     ['layout', 'present'].forEach(k => Object.keys(isObj(v[k]) ? v[k] : {}).forEach(id => { if (!has(id)) warn(`${at}.${k}.${id}`, `${name(id)} is not an element: ignored`); })); });
   return out;
 }
 /* ---------- diagram types (work package 1.3) ----------
    A typed view's `diagram` names its type; a view with none is a map, and the map registers itself as the default
-   (src/map/typed.js). A type this release does not know is drawn as plain cards, with a warning. Provisional: what a
-   definition holds is settled after the sequence spike (1.12), so the registry is not exported from the package yet. */
+   (src/map/typed.js). A type this release does not know is drawn as plain cards, with a warning. Internal until the
+   API is documented. */
 const TYPES = new Map();
 
 function registerDiagramType(name, def = {}) {
@@ -106,14 +108,18 @@ function registerDiagramType(name, def = {}) {
   return type;
 }
 
-/* A definition may hold, all optional and provisional (1.7's panels read them):
-     elements  [{ type, label }]          the palette: what a user can add to the view
-     lines     [{ type, label }]          the relationship picker: the kinds of line between two elements
-     props     { [type]: [{ key, label, kind: 'text' | 'bool' | 'enum', options? }] }   the properties form, per element type
-   Without them the canvas offers one generic node and one generic line (core.Node, core.Line), and shows an element's props to read. */
+/* A definition's fields are optional and provisional; absent, things go as before. notes/spike-sequence.md §1 says what
+   each does (validate(model) with no view runs once a type, not once a view); 1.9's: rankFlip, member, rules, describe. */
 
 /* A view's type: the map for a view with no diagram, the registered type, or null for one this release does not draw */
 const diagramOf = view => TYPES.get(view && view.diagram != null ? view.diagram : 'map') || null;
+
+/* What only a registered type's geometry uses, installed at load time by the files under src/typed/, which only
+   lib/umlimator-all.js holds (tools/build.mjs): rows, rooms and routes in layoutPass, a typed line's ends in svgOf. Empty in
+   umlimator.js, where no view is laid out but as a map (risks.md C5) */
+const TYPED = {};
+
+const propRefs = type => Object.assign({}, ...[...TYPES.values()].map(T => T.refs && Object.hasOwn(T.refs, type) && T.refs[type]));
 const warned = new Set(), warn = m => { if (hush) hush.push(m); else if (!warned.has(m)) { warned.add(m); console.warn('umlimator: ' + m); } }; // each warning once
 let hush = null; // a layout tried and maybe dropped (unfolding, #71) keeps its warnings here: only the one kept says them
 /* f(), with the warnings it gives held back: [its result, what it would have said] */
@@ -174,7 +180,8 @@ export function history(model, limit = 100) {
                                              value undefined removes it. Through objects only; id, members, parent,
                                              from and to change by their own commands
      add       { element, owner?, index?, view? }  a node (no from/to), a line, or with `owner` a member, at `index`
-                                             among the owner's members, else among the view's; `view` shows it there
+                                             among the owner's members, else among the view's; `view` shows it there;
+                                             in 'view' (not 'model'): in its edges, nodes or fragments (registry.js)
      move      { id, index, owner? }         a member to another place among its owner's members, or to a new owner
                { id, view, index }           an element or line to another place in a view's order (its nodeIds or edges)
      hide      { id, view }                  out of one view, with all the view says of it: its place, pin, present,
@@ -182,14 +189,16 @@ export function history(model, limit = 100) {
                                              keeps it (risks.md E5). A line that lives only in that view goes with it
      delete    { id }                        out of the model, with its members, what it owns, the lines to them, and
                                              every place that names them (references()). One already gone in the same
-                                             transaction is passed over, so a selection deletes in one transaction (E2)
+                                             transaction is passed over, so a selection deletes in one transaction (E2).
+                                             What it held and stays goes to its nearest owner left
      reparent  { id, parent }                a new owner by `parent`, or none with parent null
-   An element is a node, a member, a model line or a view's own line with an id, or a fragment (schema version 2's id
-   space). What a type's own properties name (props.replyTo, a timeline) is the type's to keep, from its stage. */
+   An element is a node, a member, a model line or a view's own line or item with an id, or a fragment (schema version 2's
+   id space). */
 
 const isObj = x => x !== null && typeof x === 'object' && !Array.isArray(x), arr = x => (Array.isArray(x) ? x : []);
 const UNSAFE = new Set(['__proto__', 'constructor', 'prototype']); // never a key a command writes (risks.md M3)
 const isLine = x => isObj(x) && (x.from != null || x.to != null);
+const dig = (x, path) => path.split('.').reduce((o, k) => (isObj(o) ? o[k] : undefined), x);
 
 /* Every element by id: { x, list, kind, owner, view } (owner: the element whose member it is; view: the view a line or
    fragment of its own lives in) */
@@ -206,7 +215,7 @@ function index(m) {
 }
 
 /* Where a model names any of `ids` (a Set): [{ path, kind }], path a list of keys from the model down. Kinds: end, parent,
-   part, view, pin, present, override, subject, story, lens, rule. Neither the element itself nor its members are listed.
+   part, prop, view, pin, present, override, subject, story, lens, rule. Neither the element itself nor its members are listed.
    only(viewIndex): look in those views and their story steps only (hide), else in all of the model. */
 function refs(m, ids, only) {
   const out = [], say = (path, kind) => out.push({ path, kind }), has = id => typeof id === 'string' && ids.has(id);
@@ -214,11 +223,14 @@ function refs(m, ids, only) {
     if (has(x.parent)) say([...at, 'parent'], 'parent');
     if (line) ['from', 'to'].forEach(k => { if (has(x[k])) say([...at, k], 'end');
       if (has((((x.props || {}).ends || {})[k] || {}).part)) say([...at, 'props', 'ends', k, 'part'], 'part'); });
+    Object.keys(propRefs(x.type)).forEach(p => { const v = dig(x, p), ks = p.split('.');
+      if (has(v)) say([...at, ...ks], 'prop'); else arr(v).forEach((id, j) => { if (has(id)) say([...at, ...ks, j], 'prop'); }); });
     arr(x.members).forEach((y, j) => element(y, [...at, 'members', j], false)); };
   if (!only) { arr(m.nodes).forEach((n, i) => element(n, ['nodes', i], false)); arr(m.edges).forEach((e, i) => element(e, ['edges', i], true)); }
   const vids = new Set();
   arr(m.views).forEach((v, i) => { if (!isObj(v) || (only && !only(i))) return; const at = ['views', i]; vids.add(v.id);
     ['nodeIds', 'tour', 'stepIds'].forEach(k => arr(v[k]).forEach((id, j) => { if (has(id)) say([...at, k, j], 'view'); }));
+    arr(v.nodes).forEach((n, j) => element(n, [...at, 'nodes', j], false));
     arr(v.edges).forEach((e, j) => { if (has(e)) say([...at, 'edges', j], 'view'); else element(e, [...at, 'edges', j], true); });
     arr(v.fragments).forEach((f, j) => element(f, [...at, 'fragments', j], false));
     [['layout', 'pin'], ['present', 'present'], ['nodeOverrides', 'override']].forEach(([k, kind]) => Object.keys(isObj(v[k]) ? v[k] : {}).forEach(id => { if (has(id)) say([...at, k, id], kind); }));
@@ -296,8 +308,18 @@ function run(m, c, gone) {
     }
     case 'add': {
       if ('to' in c) throw new Error('add: the owner of a member is `owner`');
+      if (c.in != null && c.in !== 'view' && c.in !== 'model') throw new Error(`add: in is 'view' or 'model', not ${JSON.stringify(c.in)}`);
       checkNew(c.element, at);
       const x = structuredClone(c.element), owner = c.owner != null ? need(c.owner) : null;
+      if (c.in === 'view') {
+        if (c.view == null || owner) throw new Error('add: in \'view\' needs a view, and no owner');
+        const v = viewOf(c.view), T = diagramOf(v) || {}, pal = arr(T.elements);
+        const k = isLine(x) || arr(T.items).includes(x.type) ? 'edges' : !pal.length || pal.some(t => isObj(t) && t.type === x.type) ? 'nodes' : 'fragments';
+        if (k === 'edges' && !Array.isArray(v.edges) && arr(m.edges).length) throw new Error(`add: view "${c.view}" shows every line between its cards; list its lines first`);
+        const list = (v[k] ||= []);
+        if (k === 'nodes') { list.push(x); (v.nodeIds ||= []).splice(place(v.nodeIds, c.index), 0, x.id); } else list.splice(place(list, c.index), 0, x);
+        return;
+      }
       if (owner && owner.kind !== 'node' && owner.kind !== 'member' && owner.kind !== 'fragment') throw new Error(`add: "${c.owner}" holds no members`);
       const v = c.view != null ? viewOf(c.view) : null, list = owner ? (owner.x.members ||= []) : isLine(x) ? (m.edges ||= []) : (m.nodes ||= []);
       list.splice(owner ? place(list, c.index) : list.length, 0, x);
@@ -327,19 +349,24 @@ function run(m, c, gone) {
       const ends = l => isObj(l) && (ids.has(l.from) || ids.has(l.to)); // the view's lines to it, listed or its own, leave the view with it
       if (Array.isArray(v.edges)) v.edges = v.edges.filter(y => { const l = typeof y === 'string' ? (at.get(y) || {}).x : y, out = y === c.id || ends(l);
         if (out && isObj(l) && typeof l.id === 'string') ids.add(l.id); return !out; }); // what names those lines in this view goes too
-      clear(m, refs(m, ids, i => i === vi).filter(r => r.kind !== 'end' && r.kind !== 'parent' && r.kind !== 'part'));
+      clear(m, refs(m, ids, i => i === vi).filter(r => !['end', 'parent', 'part', 'prop'].includes(r.kind)));
       return;
     }
     case 'delete': {
       if (!at.has(c.id) && gone.has(c.id)) return; // gone with an earlier command of this transaction
-      need(c.id); const now = new Set();
+      need(c.id); const now = new Set(), kids = new Map();
+      for (const [k, o] of at) if ((o.kind === 'node' || o.kind === 'member') && o.x.parent != null) { if (!kids.has(o.x.parent)) kids.set(o.x.parent, []); kids.get(o.x.parent).push(k); }
       const take = id => { const r = at.get(id); if (!r || now.has(id)) return; now.add(id);
-        arr(r.x.members).forEach(y => isObj(y) && take(y.id));
-        for (const [k, o] of at) if ((o.kind === 'node' || o.kind === 'member') && o.x.parent === id) take(k); }; // what it owns goes with it
+        arr(r.x.members).forEach(y => isObj(y) && take(y.id)); arr(kids.get(id)).forEach(take); }; // what it owns goes with it
       take(c.id);
-      // lines to what is gone go too, and lines to those lines; a line whose parent goes (a message in a deleted operand)
-      // stays, outside it
-      for (let more = true; more;) { more = false; for (const [k, o] of at) if (!now.has(k) && o.kind === 'edge' && (now.has(o.x.from) || now.has(o.x.to))) { now.add(k); more = true; } }
+      // lines to what is gone go too, lines to those lines, and what a type's refs cascade (a reply with its call)
+      const cascade = x => Object.entries(propRefs(x.type)).some(([p, how]) => how === 'cascade' && [].concat(dig(x, p)).some(id => now.has(id)));
+      for (let more = true; more;) { more = false; for (const [k, o] of at) if (!now.has(k) && (o.kind === 'edge' && (now.has(o.x.from) || now.has(o.x.to)) || cascade(o.x))) { take(k); more = true; } }
+      // what stays in something gone goes to its nearest owner left; an operand's messages to its fragment's parent
+      const above = id => { const r = at.get(id); return r && (r.x.parent ?? (r.owner && above(r.owner.id))); };
+      for (const [k, o] of at) if (!now.has(k) && now.has(o.x.parent)) { let p = o.x.parent;
+        for (let n = 0; p != null && now.has(p) && n++ < at.size;) p = above(p);
+        if (p != null && !now.has(p)) o.x.parent = p; else delete o.x.parent; }
       for (const [k, o] of at) if (now.has(k) && !(o.owner && now.has(o.owner.id))) { const i = o.list.indexOf(o.x); if (i >= 0) o.list.splice(i, 1); }
       for (let found = refs(m, now); found.length; found = refs(m, now)) clear(m, found); // a line without an id to a gone line goes in a second round
       now.forEach(id => gone.add(id));
@@ -480,60 +507,10 @@ const SHAPE = {
       return `<path d="M${x + 1} ${y + p}L${x + p} ${y + 1}H${x + w - 1}L${x + w - p} ${y + p}Z" fill="${deeper(k, 12)}"/><path d="M${x + w - p} ${y + p}L${x + w - 1} ${y + 1}V${y + h - p}L${x + w - p} ${y + h - 1}Z" fill="${deeper(k, 22)}"/>`
         + `<path d="M${x} ${y + p}H${x + w - p}V${y + h}" class="n-det n-accent" stroke="${c}"/><path d="M${x + w - p} ${y + p}L${x + w} ${y}" class="n-det" stroke="${c}"/>`; },
     inset(n, s, t) { const p = 7; return s === 'L' ? Math.max(0, n.y + p - t) : s === 'R' ? Math.max(0, t - n.y - n.h + p) : s === 'T' ? Math.max(0, n.x + p - t) : Math.max(0, t - n.x - n.w + p); } },
-  classifier: { // UML's class box (1.5): a rectangle, its name compartment, then one compartment per member kind (classParts)
-    size: n => classParts(n).size, out: boxOut(0), face: n => [n.y, n.y + n.h], inset: () => 0, draw: classSvg },
 };
-// what every shape reports (1.5): size(n), the box layout gives it (a map's card: mapNodeW wide, a row high; the classifier:
-// from its text), and ports(n, side, k), k line ends spread evenly along a side ('L', 'R', 'T', 'B'), each on the outline
+// what every shape reports (1.5): size(n), the box layout gives it (a map's card: mapNodeW wide, a row high; the classifier,
+// src/typed/draw.js: from its text), and ports(n, side, k), k line ends spread evenly along a side ('L', 'R', 'T', 'B'), each on the outline
 for (const S of Object.values(SHAPE)) { S.size ||= n => ({ w: mapNodeW(n), h: 64 }); S.ports = (n, side, k = 1) => portsOn(S, n, side, k); }
-// ---- the classifier (1.5). Its drawing input, on a typed view's node (not the model: 1.9 fills it from the model and the
-// view's present; a map never draws it): shape 'classifier'; label; type ('uml.Class', named in its accessible name);
-// stereotypes [text], shown «…» over the name; abstract (the name in italics); compartments [{ name, members }] in order
-// ('attributes', 'operations', 'literals'), each member in the model's envelope ({ type, label, props }); collapsed
-// [compartment names], hidden with no divider; rows: at most that many rows in a compartment, then "+k more" (stage 1 note §5)
-const CL = { pad: 8, name: 13, row: 11, st: 14, nl: 18, rl: 15, gap: 5, empty: 10, minW: 96, maxW: 320 };
-const VIS = { public: '+', private: '-', protected: '#', package: '~' };
-// a member's row in UML's form: "+ total: Money [1]", "+ /count: Integer = 0", "+ place(at: Date): Order"; a literal's label
-const obj = x => !!x && typeof x === 'object'; // an entry the classifier reads; null, text or a number is passed over
-function memberText(m) { const p = obj(m.props) ? m.props : {}, has = x => x != null && x !== '', name = (hasKey(VIS, p.visibility) ? VIS[p.visibility] + ' ' : '') + (p.isDerived ? '/' : '') + (m.label ?? '');
-  if (/Operation$/.test(m.type || '')) return name + '(' + (Array.isArray(p.parameters) ? p.parameters.filter(obj) : []).map(a => (has(a.direction) && a.direction !== 'in' ? a.direction + ' ' : '') + (a.name ?? '') + (has(a.valueType) ? ': ' + a.valueType : '')).join(', ') + ')' + (has(p.returnType) ? ': ' + p.returnType : '');
-  return name + (has(p.valueType) ? ': ' + p.valueType : '') + (has(p.multiplicity) ? ` [${p.multiplicity}]` : '') + (has(p.default) ? ' = ' + p.default : ''); }
-// the classifier as drawn: its stereotypes, its compartments (all: every one, each with every member; comps: those shown,
-// with their rows and how many they leave out), the head's height, and the size its text needs: as wide as its widest text,
-// within minW and maxW (a longer row is cut: classSvg). An abstract name is in italics, which the measure (upright) does
-// not see: it is measured a tenth wider (slant)
-function classParts(n) {
-  const hidden = new Set(Array.isArray(n.collapsed) ? n.collapsed : []), cap = Number.isFinite(n.rows) ? Math.max(0, Math.floor(n.rows)) : Infinity, slant = n.abstract ? 1.1 : 1;
-  const stereo = (Array.isArray(n.stereotypes) ? n.stereotypes : []).filter(t => t != null && t !== '').map(String), st = stereo.map(t => `«${t}»`);
-  const all = (Array.isArray(n.compartments) ? n.compartments : []).filter(obj).map(c => ({ name: String(c.name ?? ''), members: Array.isArray(c.members) ? c.members.filter(obj) : [] }));
-  const comps = all.filter(c => !hidden.has(c.name)).map(c => ({ name: c.name, rows: c.members.slice(0, cap).map(m => ({ m, text: memberText(m) })), more: Math.max(0, c.members.length - cap) }));
-  const texts = [[n.label ?? '', CL.name, slant], ...st.map(t => [t, CL.row, 1]), ...comps.flatMap(c => [...c.rows.map(r => [r.text, CL.row, 1]), ...(c.more ? [[`+${c.more} more`, CL.row, 1]] : [])])];
-  const w = Math.ceil(Math.min(CL.maxW, Math.max(CL.minW, ...texts.map(([t, px, k]) => textW(t, px) * k + 2 * CL.pad))));
-  const head = 2 * CL.gap + st.length * CL.st + CL.nl, tall = c => { const k = c.rows.length + (c.more ? 1 : 0); return k ? 2 * CL.gap - 2 + k * CL.rl : CL.empty; };
-  return { stereo, st, all, comps, head, tall, slant, size: { w, h: comps.reduce((a, c) => a + tall(c), head) } };
-}
-const words = t => String(t).split('.').pop().replace(/([a-z])([A-Z])/g, (_, a, b) => a + ' ' + b.toLowerCase()); // 'uml.DataType': "Data type"
-function classSvg(n, c, f) { // its outline, its head, then each compartment under a divider, every text cut to the box (fit)
-  const { stereo, st, all, comps, head, tall, slant } = classParts(n), { x, y, w, h } = n, max = w - 2 * CL.pad, cx = r2(x + w / 2);
-  const font = (px, wt, it) => `style="font:${it ? 'italic ' : ''}${wt} ${px}px var(--um-sans)"`;
-  const row = (cls, fill, ty, t, more = '') => `<text x="${r2(x + CL.pad)}" y="${r2(ty)}" class="${cls}" fill="${fill}"${more}>${esc(fit(t, CL.row, max))}</text>`;
-  const out = [`<rect x="${x}" y="${y}" width="${w}" height="${h}" class="n-mask"/><rect x="${x}" y="${y}" width="${w}" height="${h}" class="n-body" fill="${f}" stroke="${c}"/>`];
-  let ty = y + CL.gap; const hd = [];
-  st.forEach(t => { hd.push(`<text x="${cx}" y="${r2(ty + 11)}" text-anchor="middle" class="c-st" fill="var(--um-muted)" ${font(CL.row, 400)}>${esc(fit(t, CL.row, max))}</text>`); ty += CL.st; });
-  hd.push(`<text x="${cx}" y="${r2(ty + 14)}" text-anchor="middle" class="c-name" fill="var(--um-text)" ${font(CL.name, 600, n.abstract)} data-o="${esc(n.id)}">${esc(fit(n.label ?? '', CL.name, max / slant))}</text>`);
-  out.push(`<g class="c-head" data-band="${r2(y)} ${r2(y + head)}">${hd.join('')}</g>`);
-  let top = y + head;
-  comps.forEach((C, i) => { const bh = i === comps.length - 1 ? Math.max(y + h - top, 0) : tall(C), at = j => top + CL.gap - 1 + j * CL.rl + 11.5;
-    const rows = C.rows.map((r, j) => { const p = obj(r.m.props) ? r.m.props : {};
-      return row('c-row', 'var(--um-text)', at(j), r.text, ` ${font(CL.row, 400, /Operation$/.test(r.m.type || '') && p.isAbstract)}${p.isStatic ? ' text-decoration="underline"' : ''}`); });
-    if (C.more) rows.push(row('c-more', 'var(--um-muted)', at(C.rows.length), `+${C.more} more`, ` ${font(CL.row, 400)}`));
-    out.push(`<g class="c-comp" data-comp="${esc(C.name)}" data-band="${r2(top)} ${r2(top + bh)}"><path d="M${x} ${r2(top)}H${x + w}" class="n-det" stroke="${c}"/>${rows.join('')}</g>`);
-    top += bh; });
-  // its accessible name (A1): "Class Order (entity, abstract), 2 attributes, 1 operation", every member counted, shown or not
-  const counts = all.map(C => `${C.members.length} ${C.members.length === 1 ? C.name.replace(/s$/, '') : C.name}`), why = [...stereo, ...(n.abstract ? ['abstract'] : [])];
-  const name = [`${words(n.type || 'uml.Class')} ${n.label ?? ''}${why.length ? ` (${why.join(', ')})` : ''}`, ...counts].join(', ');
-  return `<g class="node classifier" data-id="${esc(n.id)}" data-shape="classifier" tabindex="-1" role="img" aria-label="${esc(name)}">${out.join('')}</g>`;
-}
 const SHAPE_NAMES = ['box', 'person', 'browser', 'mobile', 'cylinder', 'pipe', 'document', 'hexagon', 'robot', 'terminal', 'window', 'folder', 'node']; // all 13
 // a card's shape in a notation: its own `shape` first; box draws every card as before (a hook stays a hexagon there too)
 const shapeOf = (n, notation) => { const sh = String(n.shape ?? '').toLowerCase(); if (SHAPE_NAMES.includes(sh)) return sh;
@@ -611,51 +588,21 @@ function roundPath(pts, r = 9) {
   }
   const last = pts[pts.length - 1]; return d + ` L ${last[0]} ${last[1]}`;
 }
-
-// a typed line's end labels (1.5): each end's role and multiplicity (e.end.labels: { from: { role, mult }, to: { role, mult } }),
-// each in a box reserved by its end. First choice: 4 px out from the outline along the line, 8 px to one side of it, clear of
-// the end's marker; the role above a line that leaves sideways and left of one that leaves up or down, the multiplicity on
-// the other side. A box that would meet a segment of its own line (7.5 px round it, so markers too), either end's node or
-// a box placed before it moves away from the line, 4 px at a time, on its side and then the other, at the end or centred
-// across it (a short end segment, a loop). pts: the line as drawn; e.s and e.t: its nodes. Layout (1.4) may take the boxes
-// as obstacles; it moves them apart where many lines meet (L5)
-function endLabels(e, pts = e.pts) {
-  const T = e.end && e.end.labels, out = []; if (!T || !pts || pts.length < 2) return out;
-  const meets = (a, b) => a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
-  const keep = [...pts.slice(1).map((q, i) => { const p = pts[i]; return { x: Math.min(p[0], q[0]) - 7.5, y: Math.min(p[1], q[1]) - 7.5, w: Math.abs(q[0] - p[0]) + 15, h: Math.abs(q[1] - p[1]) + 15 }; }),
-    ...[e.s, e.t].filter(n => n && Number.isFinite(n.x)).map(n => ({ x: n.x - 2, y: n.y - 2, w: n.w + 4, h: n.h + 4 }))];
-  [['from', pts[0], pts[1]], ['to', pts[pts.length - 1], pts[pts.length - 2]]].forEach(([end, p, q]) => {
-    const at = T[end] || {}, flat = Math.abs(q[0] - p[0]) >= Math.abs(q[1] - p[1]), dir = Math.sign(flat ? q[0] - p[0] : q[1] - p[1]) || 1;
-    [['role', at.role, -1], ['mult', at.mult, 1]].forEach(([kind, t, side]) => { if (t == null || t === '') return;
-      const w = r2(textW(t, 10) + 6), h = 14, along = (v, d, mid) => mid ? v - d / 2 : dir > 0 ? v + 4 : v - 4 - d, aside = (v, d, s, o) => s < 0 ? v - o - d : v + o;
-      const box = (o, s, mid) => ({ end, kind, text: String(t), x: r2(flat ? along(p[0], w, mid) : aside(p[0], w, s, o)), y: r2(flat ? aside(p[1], h, s, o) : along(p[1], h, mid)), w, h });
-      let b = null;
-      for (let o = 8; !b && o <= 400; o += 4) for (const s of [side, -side]) for (const mid of [false, true]) { const c = box(o, s, mid); if (!b && ![...keep, ...out].some(k => meets(c, k))) b = c; }
-      out.push(b || box(8, side, false)); }); });
-  return out;
-}
 let svgSeq = 0;
-// A typed view's line (1.5; a map's lines never read it) says how it is drawn in e.end: { from, to, dashed, labels }. from
-// and to name an end in this table, the line's ends as UML draws them (none, or a name it does not hold, draws no marker);
-// dashed: a dependency's or realization's line; labels: each end's role and multiplicity (endLabels). Each end: [its
-// length, half its height, its path pointing right with the tip at its length, its fill]. Its tip is where the line ends,
-// on the node's outline. Hollow is the stage's background, filled the line's own colour (T2), in either theme
-const ENDS = { none: null, arrow: [10, 4, 'M0 0L10 4L0 8Z', 'line'], open: [10, 5, 'M0 0L10 5L0 10', 'none'], triangle: [13, 7, 'M0 0L13 7L0 14Z', 'hollow'],
-  diamond: [16, 6, 'M0 6L8 0L16 6L8 12Z', 'hollow'], 'filled-diamond': [16, 6, 'M0 6L8 0L16 6L8 12Z', 'line'] };
-const endOf = (E, w) => hasKey(ENDS, E[w]) && ENDS[E[w]] ? E[w] : null;
-/* SVG markup. opts: { childCount(id) -> n, subject: id, title } */
+/* SVG markup. opts: { childCount(id) -> n, subject: id, title, under, over } */
 function svgOf(geo, opts = {}) {
   const id = 'g' + (svgSeq++), { nodes, edges, groups, bounds: B, map } = geo;
+  const LINE = map ? 'var(--um-arrow)' : 'var(--um-muted)'; // a typed view's lines: 3:1 or more in both themes
   const col = k => `var(--um-${KIND[k][0]})`, fill = k => `var(--um-${KIND[k][0]}-f)`;
   const estyle = e => {
-    if (e.style === 'faded') return { ...(map && e.wk ? { c: `var(--um-w-${e.wk})`, m: e.wk, cls: ' w-' + e.wk + ' faded' } : { c: 'var(--um-arrow)', m: 'd', cls: ' faded' }), dash: '', op: .35 }; // its own colour, faint, no flow (drift's idle lines)
+    if (e.style === 'faded') return { ...(map && e.wk ? { c: `var(--um-w-${e.wk})`, m: e.wk, cls: ' w-' + e.wk + ' faded' } : { c: LINE, m: 'd', cls: ' faded' }), dash: '', op: .35 }; // its own colour, faint, no flow (drift's idle lines)
     if (map && e.wk && !e.style) return { c: `var(--um-w-${e.wk})`, m: e.wk, dash: e.back ? '6 5' : '', cls: ' w-' + e.wk + (e.back ? ' back' : '') };
     const st = e.style || (e.change === 'added' ? 'added' : e.change === 'removed' ? 'removed' : '');
     if (st === 'added' || st === 'emphasis') return { c: 'var(--um-green)', m: 'g', dash: '', flow: st === 'added' || e.animate };
     if (st === 'removed') return { c: 'var(--um-rose)', m: 'r', dash: '5 5', op: .7 };
     if (st === 'security') return { c: 'var(--um-rose)', m: 'r', dash: '5 5' };
     if (st === 'dashed' || st === 'async') return { c: 'var(--um-violet)', m: 'v', dash: '4 4' };
-    return { c: 'var(--um-arrow)', m: 'd', dash: '' };
+    return { c: LINE, m: 'd', dash: '' };
   };
   // a line that breaks a rule (#70): rose, with a "!" just after its start that names the rule (opts.broken: rule titles by edge id)
   const broke = e => opts.broken ? [...new Set((e.all || [e]).flatMap(x => opts.broken[x._id] || []))] : [];
@@ -663,11 +610,8 @@ function svgOf(geo, opts = {}) {
   const ruleMark = (e, why) => { const [a, b] = e.pts, L = Math.abs(b[0] - a[0]) + Math.abs(b[1] - a[1]) || 1, t = Math.min(18, L / 2) / L, x = a[0] + (b[0] - a[0]) * t, y = a[1] + (b[1] - a[1]) * t;
     return `<g class="rule-mark"><title>Breaks rule: ${esc(why.join('; '))}</title><circle cx="${x}" cy="${y}" r="6.5"/><text x="${x}" y="${y + 3.4}" text-anchor="middle">!</text></g>`; };
   const marker = (n, c, k = 1) => `<marker id="${id}-${n}" markerWidth="${10 * k}" markerHeight="${8 * k}" refX="${9 * k}" refY="${4 * k}" orient="auto-start-reverse" markerUnits="userSpaceOnUse"><path d="M0 0 L${10 * k} ${4 * k} L0 ${8 * k} Z" fill="${c}"/></marker>`;
-  const MC = { d: 'var(--um-arrow)', g: 'var(--um-green)', r: 'var(--um-rose)', v: 'var(--um-violet)', h: 'var(--um-cyan)', ...Object.fromEntries(WIRES.map(w => [w[0], `var(--um-w-${w[0]})`])) };
+  const MC = { d: LINE, g: 'var(--um-green)', r: 'var(--um-rose)', v: 'var(--um-violet)', h: 'var(--um-cyan)', ...Object.fromEntries(WIRES.map(w => [w[0], `var(--um-w-${w[0]})`])) };
   const heavy = [...new Set(edges.filter(e => e.weight > 1).map(e => lstyle(e).m + '-w' + e.weight))]; // a heavier line's arrowhead grows with it
-  const typed = e => !map && e.end ? e.end : null, ends = [...new Set(edges.flatMap(e => typed(e) ? ['from', 'to'].map(w => endOf(e.end, w)).filter(Boolean).map(k => k + '-' + lstyle(e).m) : []))];
-  const endMark = km => { const k = km.slice(0, km.lastIndexOf('-')), m = km.slice(k.length + 1), [L, H, p, fl] = ENDS[k];
-    return `<marker id="${id}-${km}" markerWidth="${L}" markerHeight="${2 * H}" refX="${L}" refY="${H}" orient="auto-start-reverse" markerUnits="userSpaceOnUse" overflow="visible"><path d="${p}" fill="${fl === 'line' ? MC[m] : fl === 'hollow' ? 'var(--um-stage-bg)' : 'none'}" stroke="${MC[m]}" stroke-width="1.5" stroke-linejoin="round" stroke-linecap="round"/></marker>`; };
   // the notation (0.15.0): each card's look, and each line as drawn, its ends on the cards' outlines (a map's cards only)
   const notation = map ? noteOf(opts.shapes) || 'box' : 'box', kidsOf = n => n.kids != null ? n.kids : opts.childCount ? opts.childCount(n.id) : 0;
   // another view's node is drawn in its own shape, when it names one (1.5): its lines end where its ports() put them, on
@@ -675,8 +619,9 @@ function svgOf(geo, opts = {}) {
   const ports = map ? sidePorts(geo) : null, looks = new Map(map ? nodes.map(n => [n, cardLook(n, notation, !!(kidsOf(n) || n.opens) && opts.openHint !== false, ports.get(n))])
     : nodes.map(n => [n, n.shape != null && cardLook(n, 'box', false, null)]).filter(x => x[1]));
   const drawn = edges.map(e => map && looks.size ? drawnPts(e, n => looks.get(n) || null) : e.pts);
+  const T = !map && TYPED.lines ? TYPED.lines({ id, edges, drawn, lstyle, MC }) : null; // a typed view's line ends and end labels (src/typed/draw.js)
   let s = `<svg viewBox="${B.x} ${B.y} ${B.w} ${B.h}" data-w="${B.w}" data-h="${B.h}" role="${map ? 'group' : 'img'}" aria-label="${esc(opts.title || 'Diagram')}" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid meet">
-    <defs>${marker('d', 'var(--um-arrow)')}${marker('g', 'var(--um-green)')}${marker('r', 'var(--um-rose)')}${marker('v', 'var(--um-violet)')}${marker('h', 'var(--um-cyan)')}${map ? WIRES.map(w => marker(w[0], `var(--um-w-${w[0]})`)).join('') : ''}${heavy.map(m => { const [c, k] = m.split('-w'); return marker(m, MC[c], 1 + (k - 1) * .35); }).join('')}${ends.map(endMark).join('')}</defs>`;
+    <defs>${marker('d', LINE)}${marker('g', 'var(--um-green)')}${marker('r', 'var(--um-rose)')}${marker('v', 'var(--um-violet)')}${marker('h', 'var(--um-cyan)')}${map ? WIRES.map(w => marker(w[0], `var(--um-w-${w[0]})`)).join('') : ''}${heavy.map(m => { const [c, k] = m.split('-w'); return marker(m, MC[c], 1 + (k - 1) * .35); }).join('')}${T ? T.defs : ''}</defs>`;
   const families = geo.families || [], familyDepth = f => f.parent ? 1 + familyDepth(families.find(p => p.id === f.parent) || {}) : 0;
   families.slice().sort((a,b) => familyDepth(a)-familyDepth(b)).forEach(f => { // in c4 every box is a boundary, dashed as Structurizr draws one (a toned box is dashed in any notation)
     s += `<g class="family${f.tone ? ' toned' : ''}" data-family="${esc(f.id)}"${f.parent ? ` data-parent="${esc(f.parent)}"` : ''}${f.tone ? ` style="--um-tone:${toneOf(f)}"` : ''}><rect class="family-box" x="${f.x}" y="${f.y}" width="${f.w}" height="${f.h}" rx="14" stroke="var(--um-${familyDepth(f) ? 'cyan' : 'border-2'})"${notation === 'c4' ? ' stroke-dasharray="7 5"' : ''}/>
@@ -712,7 +657,7 @@ function svgOf(geo, opts = {}) {
     return { d: roundPath(P), legs, at };
   })() : null;
   const tourAnim = (vals, times) => `<animate attributeName="opacity" values="${vals}" keyTimes="${times.map(f2).join(';')}" dur="${TOUR}s" repeatCount="indefinite"/>`;
-  s += '<g class="edges">';
+  s += (opts.under || '') + '<g class="edges">'; // a type's layers (registry.js draw)
   (geo.intake || []).forEach(b => {
     const bp = roundPath(looks.size ? drawnPts({ pts: b.pts, t: geo.byId[b.to], ts: 'L' }, n => looks.get(n) || null) : b.pts); // its end on the card's outline, as a line's
     s += `<g class="intake"><title>${esc(b.label)} feeds ${esc((geo.byId[b.to] || {}).label || b.to)}</title><path d="${bp}" class="edge" stroke="var(--um-w-feeds)" marker-end="url(#${id}-feeds)"/>
@@ -721,10 +666,9 @@ function svgOf(geo, opts = {}) {
       ${tour ? `<circle r="3.2" class="tour tour-packet" opacity="0"><animateMotion path="${bp}" keyPoints="0;0;1" keyTimes="0;.86;1" calcMode="linear" dur="${TOUR}s" repeatCount="indefinite"/>${tourAnim('0;0;.8;.8;0', [0, .86, .88, .99, 1])}</circle>` : ''}</g>`;
   });
   edges.forEach((e, i) => {
-    const E = typed(e), st = E && E.dashed ? { ...lstyle(e), dash: '6 4' } : lstyle(e), why = broke(e), d = roundPath(drawn[i]), mk = st.m + (e.weight > 1 ? '-w' + e.weight : '');
-    const cut = w => endOf(E, w) ? ENDS[endOf(E, w)][0] : 0, at = w => endOf(E, w) ? `url(#${id}-${endOf(E, w)}-${st.m})` : '';
-    const tip = 9 * (e.weight > 1 ? 1 + (e.weight - 1) * .35 : 1), fd = roundPath(E ? trimLine(drawn[i], cut('from'), cut('to')) : trimLine(drawn[i], e.both ? tip : 0, tip)); // an arrowhead's length (marker refX)
-    const marks = E ? `${at('to') ? `marker-end="${at('to')}"` : ''} ${at('from') ? `marker-start="${at('from')}"` : ''}` : `marker-end="url(#${id}-${mk})" ${e.both ? `marker-start="url(#${id}-${mk})"` : ''}`;
+    const E = T && T.edge(e, i), st = E ? E.st : lstyle(e), why = broke(e), d = roundPath(drawn[i]), mk = st.m + (e.weight > 1 ? '-w' + e.weight : '');
+    const tip = 9 * (e.weight > 1 ? 1 + (e.weight - 1) * .35 : 1), fd = roundPath(E ? E.pts : trimLine(drawn[i], e.both ? tip : 0, tip)); // an arrowhead's length (marker refX)
+    const marks = E ? E.marks : `marker-end="url(#${id}-${mk})" ${e.both ? `marker-start="url(#${id}-${mk})"` : ''}`;
     if (tour && tour.legs[i]) { const [a, b] = tour.legs[i];
       s += `<path d="${d}" class="tour-glow" stroke="${st.c}" opacity="0">${tourAnim('0;0;.55;.55;0;0', [0, a, Math.min(a + .01, b), b, b + .03, 1])}</path>`; }
     s += `<g class="edge-g${st.cls || ''}${e.weight > 1 ? ' wt-' + e.weight : ''}" data-from="${esc(e.from)}" data-to="${esc(e.to)}" data-i="${i}"><path d="${d}" class="halo"/><path d="${d}" class="hitline"/>
@@ -732,13 +676,13 @@ function svgOf(geo, opts = {}) {
       <path d="${fd}" class="flowline" stroke="${st.c}"/>${(e.all || [e]).some(x => x.edited) && !e.strong ? (() => { let m = [e.pts[0], e.pts[1]];
         e.pts.slice(1).forEach((p, k) => { const a = e.pts[k]; if (Math.abs(p[0] - a[0]) + Math.abs(p[1] - a[1]) > Math.abs(m[1][0] - m[0][0]) + Math.abs(m[1][1] - m[0][1])) m = [a, p]; });
         return `<circle cx="${(m[0][0] + m[1][0]) / 2}" cy="${(m[0][1] + m[1][1]) / 2}" r="4" class="edited-dot"><title>Edited</title></circle>`; })() : ''}${why.length ? ruleMark(e, why) : ''}
-      <title>${e.step != null ? 'Step ' + esc(e.step) + ': ' : ''}${esc(e.s.label)} ${e.both ? '⇄' : '→'} ${esc(e.t.label)}${e.label ? ': ' + esc(e.label) : ''}${e.label && e.sublabel ? ' (' + esc(e.sublabel) + ')' : ''}${e.when ? '\n' + esc(e.when) : ''}${why.length ? '\nBreaks rule: ' + esc(why.join('; ')) : ''}</title></g>`;
+      <title>${!map && e.aria != null ? esc(e.aria) : `${e.step != null ? 'Step ' + esc(e.step) + ': ' : ''}${esc(e.s.label)} ${e.both ? '⇄' : '→'} ${esc(e.t.label)}${e.label ? ': ' + esc(e.label) : ''}`}${e.label && e.sublabel ? ' (' + esc(e.sublabel) + ')' : ''}${e.when ? '\n' + esc(e.when) : ''}${why.length ? '\nBreaks rule: ' + esc(why.join('; ')) : ''}</title></g>`;
   });
   // the tour's dot rides over the lines and boxes but under the cards: it goes into a card and comes out at its next
   // line, rather than across the card's name
   s += '</g>' + (tour ? `<g class="tour" aria-hidden="true"><circle r="5.5" class="tour-dot"><animateMotion path="${tour.d}" dur="${TOUR}s" repeatCount="indefinite"/></circle></g>` : '') + '<g class="nodes">';
   nodes.forEach(n => {
-    if (!map && n.shape === 'classifier') { s += SHAPE.classifier.draw(n, col(n.k), fill(n.k)); return; } // a typed view's class box (1.5)
+    if (!map && hasKey(SHAPE, n.shape) && SHAPE[n.shape].draw) { s += SHAPE[n.shape].draw(n, col(n.k), fill(n.k)); return; } // a typed view's own shape: a class box (1.5), a note (1.9)
     const c = col(n.k), f = fill(n.k), removed = n.change === 'removed', planned = n.change === 'planned';
     const L = looks.get(n) || null, S = L && L.S; // a shaped card (0.15.0); null: a box, drawn as before
     const pub = map && n.k === 'm-public', priv = map && n.k === 'm-script', ext = map && n.k === 'm-ext', verb = map && n.k === 'm-verb', hook = map && n.k === 'm-hook' && String(n.shape ?? '').toLowerCase() !== 'box';
@@ -851,9 +795,9 @@ return I && I.src ? `<rect x="${x - M * 3 / 28}" y="${y - M * 3 / 28}" width="${
       const name = `${e.step != null ? `Step ${e.step}: ` : ''}Line ${e.both ? `between ${e.s.label} and ${e.t.label}, both ways` : `from ${e.s.label} to ${e.t.label}`}${said}${broke(e).length ? `, breaks rule ${broke(e).join('; ')}` : ''}`;
       s += `<g class="um-key line-key${e.weight > 1 ? ' wt-' + e.weight : ''}" data-i="${i}" tabindex="0" role="button" aria-pressed="false" aria-label="${esc(name)}"><path d="${roundPath(drawn[i])}" class="key-ring"/></g>`; });
   }
-  s += '</g><g class="labels depth-read">';
+  s += '</g>' + (opts.over || '') + '<g class="labels depth-read">';
   edges.forEach((e, i) => {
-    if (typed(e)) s += endLabels(e, drawn[i]).map(b => `<text x="${r2(b.x + b.w / 2)}" y="${r2(b.y + 10.5)}" text-anchor="middle" class="end-lab" data-i="${i}" data-end="${b.end}" data-box="${b.x} ${b.y} ${b.w} ${b.h}" fill="var(--um-muted)" style="font:500 10px var(--um-sans)">${esc(b.text)}</text>`).join('');
+    if (T) s += T.labels(i);
     if (!e.lbl) return;
     const L = e.lbl;
     if (map) {
@@ -893,10 +837,10 @@ const labelW = e => textW(fit((e.step != null ? e.step + ' · ' : '') + (e.label
    leaves a at row oa inside it and reaches b at row ob, as rowsFor's links do (the middle when not given). Each line into a
    box has its own entry, so two that cross on the way in to its cards count as crossing; they all met it at one point.
    fixed: items at a set row in columns of their own, which stay as they are (a box's far ends, in blockPos). */
-function untangle(cols, links, h = () => 1, fixed = {}) {
-  const colOf = {}; cols.forEach((c, k) => c.forEach(id => { colOf[id] = k; }));
-  const segs = [], extra = new Set(), want = {}, hh = id => extra.has(id) ? 1 : h(id), mid = (id, o) => o ?? (hh(id) - 1) / 2;
-  const tops = () => { const at = {}; cols.forEach(c => { let r = 0; c.forEach(id => { at[id] = fixed[id] ?? r; r += hh(id); }); }); return at; }; // each item's top row
+function untangle(cols, links, h = () => 1, fixed = Object.create(null)) { // maps by id: no prototype (M3)
+  const colOf = Object.create(null); cols.forEach((c, k) => c.forEach(id => { colOf[id] = k; }));
+  const segs = [], extra = new Set(), want = Object.create(null), hh = id => extra.has(id) ? 1 : h(id), mid = (id, o) => o ?? (hh(id) - 1) / 2;
+  const tops = () => { const at = Object.create(null); cols.forEach(c => { let r = 0; c.forEach(id => { at[id] = fixed[id] ?? r; r += hh(id); }); }); return at; }; // each item's top row
   const at0 = tops();
   links.forEach(([a, b, oa, ob], n) => {
     const ka = colOf[a], kb = colOf[b]; if (ka == null || kb == null || kb <= ka) return;
@@ -908,7 +852,7 @@ function untangle(cols, links, h = () => 1, fixed = {}) {
   });
   if (extra.size) cols.forEach((c, k) => { const ps = [...extra].filter(p => colOf[p] === k);
     if (ps.length) cols[k] = [...c.map(id => [id, at0[id], 0]), ...ps.map(p => [p, want[p], 1])].sort((x, y) => x[1] - y[1] || x[2] - y[2]).map(x => x[0]); });
-  const ins = {}, outs = {}; segs.forEach(([a, b, oa, ob]) => { (outs[a] ||= []).push([b, ob, oa]); (ins[b] ||= []).push([a, oa, ob]); });
+  const ins = Object.create(null), outs = Object.create(null); segs.forEach(([a, b, oa, ob]) => { (outs[a] ||= []).push([b, ob, oa]); (ins[b] ||= []).push([a, oa, ob]); });
   const crossings = () => { const at = tops(); let n = 0;
     for (let i = 0; i < segs.length; i++) for (let j = i + 1; j < segs.length; j++) { const [a, b, oa, ob] = segs[i], [c, d, oc, od] = segs[j];
       if (colOf[a] === colOf[c] && (at[a] + oa - at[c] - oc) * (at[b] + ob - at[d] - od) < 0) n++; }
@@ -938,9 +882,10 @@ function pullSources(ids, links, rank) {
    adjacent violators); on half rows from 0. A line between cards on one row runs straight, past fewer cards. h: an item's
    height in rows (a box in a view with boxes); a link [a, b, oa, ob] leaves a at row oa inside it and reaches b at row
    ob (a box's card), else at its middle. fixed: items at a set row, in columns of their own that stay (as untangle's). */
-function rowsFor(cols, links, h = () => 1, fixed = {}) {
-  const row = {}, colOf = {}; cols.forEach((c, k) => { let r = 0; c.forEach(id => { row[id] = fixed[id] ?? r; r += h(id); colOf[id] = k; }); });
-  const ins = {}, outs = {}, at = (id, o) => o ?? (h(id) - 1) / 2; // where a link meets an item, in rows from its top
+function rowsFor(cols, links, h = () => 1, fixed = Object.create(null)) {
+  const row = Object.create(null); if (!cols.length) return row; // an empty view
+  const colOf = Object.create(null); cols.forEach((c, k) => { let r = 0; c.forEach(id => { row[id] = fixed[id] ?? r; r += h(id); colOf[id] = k; }); });
+  const ins = Object.create(null), outs = Object.create(null), at = (id, o) => o ?? (h(id) - 1) / 2; // where a link meets an item, in rows from its top
   links.forEach(([a, b, oa, ob]) => { if (colOf[a] == null || colOf[b] == null || colOf[b] <= colOf[a]) return;
     (outs[a] ||= []).push([b, at(b, ob), at(a, oa)]); (ins[b] ||= []).push([a, at(a, oa), at(b, ob)]); });
   const median = xs => { const s = xs.slice().sort((a, b) => a - b), m = s.length >> 1; return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2; };
@@ -949,7 +894,7 @@ function rowsFor(cols, links, h = () => 1, fixed = {}) {
       while (blocks.length > 1 && blocks.at(-2).sum / blocks.at(-2).n > blocks.at(-1).sum / blocks.at(-1).n) { const b = blocks.pop(), a = blocks.at(-1); a.ids.push(...b.ids); a.sum += b.sum; a.n += b.n; } });
     off = 0; blocks.forEach(b => b.ids.forEach(id => { row[id] = b.sum / b.n + off; off += h(id); })); };
   for (const [from, to, step] of [[1, cols.length, 1], [cols.length - 2, -1, -1], [1, cols.length, 1]])
-    for (let k = from; k !== to; k += step) { if (cols[k].every(id => id in fixed)) continue; const want = {};
+    for (let k = from; k !== to; k += step) { if (cols[k].every(id => id in fixed)) continue; const want = Object.create(null);
       cols[k].forEach(id => { const nb = (step > 0 ? ins : outs)[id] || []; want[id] = nb.length ? median(nb.map(([x, ox, o]) => row[x] + ox - o)) : row[id]; });
       fit(cols[k], want); }
   const low = Math.min(...Object.keys(row).filter(id => !(id in fixed)).map(id => row[id]));
@@ -1055,29 +1000,12 @@ function layoutPass(dg, map, room, last) { // room: { x: { col: px }, y: { row:
       gapAfter[c] = Math.max(gapAfter[c] || 0, w + 54 + box);
       [e.from, e.to].forEach(id => { const k = c + '|' + id, t = sum[k] ||= { w: -6, box: 0 }; t.w += w + 6; t.box = Math.max(t.box, box); gapAfter[c] = Math.max(gapAfter[c], t.w + 54 + t.box); }); }); }
   const extraX = { ...(room || {}).x }, extraY = { ...(room || {}).y }; // more room after a column (row): for lines with no route, and where a box would touch another box (below)
-  // A typed view's lines from a node to itself (risks.md F1) are loops round its top right corner, nested, the first innermost:
-  // each one's top run D px above the node, its label on that run clear of the node's stub room and of the loop inside; its
-  // right run R px right of the node, far enough for the top run to hold the label. out: how far each loop's port on the
-  // node's top lies left of its right side (0 before ports are known, for the room: above the node's row, right of its column)
-  const loopDims = (list, out) => { let D = 0, R = 0, half = 0;
-    return list.map((e, k) => { const lw = e.label || e.step != null ? labelW(e) : 0, [bw, bh] = dg.turned ? [lw && 18, lw] : [lw, lw && 18];
-      D = k ? D + half + bh / 2 + 10 : STUB + 6 + bh / 2; half = bh / 2;
-      R = Math.max(k ? R + 2 * SEP : STUB + 4, bw + 12 - out[k]); return { D, R, top: D + half }; }); };
-  const loops = Object.create(null); if (dg.typed && !dg.abs) (dg.edges || []).forEach(e => { if (e.from === e.to && byId[e.from]) (loops[e.from] ||= []).push(e); });
-  Object.entries(loops).forEach(([id, list]) => { const n = byId[id], d = loopDims(list, list.map(() => 0)).at(-1);
-    extraY[n.row - .5] = Math.max(extraY[n.row - .5] || 0, d.top + STUB + 7 - RG);
-    extraX[n.col] = Math.max(extraX[n.col] || 0, d.R + STUB + 6 - Math.max(CG, gapAfter[n.col] || 0)); });
-  // a typed view's rows (stage 1 note §4): each as tall as its tallest node, a node on a half row counting toward both rows, and
-  // NH with none. With every node NH tall, the pitch is a map's
-  const rowH = {}, rowTop = {}; if (dg.typed && !dg.abs && nodes.length) {
-    nodes.forEach(n => [Math.floor(n.row), Math.ceil(n.row)].forEach(k => { rowH[k] = Math.max(rowH[k] ?? 0, n.h); }));
-    const r0 = Math.min(...Object.keys(rowH).map(Number)), r1 = Math.max(...Object.keys(rowH).map(Number));
-    for (let k = r0, y = r0 * pitch; k <= r1 + 1; k++) { rowTop[k] = y; y += (rowH[k] ?? NH) + RG; } }
-  const rowAt = r => { const k = Math.floor(r), f = r - k; return rowTop[k] == null || rowTop[k + 1] == null ? r * pitch : rowTop[k] + f * (rowTop[k + 1] - rowTop[k]); };
-  const rowHt = r => Math.max(rowH[Math.floor(r)] ?? NH, rowH[Math.ceil(r)] ?? NH); // a typed row's height, a half row's the taller of its two
+  // a typed view's lines from a node to itself, drawn as loops (risks.md F1): the room they take, their ports and routes (src/typed/layout.js)
+  const loops = Object.create(null), LP = dg.typed && !dg.abs ? TYPED.loops(loops, dg, { byId, extraX, extraY, STUB, RG, CG, SEP, gapAfter }) : null;
+  const rows = dg.typed && TYPED.rows(dg, nodes, pitch, NH, RG); // a typed view's rows (src/typed/layout.js)
   const gap = c => Math.max(CG, gapAfter[c] || 0) + (extraX[c] || 0);
   const cx = c => Number.isInteger(c) ? colX[c] : colX[Math.floor(c)] + (c % 1) * ((colW[Math.floor(c)] || NW) + gap(Math.floor(c)));
-  const rowY = r => Object.keys(extraY).reduce((y, k) => +k < r ? y + extraY[k] : y, dg.typed ? rowAt(r) : r * pitch);
+  const rowY = r => Object.keys(extraY).reduce((y, k) => +k < r ? y + extraY[k] : y, rows ? rows.at(r) : r * pitch);
   const place = () => {
     x = 0; for (let c = Math.floor(cols[0] ?? 0); c <= Math.ceil(cols[cols.length - 1] ?? 0); c++) { colX[c] = x; x += (colW[c] || NW) + gap(c); }
     nodes.forEach(n => { n.x = cx(n.col) + ((colW[n.col] || n.w) - n.w) / 2; n.y = rowY(n.row); if (map && n.k === 'm-script') { n.h = NH - 22; n.y += 11; } });
@@ -1192,7 +1120,7 @@ function layoutPass(dg, map, room, last) { // room: { x: { col: px }, y: { row:
     if (near && !through([...pts, ...up], e)) { e.fixed = [...pts, ...up]; e.under = k + 1; }
     else if (!through([...pts, ...bottom], e)) { e.fixed = [...pts, ...bottom]; e.under = true; } // one that would cut through a card is left to the router
   });
-  edges.forEach(e => { if (e.s === e.t) Object.assign(e, { [OWN_ROUTE]: 'loop', fixed: true, fs: 'R', ts: 'T', stubs: [], how: 'self' }); }); // its loop is drawn once its ports are known
+  if (LP) LP.mark(edges);
   const free = edges.filter(e => !e.fixed);
   edges.filter(e => e.fixed && !e[OWN_ROUTE]).forEach(e => { e.pts = e.fixed; e.p1 = e.pts[0]; e.p2 = e.pts[e.pts.length - 1]; e.fs = 'R'; e.ts = e.under > 0 ? 'R' : e.under ? 'B' : 'L'; e.stubs = []; e.how = e.under ? 'under' : 'comb'; });
   const sides = {};
@@ -1227,10 +1155,7 @@ function layoutPass(dg, map, room, last) { // room: { x: { col: px }, y: { row:
   });
   free.forEach(e => { pushSide(e.s, e.fs, e, e.t); pushSide(e.t, e.ts, e, e.s); });
   edges.filter(e => e.under > 0).forEach(e => pushSide(e.t, 'R', e, e.s)); // a loop under the boxes takes its port with the side's other lines
-  // a loop from a node to itself takes the top port of its right side and the right port of its top, the inner loop the nearer the corner
-  const loopsOf = n => edges.filter(e => e[OWN_ROUTE] === 'loop' && e.s === n);
-  edges.filter(e => e[OWN_ROUTE] === 'loop').forEach(e => { const n = e.s, k = loopsOf(n).indexOf(e);
-    pushSide(n, 'R', e, { x: n.x + n.w, y: -1e6 + k, w: 0, h: 0 }); pushSide(n, 'T', e, { x: 1e6 - k, y: n.y, w: 0, h: 0 }); });
+  if (LP) LP.ports(pushSide);
   const portAt = (it, side, p) => { if (it.n === it.e.s && it.e.fs === side) it.e.p1 = p; else it.e.p2 = p; };
   Object.entries(sides).sort(([, a], [, b]) => !!a[0].n.box - !!b[0].n.box).forEach(([key, list]) => { // cards first: a box's port lines up with them
     const side = key.split('|').pop(), vertical = side === 'L' || side === 'R';
@@ -1268,31 +1193,8 @@ function layoutPass(dg, map, room, last) { // room: { x: { col: px }, y: { row:
     });
   });
   edges.filter(e => e.under > 0).forEach(e => { const P = e.fixed; e.pts = e.fixed = [...P.slice(0, 4), [P[3][0], e.p2[1]], e.p2]; });
-  // a loop from a node to itself: out of the right side, up, left, down into the top. Other routes keep SEP px off its corners
-  // (corners: obstacles to routes only), so none touches it or turns where it does
-  const corners = []; [...new Set(edges.filter(e => e[OWN_ROUTE] === 'loop').map(e => e.s))].forEach(n => { const list = loopsOf(n);
-    loopDims(list, list.map(e => n.x + n.w - e.p2[0])).forEach(({ D, R }, k) => { const e = list[k], x = n.x + n.w + R, y = n.y - D;
-      e.pts = e.fixed = [e.p1, [x, e.p1[1]], [x, y], [e.p2[0], y], e.p2];
-      e.pts.slice(1, 4).forEach(([px, py]) => corners.push({ x: px - SEP, y: py - SEP, w: 2 * SEP, h: 2 * SEP })); }); });
-  // A view laid out down (turned): the labels of lines between one pair are wider than the 16 px between the lines, so the
-  // lines fan out in the gap between the pair's columns, each to a lane of its own that holds its label. Above the middle, the
-  // outer line turns nearer each node, so none crosses another; a group the gap or another node leaves no room for goes to the router
-  if (dg.typed && dg.turned) { const pairs = new Map(), lr = e => e.fs === 'R' ? [e.p1, e.p2] : [e.p2, e.p1];
-    free.forEach(e => { const [l, r] = e.fs === 'R' ? [e.s, e.t] : [e.t, e.s], k = l.id + '\u0001' + r.id;
-      if (/^(RL|LR)$/.test(e.fs + e.ts) && l.x + l.w < r.x) pairs.set(k, [...(pairs.get(k) || []), e]); });
-    pairs.forEach(list => { if (list.length < 2 || !list.some(e => e.label || e.step != null)) return;
-      list.sort((a, b) => lr(a)[0][1] - lr(b)[0][1]); if (list.some((e, i) => i && lr(e)[1][1] <= lr(list[i - 1])[1][1])) return;
-      const bh = list.map(e => e.label || e.step != null ? labelW(e) : 0), gaps = bh.map((h, i) => i ? Math.max(SEP, (bh[i - 1] + h) / 2 + 6) : 0);
-      const mid = list.reduce((a, e) => a + lr(e)[0][1] + lr(e)[1][1], 0) / (2 * list.length), lanes = [];
-      gaps.reduce((y, g, i) => (lanes[i] = y + g), mid - gaps.reduce((a, g) => a + g, 0) / 2);
-      // each line's turn on each side: the k-th line turning towards its lane from the outside turns k SEP px past the stub
-      const turns = side => { const at = []; const up = list.map((e, i) => i).filter(i => lanes[i] < lr(list[i])[side][1]), down = list.map((e, i) => i).filter(i => lanes[i] >= lr(list[i])[side][1]).reverse();
-        [up, down].forEach(g => g.forEach((i, k) => { at[i] = lr(list[i])[side][0] + (side ? -1 : 1) * (STUB + k * SEP); })); return at; };
-      const xl = turns(0), xr = turns(1);
-      if (Math.min(...xr) - Math.max(...xl) < 18 + 16) return;
-      const pts = list.map((e, i) => { const [a, b] = lr(e), P = simplify([a, [xl[i], a[1]], [xl[i], lanes[i]], [xr[i], lanes[i]], [xr[i], b[1]], b]); return e.fs === 'R' ? P : P.reverse(); });
-      if (list.some((e, i) => through(pts[i], e))) return;
-      list.forEach((e, i) => { Object.assign(e, { [OWN_ROUTE]: 'fan', fixed: pts[i], pts: pts[i], stubs: [], how: 'fan' }); free.splice(free.indexOf(e), 1); }); }); }
+  const corners = LP ? LP.route() : []; // a loop's corners: obstacles to the other routes
+  if (dg.typed && dg.turned) TYPED.fan(free, { simplify, through, STUB, SEP }); // a view laid out down: lines between one pair fan out (src/typed/layout.js)
   const BEND = map ? 60 : 26, CROSS = 900; // maps: few bends
   const OUT = { R: [1, 0], L: [-1, 0], T: [0, -1], B: [0, 1] };
   const nodeRects = nodes.map(n => ({ x: n.x, y: n.y, w: n.w, h: n.h }));
@@ -1302,7 +1204,7 @@ function layoutPass(dg, map, room, last) { // room: { x: { col: px }, y: { row:
     nodes.forEach(n => gapLinesY.push(n.y - RG / 2, n.y + n.h + RG / 2));
   } else {
     Object.keys(colX).map(Number).forEach(c => gapLinesX.push(colX[c] - CG / 2, colX[c] + (colW[c] || NW) + CG / 2));
-    [...new Set(nodes.map(n => n.y))].forEach(y => gapLinesY.push(y - RG / 2, y + (dg.typed ? rowHt(nodes.find(n => n.y === y).row) : NH) + RG / 2));
+    [...new Set(nodes.map(n => n.y))].forEach(y => gapLinesY.push(y - RG / 2, y + (rows ? rows.ht(nodes.find(n => n.y === y).row) : NH) + RG / 2));
   }
   const routed = [], reserved = [];
   const inRect = (p, r) => p[0] > r.x && p[0] < r.x + r.w && p[1] > r.y && p[1] < r.y + r.h;
@@ -1676,6 +1578,7 @@ function layoutPass(dg, map, room, last) { // room: { x: { col: px }, y: { row:
   const xs = [...families.flatMap(f => [f.x,f.x+f.w]), ...(dg.lanes || []).flatMap(l => [l.x, l.x + l.w]), ...nodes.flatMap(n => [n.x - 14, n.x + n.w + 8]), ...groups.flatMap(g => [g.x, g.x2]), ...edges.flatMap(e => e.pts.map(p => p[0])), ...placed.flatMap(p => [p.x, p.x + p.w])];
   const ys = [...families.flatMap(f => [f.y,f.y+f.h]), ...(dg.lanes || []).flatMap(l => [l.y, l.y + l.h]), ...nodes.flatMap(n => [n.y - 14, n.y + n.h + (n.tag ? 18 : 8)]), ...groups.flatMap(g => [g.y, g.y2]), ...edges.flatMap(e => e.pts.map(p => p[1])), ...placed.flatMap(p => [p.y, p.y + p.h])];
   intake.forEach(b => { xs.push(b.cx - b.r - 8 - textW(b.label || '', 10.5), b.cx + b.r); ys.push(b.cy - b.r, b.cy + b.r); });
+  if (!xs.length) xs.push(0), ys.push(0); // a view with nothing in it: an empty stage
   const M = 36, minX = Math.min(...xs) - M, minY = Math.min(...ys) - M;
   return { ms: __ms, ...(labelRoom ? { labelRoom } : {}), stats, nodes, edges, subAndChips: !!dg.subAndChips, groups, families, intake, tour: dg.tour || null, byId, map, hub: dg.hub || null, lanes: dg.lanes || [], blocks: dg.blocks || [], bounds: { x: minX, y: minY, w: Math.max(...xs) - minX + M, h: Math.max(...ys) - minY + M } };
 }
@@ -1818,49 +1721,6 @@ function auditSvg(svg, geo, where) {
   for (let i = 0; i < els.length; i++) for (let j = i + 1; j < els.length; j++) if (hit(els[i].b, els[j].b, -1)) issues.push(`${where}: edge labels "${els[i].txt}" and "${els[j].txt}" overlap`);
   return issues;
 }
-/* A typed view's layout (work package 1.4): layoutGraph's plain layout with what a typed view needs, none of it on a map.
-   Rows as tall as their tallest node (stage 1 note §4); a line from a node to itself drawn as a loop (risks.md F1); lines
-   between one pair each with its own ports and label (F2); `direction: "down"` (note §6); and a memo that lays the view out
-   again only when its geometry changed (F7). Nodes come with their sizes, `w` and `h`, which their shapes give (1.5). */
-
-// what moves a typed view's geometry: every field of the view layoutGraph reads but VIEW_PAINT (a test holds the two lists to
-// layered.js), and these of a node and a line. Anything else (a colour, a `props` field) only repaints
-const VIEW_GEO = ['abs', 'authors', 'blocks', 'containers', 'direction', 'fan', 'flipped', 'gap', 'groups', 'hub', 'intake', 'laneGap', 'lanes', 'mainSteps', 'nodeH', 'quick', 'repair', 'rgap', 'turned', 'typed'];
-const VIEW_PAINT = ['tour', 'subAndChips'], NODE_GEO = ['id', 'col', 'row', 'w', 'h', 'ax', 'ay'], EDGE_GEO = ['id', 'from', 'to', 'label', 'step', 'fromSide', 'toSide', 'back', 'fixed', 'sublabel'];
-const geometryKey = dg => JSON.stringify([VIEW_GEO.map(k => dg[k]), (dg.nodes || []).map(n => NODE_GEO.map(k => n[k])), (dg.edges || []).map(e => EDGE_GEO.map(k => e[k]))]);
-
-// direction "down": laid out left to right with every box turned, then turned back, x for y and the sides L for T, R for B
-const SIDE_T = { L: 'T', T: 'L', R: 'B', B: 'R' }, swapXY = p => [p[1], p[0]];
-const flipBox = r => { if (r) [r.x, r.y, r.w, r.h] = [r.y, r.x, r.h, r.w]; };
-function transpose(g) {
-  [...g.nodes, ...(g.families || []), g.bounds].forEach(flipBox);
-  (g.groups || []).forEach(r => { [r.x, r.y, r.x2, r.y2] = [r.y, r.x, r.y2, r.x2]; });
-  g.edges.forEach(e => { e.pts = e.pts.map(swapXY); if (e.fixed) e.fixed = e.pts; e.p1 = swapXY(e.p1); e.p2 = swapXY(e.p2);
-    e.fs = SIDE_T[e.fs]; e.ts = SIDE_T[e.ts]; e.stubs = (e.stubs || []).map(s => s.map(swapXY)); flipBox(e.lbl); });
-  return g;
-}
-
-// the geometry kept, with the paint of the view given in place of the paint it was laid out with: each node's own fields, and
-// each line's, by its id (typed lines have ids); a field the view no longer gives goes. The geometric fields are the same in both
-function repaint(g, was, dg) {
-  const by = (list, key) => new Map((list || []).filter(x => x && x[key] != null).map(x => [x[key], x]));
-  [[g.nodes, was.nodes, dg.nodes], [g.edges, was.edges, dg.edges]].forEach(([out, a, b]) => { const A = by(a, 'id'), B = by(b, 'id');
-    out.forEach(x => { const old = A.get(x.id), now = B.get(x.id); if (!now) return; for (const k in old) if (!(k in now)) delete x[k]; Object.assign(x, now); }); });
-  return g;
-}
-
-/* dg: layoutGraph's input, with `direction` ("right", the default, or "down"). memo: an object kept for the view between
-   calls; while the geometry key is the same, the geometry it holds is repainted and returned, and nothing is laid out or
-   routed. memo.runs counts the layouts. */
-function layoutTyped(dg, memo) {
-  const key = memo && geometryKey(dg);
-  if (memo && memo.key === key) { const g = repaint(memo.g, memo.dg, dg); memo.dg = dg; return g; }
-  const t = { ...dg, typed: true }, g = dg.direction === 'down'
-    ? transpose(layoutGraph({ ...t, turned: true, nodes: (dg.nodes || []).map(n => ({ ...n, w: n.h || dg.nodeH || 64, h: n.w || NW })) }, false))
-    : layoutGraph(t, false);
-  if (memo) Object.assign(memo, { key, g, dg, runs: (memo.runs || 0) + 1 });
-  return g;
-}
 /* ================= diagram engine (shared by document diagrams and the map) =================
    Style adapted from tt-a1i/archify (MIT): semantic palette, opaque mask under a translucent
    fill, per-kind sigils, grid canvas, orthogonal rounded routes, arrow markers. */
@@ -2210,7 +2070,7 @@ function mapContext(model, opts = {}) {
       // the box's lines to cards outside it (#86): each far end at its row from the box's top, where the pass before put both.
       // ponytail: three passes, so a far end that moves in the last one is followed where it was, and a far end in the card's
       // own column, or a line to a box, places nothing; passes until nothing moves, if a map needs them
-      const far = [], fixed = {}, top = P && g != null && was[g] ? Object.keys(was[g].pos).map(c => P[c] && P[c][1] - was[g].pos[c][1]).find(r => r != null) : null;
+      const far = [], fixed = Object.create(null), top = P && g != null && was[g] ? Object.keys(was[g].pos).map(c => P[c] && P[c][1] - was[g].pos[c][1]).find(r => r != null) : null;
       if (top != null) fwd.forEach(e => { const fin = holds(g, e.from); if (fin === holds(g, e.to)) return;
         const [mine, other] = fin ? [e.from, e.to] : [e.to, e.from], x = itemIn(mine, g), p = P[mine], q = P[other]; if (x === undefined || !p || !q || p[0] === q[0]) return;
         const id = '\u0002' + far.length, left = q[0] < p[0]; fixed[id] = q[1] - top;
@@ -2233,7 +2093,10 @@ function mapContext(model, opts = {}) {
     for (const order of [false, true]) { was = now; now = {}; P = block(null, P, order).pos; } // levelled by the lines from outside, then ordered by them too
     return P;
   }
-  const autoPos = vid => ((V[vid] || {}).containers || []).length ? blockPos(vid) : bestFlow(vid);
+  // a typed view whose type lays it out (1.9): the plain flow's ranking, with the lines the type turns round for it
+  const ownLayout = vid => { if (D.schemaVersion !== 2) return null; const T = diagramOf(V[vid]); return T && T.layout && (T.layout.run || typeof T.layout === 'function') ? T : null; }; // version 1: a map
+  const autoPos = vid => ownLayout(vid) ? flowPos(vid, { flip: ownLayout(vid).rankFlip }) : ((V[vid] || {}).containers || []).length ? blockPos(vid) : bestFlow(vid);
+  const memos = opts.memos || Object.create(null); // per view, layoutTyped's memo, kept across update()s: an edit that moves nothing lays out nothing
   const level = e => !/^(top|bottom)$/.test(e.fromSide) && !/^(top|bottom)$/.test(e.toSide); // a line into a card's top or bottom asks for no row
   /* A small plain view is routed a few ways and keeps the one the layout check scores best: cards level with their
      neighbours, or packed from the top as before, with cards no line comes into beside their callee or not. A cheap
@@ -2253,15 +2116,16 @@ function mapContext(model, opts = {}) {
   const fanIn = vid => { const k = {}; return viewEdges(V[vid] || {}).some(e => e.from !== e.to && (k[e.to] = (k[e.to] || 0) + 1) >= 6); };
   const drawn = {}; // the way bestFlow kept, routed already: the view's next buildGeo takes it once instead of routing it again
   function flowPos(vid, o = {}) {
-    const v = V[vid], lp = loopsOf(v), fwd = lp.edges.filter((e, k) => !lp.back.has(k) && e.from !== e.to);
+    const v = o.flip ? { ...V[vid], edges: viewEdges(V[vid]).map(e => o.flip(e) ? { ...e, from: e.to, to: e.from } : e) } : V[vid];
+    const lp = loopsOf(v), fwd = lp.edges.filter((e, k) => !lp.back.has(k) && e.from !== e.to);
     // cards with no line go in rows of their own under the view (#46), as wide as its columns; they stacked with the sources
     const all = (v.nodeIds || []).filter(i => N[i]), lined = new Set(lp.edges.filter(e => e.from !== e.to).flatMap(e => [e.from, e.to]));
     const loose = lined.size ? all.filter(i => !lined.has(i)) : [], ids = all.filter(i => !loose.includes(i));
-    const rank = {}; ids.forEach(i => { rank[i] = 0; });
+    const rank = Object.create(null); ids.forEach(i => { rank[i] = 0; });
     for (let it = 0; it <= ids.length; it++) fwd.forEach(e => { if (rank[e.to] < rank[e.from] + 1) rank[e.to] = rank[e.from] + 1; });
     const seen = id => { const k = lp.edges.findIndex(e => e.to === id || e.from === id); return k < 0 ? 999 : k; };
     const sink = i => isState(i) && !fwd.some(e => e.from === i); // state that leads nowhere sits along the bottom
-    const pos = {}, links = fwd.map(e => [e.from, e.to]);
+    const pos = Object.create(null), links = fwd.map(e => [e.from, e.to]);
     const order = rk => { const cols = {}; ids.forEach(i => (cols[rk[i]] ||= []).push(i));
       const ranks = Object.keys(cols).map(Number).sort((a, b) => a - b), mains = ranks.map(c => cols[c].filter(i => !sink(i)).sort((a, b) => seen(a) - seen(b)));
       untangle(mains, links); return { cols, ranks, mains }; }; // in reading order, unless another order crosses less (#53)
@@ -2286,8 +2150,8 @@ function mapContext(model, opts = {}) {
   // with no layout (a change of notation draws the cards again and nothing else)
   const notationOf = vid => noteOf((V[vid] || {}).shapes) || noteOf(D.shapes) || 'box';
   function drawView(vid, g, opts = {}) {
-    const v = V[vid], shapes = noteOf(opts.shapes) || notationOf(vid);
-    return { markup: svgOf(g, { title: v.title, subject: subjectOf(v), icons: D.icons, broken: brokenIn(vid), ...opts, shapes }), shapes };
+    const v = V[vid], shapes = noteOf(opts.shapes) || notationOf(vid), T = ownLayout(vid), L = T && T.draw && T.draw(g, { esc, r2, textW }); // its two layers only
+    return { markup: svgOf(g, { title: v.title, subject: subjectOf(v), icons: D.icons, broken: brokenIn(vid), ...opts, shapes, ...(L && { under: L.under, over: L.over }) }), shapes };
   }
   // the rules a view's lines break (#70), by model edge id: svgOf draws such a line rose, with a mark that names them
   let ruled = null;
@@ -2297,7 +2161,7 @@ function mapContext(model, opts = {}) {
     (ruled ||= rules(D)).forEach(b => { if (b.view === vid) b.targets.forEach(t => { if (t.type === 'edge') t.ids.forEach(i => { const l = by[i] ||= []; if (!l.includes(title(b.rule))) l.push(title(b.rule)); }); }); });
     return Object.keys(by).length ? by : null;
   };
-  const layoutCache = {};
+  const layoutCache = Object.create(null); // M3
   // the cards a card opens: its inner view's, else the count the host gives for one it has not loaded (opensCount)
   const kidCount = (nid, vid) => { const c = childOf(nid, vid), k = c && c !== vid ? (V[c].nodeIds || []).length : 0, n = +nodeIn(nid, vid).opensCount;
     return k || (opensOf(nid, vid) && n > 0 ? Math.floor(n) : 0); };
@@ -2325,7 +2189,15 @@ function mapContext(model, opts = {}) {
   // quick: a candidate the layout searches below score and may drop, laid out once, as it was before 0.6.0 (no room for lines
   // with no route, no way round the cards for them, no warning)
   function buildGeo(vid, override, repair = (V[vid] || {}).repair !== false, quick = false) { // a view's repair: false turns port repair off
-    const v = V[vid], ids = (v.nodeIds || []).filter(i => N[i]);
+    const v = V[vid], ids = (v.nodeIds || []).filter(i => N[i]), T = ownLayout(vid);
+    if (T) { // the type's layout (registry.js), in the host's measure (R2)
+      const L = T.layout, memo = memos[vid] ||= {}, k = !override && L.key ? L.key(D, v) : null;
+      if (k != null && memo.runKey === k) return memo.runGeo;
+      const pos = override || (v.layout && L.pins !== false ? fillLayout(vid, v.layout) : (layoutCache[vid] ||= autoPos(vid)));
+      const g = L.run ? L.run(D, v, { measure: M, pos, memo }) : L({ model: D, view: v, pos, memo });
+      if (k != null) Object.assign(memo, { runKey: k, runGeo: g });
+      return g;
+    }
     const edges = viewEdges(v).map(e => ({ ...e }));
     if (v.render === 'sequence') edges.forEach((e, i) => { e.step = i + 1; });
     const P = planCache[vid] || { flow: true, backKeys: loopsOf(v).keys, steps: {} };
@@ -2568,7 +2440,7 @@ function mapContext(model, opts = {}) {
     for (let more = true; more && todo.length;) { more = false; todo = todo.filter(nid => { if (!unfold(vid, nid)) return true; (unfolded[vid] ||= []).push(nid); return !(more = true); }); } }))();
   const geoCache = {};
   return { D, views, nodes, N, V, rootId, nodeIn, childOf, opensOf, subjectOf, viewsWith, kidsOf, chain, viewEdges, isState, planOf: withM(planOf), planCache,
-    layoutCache, geoCache, buildGeo: withM(buildGeo), buildView: withM(buildView), drawView: withM(drawView), notationOf, optimize: withM(optimize), flowPos, kidCount, viewKey, brokenIn, unfoldable, unfolded };
+    layoutCache, geoCache, memos, buildGeo: withM(buildGeo), buildView: withM(buildView), drawView: withM(drawView), notationOf, optimize: withM(optimize), flowPos, kidCount, viewKey, brokenIn, unfoldable, unfolded };
 }
 const edgeRefIds = e => [...new Set((e.all || [e]).map(x => x._id).filter(Boolean))];
 
@@ -2723,6 +2595,9 @@ export function validate(model) {
     out.push(...typedProblems(m).filter(p => !(p.level === 'error' && said.has(p.path))));
     views.forEach((v, i) => { const at = `views[${i}].diagram`; // a well-formed name of a type this release does not draw (M13)
       if (typedView(v) && !diagramOf(v) && !out.some(p => p.path === at)) warn(at, `diagram "${v.diagram}" is not drawn by this release: its nodes are drawn as plain cards`); });
+    const once = new Set(); // each view's type's rules, a problem once; a validate(model) that takes no view, once a type
+    views.filter(typedView).forEach(v => { const T = diagramOf(v); if (!T || !T.validate || once.has(T)) return; if (T.validate.length < 2) once.add(T);
+      T.validate(m, v).forEach(p => { const k = JSON.stringify([p.level, p.path, p.message]); if (!once.has(k)) { once.add(k); out.push(p); } }); });
   }
   return out;
 }
@@ -2966,6 +2841,7 @@ export function reach(model, viewId, from, options = {}) {
 /** A view in plain sentences: its cards and their kinds, its boxes, what each card's lines do (in run order on a sequence
  *  view), and the cards with no line. The same model gives the same words: a text alternative, docs, or an AI's context. */
 export function describe(model, viewId) {
+  const T = model && model.schemaVersion === 2 && diagramOf(arrOf(model.views).find(v => v && v.id === viewId)); if (T && T.describe) return T.describe(model, viewId); // a type's own words (1.9)
   const { ctx, v, ids, edges } = lineGraph(model, viewId), boxes = (v.containers || []).filter(c => c && c.id);
   const name = id => ctx.N[id] ? ctx.nodeIn(id, viewId).label || id : (boxes.find(c => c.id === id) || {}).label || id;
   const list = xs => xs.length < 3 ? xs.join(' and ') : xs.slice(0, -1).join(', ') + ' and ' + xs[xs.length - 1];
@@ -3653,7 +3529,9 @@ function typedEditor(api) {
     const t = nodeTypes()[i], cam = api.cam(); if (!t || !can('add') || !cam) return;
     api.editor({ x: cam.s.cx - 80, y: cam.s.cy - 13, w: 160, h: 26 }, '', value => emit([{ op: 'add', element: { ...typed(t, 'node'), label: value }, view: api.view() }]));
   }
-  const addLine = (from, to, t) => emit([{ op: 'add', element: { ...typed(t, 'line'), from, to }, view: api.view() }]);
+  const hook = k => { const E = def().edits; return isRec(E) && typeof E[k] === 'function' ? E[k] : null; }; // registry.js edits
+  const addLine = (from, to, t) => { const c = hook('connect'); // at (a slot): stage 3's
+    emit(c ? arrOf(c(model(), view(), from, to, null, t)) : [{ op: 'add', element: { ...typed(t, 'line'), from, to, ...(isRec(t.props) ? { props: structuredClone(t.props) } : {}) }, view: api.view() }]); };
   function connect(from, to) { // the relationship picker, when the type has more than one kind of line
     if (!can('add') || !from || !to || from === to) return;
     const types = lineTypes();
@@ -3736,15 +3614,17 @@ function typedEditor(api) {
     const off = can('rename') ? '' : ' disabled'; // the editable flags: a field the host does not offer is shown, to read
     const text = (f, v, name, more = '') => `<label>${esc(name)}<input data-f="${esc(f)}" data-was="${esc(v)}" value="${esc(v)}"${more}${off}></label>`;
     let h = `<h3>Properties${x.type != null ? ': ' + esc(x.type) : ''}</h3>` + text('label', x.label ?? '', 'Name');
-    schema.forEach(f => { const v = P[f.key], name = f.label || f.key;
-      if (f.kind === 'bool') h += `<label class="um-check"><input type="checkbox" data-f="p:${esc(f.key)}" data-key="${esc(f.key)}"${v ? ' checked' : ''}${off}>${esc(name)}</label>`;
-      else if (f.kind === 'enum') h += `<label>${esc(name)}<select data-f="p:${esc(f.key)}" data-key="${esc(f.key)}"${off}>${['', ...arrOf(f.options)].map(o => `<option value="${esc(o)}"${o === v ? ' selected' : ''}>${esc(o)}</option>`).join('')}</select></label>`;
-      else h += text('p:' + f.key, v ?? '', name, ` data-key="${esc(f.key)}"`); });
+    schema.forEach(f => { const v = Array.isArray(f.path) ? f.path.reduce((o, k) => isRec(o) ? o[k] : undefined, P) : P[f.key], name = f.label || f.key; // path: a field inside props (ends.from.role)
+      const key = ` data-key="${esc(f.key)}"${Array.isArray(f.path) ? ` data-path="${esc(JSON.stringify(f.path))}"` : ''}`;
+      if (f.kind === 'bool') h += `<label class="um-check"><input type="checkbox" data-f="p:${esc(f.key)}"${key}${v ? ' checked' : ''}${off}>${esc(name)}</label>`;
+      else if (f.kind === 'enum') h += `<label>${esc(name)}<select data-f="p:${esc(f.key)}"${key}${off}>${['', ...arrOf(f.options)].map(o => `<option value="${esc(o)}"${o === v ? ' selected' : ''}>${esc(o)}</option>`).join('')}</select></label>`;
+      else h += text('p:' + f.key, f.kind === 'list' ? arrOf(v).join(', ') : v ?? '', name, key + (f.kind === 'list' ? ' data-list' : '')); });
     const rest = schema.length ? [] : Object.entries(P); // no schema: what it holds, to read
     if (rest.length) h += '<dl>' + rest.map(([k, v]) => `<dt>${esc(k)}</dt><dd>${esc(typeof v === 'string' ? v : JSON.stringify(v))}</dd>`).join('') + '</dl>';
-    if (e.kind === 'node') {
-      const ms = arrOf(x.members).filter(m => isRec(m) && typeof m.id === 'string');
-      h += '<h3>Members</h3><ul>' + ms.map((m, i) => `<li><input data-f="m:${esc(m.id)}" data-m="${esc(m.id)}" data-was="${esc(m.label ?? '')}" value="${esc(m.label ?? '')}" aria-label="Member ${i + 1} of ${ms.length}${can('reorder') ? ', Alt + arrows to move it' : ''}"${off}>`
+    const M = def().member;
+    if (e.kind === 'node' && !(M && M.holds && !M.holds(x))) { // a comment holds none
+      const ms = arrOf(x.members).filter(m => isRec(m) && typeof m.id === 'string'), line = m => M ? M.print(m) : m.label ?? ''; // a type's member text: "+ total: Money [1]" (1.9)
+      h += '<h3>Members</h3><ul>' + ms.map((m, i) => `<li><input data-f="m:${esc(m.id)}" data-m="${esc(m.id)}" data-was="${esc(line(m))}" value="${esc(line(m))}" aria-label="Member ${i + 1} of ${ms.length}${can('reorder') ? ', Alt + arrows to move it' : ''}"${off}>`
         + (can('reorder') ? `<button data-f="up:${esc(m.id)}" data-up="${esc(m.id)}" aria-label="Move ${esc(nameOf(m))} up">↑</button><button data-f="down:${esc(m.id)}" data-down="${esc(m.id)}" aria-label="Move ${esc(nameOf(m))} down">↓</button>` : '') + '</li>').join('')
         + '</ul>' + (can('add') ? '<input data-f="new" data-new placeholder="New member, Enter adds it" aria-label="New member">' : '');
     }
@@ -3772,15 +3652,19 @@ function typedEditor(api) {
 
   function commit(t) { // a field of the properties panel: one transaction
     const d = t.dataset, at = elementsOf(model()), id = selId(at);
+    const M = def().member, bad = why => { t.setAttribute('aria-invalid', 'true'); api.status(why); }; // a line the type cannot read: kept as written, nothing applied (E3)
     if (d.new != null) { const value = t.value.trim(), x = id && at.get(id); if (!value || !x || !can('add')) return;
-      const prev = arrOf(x.x.members).filter(isRec).pop(); t.value = '';
-      return emit([{ op: 'add', element: { ...typed(prev || {}, 'member'), label: value }, owner: id }]); }
+      const r = M && M.add(value, x.x); if (r && r.error) return bad(r.error);
+      const prev = arrOf(x.x.members).filter(isRec).pop(); t.value = ''; t.removeAttribute('aria-invalid');
+      return emit([{ op: 'add', element: r ? { ...typed(r, 'member'), label: r.label, ...(Object.keys(r.props).length ? { props: r.props } : {}) } : { ...typed(prev || {}, 'member'), label: value }, owner: id }]); }
     if (!can('rename') || (!id && d.m == null)) return;
     let value = t.type === 'checkbox' ? t.checked : t.value.trim();
     if (t.type !== 'checkbox') { if (t.value === d.was) return;
       if (value === '' && d.key == null) { t.value = d.was; return; } // an empty name does nothing, as on the map; an empty property is removed
-      d.was = t.value; if (value === '') value = undefined; }
-    const path = d.key == null ? 'label' : d.key.includes('.') ? ['props', d.key] : 'props.' + d.key;
+      if (d.m != null && M) { const m = (at.get(d.m) || {}).x, r = m && M.edit(m, value); if (!r || r.error) return bad(r ? r.error : 'not a member');
+        t.removeAttribute('aria-invalid'); d.was = t.value; return emit(r.commands); }
+      d.was = t.value; if (value === '') value = undefined; else if (d.list != null) value = value.split(',').map(x => x.trim()).filter(Boolean); }
+    const path = d.path ? ['props', ...JSON.parse(d.path)] : d.key == null ? 'label' : d.key.includes('.') ? ['props', d.key] : 'props.' + d.key;
     emit([{ op: 'set', id: d.m ?? id, path, value }]);
   }
   function moveMember(id, by) {
@@ -3805,7 +3689,7 @@ function typedEditor(api) {
       else if (d.orphans != null) { orphans = b.checked; put('.um-els', outline()); } });
     panel.addEventListener('change', e => { if (e.target.dataset.orphans == null) commit(e.target); });
     panel.addEventListener('keydown', e => { e.stopPropagation(); const t = e.target, K = e.key; // the panel's keys stay in it
-      if (K === 'Escape') { if (t.tagName === 'INPUT' && t.type !== 'checkbox') t.value = t.dataset.was ?? ''; api.focus(); } // what was typed is not kept
+      if (K === 'Escape') { if (t.tagName === 'INPUT' && t.type !== 'checkbox') { t.value = t.dataset.was ?? ''; t.removeAttribute('aria-invalid'); } api.focus(); } // what was typed is not kept
       else if (K === 'Enter' && t.tagName === 'BUTTON') { e.preventDefault(); t.click(); }
       else if (K === 'Enter' && t.tagName === 'INPUT' && t.type !== 'checkbox') { e.preventDefault(); commit(t); }
       else if (e.altKey && t.dataset.m != null && (K === 'ArrowUp' || K === 'ArrowDown')) { e.preventDefault(); moveMember(t.dataset.m, K === 'ArrowUp' ? -1 : 1); } });
@@ -4626,7 +4510,7 @@ export function render(container, model, options = {}) {
     const old = ctx, keys = {}, wantNew = selectNew && !own;
     old.views.forEach(v => { keys[v.id] = relayout ? null : old.viewKey(v.id); });
     current = model2;
-    ctx = mapContext(withPlaces(model2, use), { measure, kinds: !!P.kinds, prev: options.stableLayout === false ? null : old.planCache, expand: expanded });
+    ctx = mapContext(withPlaces(model2, use), { measure, kinds: !!P.kinds, prev: options.stableLayout === false ? null : old.planCache, expand: expanded, memos: relayout ? null : old.memos });
     Object.keys(expanded).forEach(v => { expanded[v] = ctx.unfolded[v] || []; }); // a card or inner view the model no longer has folds
     if (!own) selectNew = false;
     ctx.views.forEach(v => { const id = v.id; if (keys[id] == null || keys[id] !== ctx.viewKey(id)) return;
@@ -5130,9 +5014,10 @@ const SHAPE_SAYS = { person: ['Person', 'someone who uses it'], browser: ['Brows
 const swatchOf = (sh, k, c, f, dashed) => { const n = { x: 0, y: 0, w: 100, h: 64 }, S = SHAPE[sh]; // a legend's key: the card's outline, small
   return `<svg class="lgs" viewBox="-4 -4 108 72" aria-hidden="true"><path d="${S.out(n)}" fill="${f}" stroke="${c}"${dashed ? ' stroke-dasharray="3 2"' : ''}/>${S.det ? S.det(n, c, k) : ''}</svg>`; };
 function legendItems(gs, opens = 'double-click to open', notes = [], icons = {}) { // what these pictures draw, each with what it means: the view's legend, and the PDF's (#93). notes: each picture's notation (0.15.0)
-  const ns = gs.flatMap(g => g.nodes), es = gs.flatMap(g => g.edges), used = [...new Set(ns.map(n => n.k))];
+  const typedKeys = [...new Set(gs.flatMap(g => g.legend || []))]; // a typed view's type writes its own keys (1.9); its cards and lines are not a map's
+  const ns = gs.flatMap(g => g.legend ? [] : g.nodes), es = gs.flatMap(g => g.legend ? [] : g.edges), used = [...new Set(ns.map(n => n.k))];
   // each card as its picture's notation draws it: its shape, its dash and its mark (the legend draws what the map draws)
-  const cards = gs.flatMap((g, i) => { const nt = g.map ? noteOf(notes[i]) || 'box' : 'box';
+  const cards = gs.flatMap((g, i) => { if (g.legend) return []; const nt = g.map ? noteOf(notes[i]) || 'box' : 'box';
     return g.nodes.map(n => { const sh = shapeOf(n, nt), I = (icons || {})[n.icon]; // an icon the table lacks leaves the card the component mark, as svgOf draws it
       return { k: n.k, sh, dash: nt !== 'box' && n.k === 'external', comp: nt === 'uml' && sh === 'box' && !(I && (I.src || I.g)) && !String(n.k).startsWith('m-') }; }); });
   const kindShape = k => { const s = [...new Set(cards.filter(d => d.k === k).map(d => d.sh))]; return s.length === 1 && s[0] !== 'box' && !(k === 'm-hook' && s[0] === 'hexagon') ? s[0] : null; };
@@ -5150,7 +5035,7 @@ function legendItems(gs, opens = 'double-click to open', notes = [], icons = {})
     .concat(ns.some(n => n.step) ? ['<span class="lgi"><i class="num">1</i><b>Step</b><span>run order</span></span>'] : [])
     .concat(ns.some(n => n.tag) ? ['<span class="lgi"><i class="tag"></i><b>@author</b><span>who wrote it</span></span>'] : [])
     .concat(WIRES.filter(w => es.some(e => e.wk === w[0])).map(w => `<span class="lgi"><i class="w" style="border-color:var(--um-w-${w[0]})"></i><b>${w[1]}</b><span>${w[2]}</span></span>`))
-    .concat(es.some(e => e.back) ? ['<span class="lgi"><i class="w dash" style="border-color:var(--um-w-calls)"></i><b>loops back</b><span>the one line that runs right to left</span></span>'] : []);
+    .concat(es.some(e => e.back) ? ['<span class="lgi"><i class="w dash" style="border-color:var(--um-w-calls)"></i><b>loops back</b><span>the one line that runs right to left</span></span>'] : []).concat(typedKeys);
 }
 
 function pieces(X, el, o) {
@@ -5915,3 +5800,1109 @@ function printDoc(X, model, Q) {
   all.forEach((p, i) => { p.querySelector('.pn').textContent = `page ${i + 1} of ${all.length}`; });
   doc.querySelectorAll('[data-pg]').forEach(td => { td.textContent = all.findIndex(p => p.dataset.key === td.dataset.pg) + 1; });
 }
+/* A typed view's layout (work package 1.4): layoutGraph's plain layout with what a typed view needs, none of it on a map.
+   The parts of layoutPass only a typed view takes are here too (TYPED, registry.js); only lib/umlimator-all.js holds this
+   file, as a map never reaches it (risks.md C5).
+   Rows as tall as their tallest node (stage 1 note §4); a line from a node to itself drawn as a loop (risks.md F1); lines
+   between one pair each with its own ports and label (F2); `direction: "down"` (note §6); and a memo that lays the view out
+   again only when its geometry changed (F7). Nodes come with their sizes, `w` and `h`, which their shapes give (1.5). */
+
+// what moves a typed view's geometry: every field of the view layoutGraph reads but VIEW_PAINT (a test holds the two lists to
+// layered.js), and these of a node and a line. Anything else (a colour, a `props` field) only repaints
+const VIEW_GEO = ['abs', 'authors', 'blocks', 'containers', 'direction', 'fan', 'flipped', 'gap', 'groups', 'hub', 'intake', 'laneGap', 'lanes', 'mainSteps', 'nodeH', 'quick', 'repair', 'rgap', 'turned', 'typed'];
+const VIEW_PAINT = ['tour', 'subAndChips'], NODE_GEO = ['id', 'col', 'row', 'w', 'h', 'ax', 'ay'], EDGE_GEO = ['id', 'from', 'to', 'label', 'step', 'fromSide', 'toSide', 'back', 'fixed', 'sublabel'];
+const geometryKey = dg => JSON.stringify([VIEW_GEO.map(k => dg[k]), (dg.nodes || []).map(n => NODE_GEO.map(k => n[k])), (dg.edges || []).map(e => EDGE_GEO.map(k => e[k]))]);
+
+// direction "down": laid out left to right with every box turned, then turned back, x for y and the sides L for T, R for B
+const SIDE_T = { L: 'T', T: 'L', R: 'B', B: 'R' }, swapXY = p => [p[1], p[0]];
+const flipBox = r => { if (r) [r.x, r.y, r.w, r.h] = [r.y, r.x, r.h, r.w]; };
+function transpose(g) {
+  [...g.nodes, ...(g.families || []), g.bounds].forEach(flipBox);
+  (g.groups || []).forEach(r => { [r.x, r.y, r.x2, r.y2] = [r.y, r.x, r.y2, r.x2]; });
+  g.edges.forEach(e => { e.pts = e.pts.map(swapXY); if (e.fixed) e.fixed = e.pts; e.p1 = swapXY(e.p1); e.p2 = swapXY(e.p2);
+    e.fs = SIDE_T[e.fs]; e.ts = SIDE_T[e.ts]; e.stubs = (e.stubs || []).map(s => s.map(swapXY)); flipBox(e.lbl); });
+  return g;
+}
+
+// the geometry kept, with the paint of the view given in place of the paint it was laid out with: each node's own fields, and
+// each line's, by its id (typed lines have ids); a field the view no longer gives goes. The geometric fields are the same in both
+function repaint(g, was, dg) {
+  const by = (list, key) => new Map((list || []).filter(x => x && x[key] != null).map(x => [x[key], x]));
+  [[g.nodes, was.nodes, dg.nodes], [g.edges, was.edges, dg.edges]].forEach(([out, a, b]) => { const A = by(a, 'id'), B = by(b, 'id');
+    out.forEach(x => { const old = A.get(x.id), now = B.get(x.id); if (!now) return; for (const k in old) if (!(k in now)) delete x[k]; Object.assign(x, now); }); });
+  return g;
+}
+
+/* dg: layoutGraph's input, with `direction` ("right", the default, or "down"). memo: an object kept for the view between
+   calls; while the geometry key is the same, the geometry it holds is repainted and returned, and nothing is laid out or
+   routed. memo.runs counts the layouts. */
+function layoutTyped(dg, memo) {
+  const key = memo && geometryKey(dg);
+  if (memo && memo.key === key) { const g = repaint(memo.g, memo.dg, dg); memo.dg = dg; return g; }
+  const t = { ...dg, typed: true }, g = dg.direction === 'down'
+    ? transpose(layoutGraph({ ...t, turned: true, nodes: (dg.nodes || []).map(n => ({ ...n, w: n.h || dg.nodeH || 64, h: n.w || NW })) }, false))
+    : layoutGraph(t, false);
+  if (memo) Object.assign(memo, { key, g, dg, runs: (memo.runs || 0) + 1 });
+  return g;
+}
+
+// A typed view's lines from a node to itself (risks.md F1) are loops round its top right corner, nested, the first innermost:
+// each one's top run D px above the node, its label on that run clear of the node's stub room and of the loop inside; its
+// right run R px right of the node, far enough for the top run to hold the label. out: how far each loop's port on the
+// node's top lies left of its right side (0 before ports are known, for the room: above the node's row, right of its column)
+const loopDims = (dg, STUB, SEP) => (list, out) => { let D = 0, R = 0, half = 0;
+  return list.map((e, k) => { const lw = e.label || e.step != null ? labelW(e) : 0, [bw, bh] = dg.turned ? [lw && 18, lw] : [lw, lw && 18];
+    D = k ? D + half + bh / 2 + 10 : STUB + 6 + bh / 2; half = bh / 2;
+    R = Math.max(k ? R + 2 * SEP : STUB + 4, bw + 12 - out[k]); return { D, R, top: D + half }; }); };
+// layoutPass's loops (LP): fills loops (by node id, the lines from it to itself) and makes room for them; then mark(edges),
+// each such line routed here, not by the router; ports(pushSide): the top port of the node's right side and the right port
+// of its top, the inner loop the nearer the corner; route(): each loop out of the right side, up, left and down into the
+// top, and its corners, which the other routes keep SEP px off, so none touches it or turns where it does
+TYPED.loops = (loops, dg, { byId, extraX, extraY, STUB, RG, CG, SEP, gapAfter }) => {
+  const dims = loopDims(dg, STUB, SEP); let edges = [];
+  (dg.edges || []).forEach(e => { if (e.from === e.to && byId[e.from]) (loops[e.from] ||= []).push(e); });
+  Object.entries(loops).forEach(([id, list]) => { const n = byId[id], d = dims(list, list.map(() => 0)).at(-1);
+    extraY[n.row - .5] = Math.max(extraY[n.row - .5] || 0, d.top + STUB + 7 - RG);
+    extraX[n.col] = Math.max(extraX[n.col] || 0, d.R + STUB + 6 - Math.max(CG, gapAfter[n.col] || 0)); });
+  const loopsOf = n => edges.filter(e => e[OWN_ROUTE] === 'loop' && e.s === n);
+  return {
+    mark(all) { edges = all; edges.forEach(e => { if (e.s === e.t) Object.assign(e, { [OWN_ROUTE]: 'loop', fixed: true, fs: 'R', ts: 'T', stubs: [], how: 'self' }); }); }, // its loop is drawn once its ports are known
+    ports: pushSide => edges.filter(e => e[OWN_ROUTE] === 'loop').forEach(e => { const n = e.s, k = loopsOf(n).indexOf(e);
+      pushSide(n, 'R', e, { x: n.x + n.w, y: -1e6 + k, w: 0, h: 0 }); pushSide(n, 'T', e, { x: 1e6 - k, y: n.y, w: 0, h: 0 }); }),
+    route() { const corners = []; [...new Set(edges.filter(e => e[OWN_ROUTE] === 'loop').map(e => e.s))].forEach(n => { const list = loopsOf(n);
+      dims(list, list.map(e => n.x + n.w - e.p2[0])).forEach(({ D, R }, k) => { const e = list[k], x = n.x + n.w + R, y = n.y - D;
+        e.pts = e.fixed = [e.p1, [x, e.p1[1]], [x, y], [e.p2[0], y], e.p2];
+        e.pts.slice(1, 4).forEach(([px, py]) => corners.push({ x: px - SEP, y: py - SEP, w: 2 * SEP, h: 2 * SEP })); }); });
+      return corners; },
+  };
+};
+
+// a typed view's rows (stage 1 note §4): each as tall as its tallest node, a node on a half row counting toward both rows, and
+// NH with none. With every node NH tall, the pitch is a map's. at(r): a row's top; ht(r): its height, a half row's the taller of its two
+TYPED.rows = (dg, nodes, pitch, NH, RG) => {
+  const rowH = {}, rowTop = {}; if (!dg.abs && nodes.length) {
+    nodes.forEach(n => [Math.floor(n.row), Math.ceil(n.row)].forEach(k => { rowH[k] = Math.max(rowH[k] ?? 0, n.h); }));
+    const r0 = Math.min(...Object.keys(rowH).map(Number)), r1 = Math.max(...Object.keys(rowH).map(Number));
+    for (let k = r0, y = r0 * pitch; k <= r1 + 1; k++) { rowTop[k] = y; y += (rowH[k] ?? NH) + RG; } }
+  return { at: r => { const k = Math.floor(r), f = r - k; return rowTop[k] == null || rowTop[k + 1] == null ? r * pitch : rowTop[k] + f * (rowTop[k + 1] - rowTop[k]); },
+    ht: r => Math.max(rowH[Math.floor(r)] ?? NH, rowH[Math.ceil(r)] ?? NH) };
+};
+
+// A view laid out down (turned): the labels of lines between one pair are wider than the 16 px between the lines, so the
+// lines fan out in the gap between the pair's columns, each to a lane of its own that holds its label. Above the middle, the
+// outer line turns nearer each node, so none crosses another; a group the gap or another node leaves no room for goes to the router
+TYPED.fan = (free, { simplify, through, STUB, SEP }) => { const pairs = new Map(), lr = e => e.fs === 'R' ? [e.p1, e.p2] : [e.p2, e.p1];
+  free.forEach(e => { const [l, r] = e.fs === 'R' ? [e.s, e.t] : [e.t, e.s], k = l.id + '\u0001' + r.id;
+    if (/^(RL|LR)$/.test(e.fs + e.ts) && l.x + l.w < r.x) pairs.set(k, [...(pairs.get(k) || []), e]); });
+  pairs.forEach(list => { if (list.length < 2 || !list.some(e => e.label || e.step != null)) return;
+    list.sort((a, b) => lr(a)[0][1] - lr(b)[0][1]); if (list.some((e, i) => i && lr(e)[1][1] <= lr(list[i - 1])[1][1])) return;
+    const bh = list.map(e => e.label || e.step != null ? labelW(e) : 0), gaps = bh.map((h, i) => i ? Math.max(SEP, (bh[i - 1] + h) / 2 + 6) : 0);
+    const mid = list.reduce((a, e) => a + lr(e)[0][1] + lr(e)[1][1], 0) / (2 * list.length), lanes = [];
+    gaps.reduce((y, g, i) => (lanes[i] = y + g), mid - gaps.reduce((a, g) => a + g, 0) / 2);
+    // each line's turn on each side: the k-th line turning towards its lane from the outside turns k SEP px past the stub
+    const turns = side => { const at = []; const up = list.map((e, i) => i).filter(i => lanes[i] < lr(list[i])[side][1]), down = list.map((e, i) => i).filter(i => lanes[i] >= lr(list[i])[side][1]).reverse();
+      [up, down].forEach(g => g.forEach((i, k) => { at[i] = lr(list[i])[side][0] + (side ? -1 : 1) * (STUB + k * SEP); })); return at; };
+    const xl = turns(0), xr = turns(1);
+    if (Math.min(...xr) - Math.max(...xl) < 18 + 16) return;
+    const pts = list.map((e, i) => { const [a, b] = lr(e), P = simplify([a, [xl[i], a[1]], [xl[i], lanes[i]], [xr[i], lanes[i]], [xr[i], b[1]], b]); return e.fs === 'R' ? P : P.reverse(); });
+    if (list.some((e, i) => through(pts[i], e))) return;
+    list.forEach((e, i) => { Object.assign(e, { [OWN_ROUTE]: 'fan', fixed: pts[i], pts: pts[i], stubs: [], how: 'fan' }); free.splice(free.indexOf(e), 1); }); }); };
+/* What a typed view draws and a map never does (risks.md C5): the classifier shape, a typed line's ends and its end labels.
+   Only lib/umlimator-all.js holds this file; it installs SHAPE.classifier and TYPED.lines (registry.js) as it loads. */
+
+// ---- the classifier (1.5). Its drawing input, on a typed view's node (not the model: 1.9 fills it from the model and the
+// view's present; a map never draws it): shape 'classifier'; label; type ('uml.Class', named in its accessible name);
+// stereotypes [text], shown «…» over the name; abstract (the name in italics); compartments [{ name, members }] in order
+// ('attributes', 'operations', 'literals'), each member in the model's envelope ({ type, label, props }); collapsed
+// [compartment names], hidden with no divider; rows: at most that many rows in a compartment, then "+k more" (stage 1 note §5)
+const CL = { pad: 8, name: 13, row: 11, st: 14, nl: 18, rl: 15, gap: 5, empty: 10, minW: 96, maxW: 320 };
+const VIS = { public: '+', private: '-', protected: '#', package: '~' };
+// a member's row in UML's form: "+ total: Money [1]", "+ /count: Integer = 0", "+ place(at: Date): Order"; a literal's label
+const obj = x => !!x && typeof x === 'object'; // an entry the classifier reads; null, text or a number is passed over
+function memberText(m) { const p = obj(m.props) ? m.props : {}, has = x => x != null && x !== '', name = (hasKey(VIS, p.visibility) ? VIS[p.visibility] + ' ' : '') + (p.isDerived ? '/' : '') + (m.label ?? '');
+  if (/Operation$/.test(m.type || '')) return name + '(' + (Array.isArray(p.parameters) ? p.parameters.filter(obj) : []).map(a => (has(a.direction) && a.direction !== 'in' ? a.direction + ' ' : '') + (a.name ?? '') + (has(a.valueType) ? ': ' + a.valueType : '')).join(', ') + ')' + (has(p.returnType) ? ': ' + p.returnType : '');
+  return name + (has(p.valueType) ? ': ' + p.valueType : '') + (has(p.multiplicity) ? ` [${p.multiplicity}]` : '') + (has(p.default) ? ' = ' + p.default : ''); }
+// the classifier as drawn: its stereotypes, its compartments (all: every one, each with every member; comps: those shown,
+// with their rows and how many they leave out), the head's height, and the size its text needs: as wide as its widest text,
+// within minW and maxW (a longer row is cut: classSvg). An abstract name is in italics, which the measure (upright) does
+// not see: it is measured a tenth wider (slant)
+function classParts(n) {
+  const hidden = new Set(Array.isArray(n.collapsed) ? n.collapsed : []), cap = Number.isFinite(n.rows) ? Math.max(0, Math.floor(n.rows)) : Infinity, slant = n.abstract ? 1.1 : 1;
+  const stereo = (Array.isArray(n.stereotypes) ? n.stereotypes : []).filter(t => t != null && t !== '').map(String), st = stereo.map(t => `«${t}»`);
+  const all = (Array.isArray(n.compartments) ? n.compartments : []).filter(obj).map(c => ({ name: String(c.name ?? ''), members: Array.isArray(c.members) ? c.members.filter(obj) : [] }));
+  const comps = all.filter(c => !hidden.has(c.name)).map(c => ({ name: c.name, rows: c.members.slice(0, cap).map(m => ({ m, text: memberText(m) })), more: Math.max(0, c.members.length - cap) }));
+  const texts = [[n.label ?? '', CL.name, slant], ...st.map(t => [t, CL.row, 1]), ...comps.flatMap(c => [...c.rows.map(r => [r.text, CL.row, 1]), ...(c.more ? [[`+${c.more} more`, CL.row, 1]] : [])])];
+  const w = Math.ceil(Math.min(CL.maxW, Math.max(CL.minW, ...texts.map(([t, px, k]) => textW(t, px) * k + 2 * CL.pad))));
+  const head = 2 * CL.gap + st.length * CL.st + CL.nl, tall = c => { const k = c.rows.length + (c.more ? 1 : 0); return k ? 2 * CL.gap - 2 + k * CL.rl : CL.empty; };
+  return { stereo, st, all, comps, head, tall, slant, size: { w, h: comps.reduce((a, c) => a + tall(c), head) } };
+}
+const words = t => String(t).split('.').pop().replace(/([a-z])([A-Z])/g, (_, a, b) => a + ' ' + b.toLowerCase()); // 'uml.DataType': "Data type"
+function classSvg(n, c, f) { // its outline, its head, then each compartment under a divider, every text cut to the box (fit)
+  const { stereo, st, all, comps, head, tall, slant } = classParts(n), { x, y, w, h } = n, max = w - 2 * CL.pad, cx = r2(x + w / 2);
+  const font = (px, wt, it) => `style="font:${it ? 'italic ' : ''}${wt} ${px}px var(--um-sans)"`;
+  const row = (cls, fill, ty, t, more = '') => `<text x="${r2(x + CL.pad)}" y="${r2(ty)}" class="${cls}" fill="${fill}"${more}>${esc(fit(t, CL.row, max))}</text>`;
+  const out = [`<rect x="${x}" y="${y}" width="${w}" height="${h}" class="n-mask"/><rect x="${x}" y="${y}" width="${w}" height="${h}" class="n-body" fill="${f}" stroke="${c}"/>`];
+  let ty = y + CL.gap; const hd = [];
+  st.forEach(t => { hd.push(`<text x="${cx}" y="${r2(ty + 11)}" text-anchor="middle" class="c-st" fill="var(--um-muted)" ${font(CL.row, 400)}>${esc(fit(t, CL.row, max))}</text>`); ty += CL.st; });
+  hd.push(`<text x="${cx}" y="${r2(ty + 14)}" text-anchor="middle" class="c-name" fill="var(--um-text)" ${font(CL.name, 600, n.abstract)} data-o="${esc(n.id)}">${esc(fit(n.label ?? '', CL.name, max / slant))}</text>`);
+  out.push(`<g class="c-head" data-band="${r2(y)} ${r2(y + head)}">${hd.join('')}</g>`);
+  let top = y + head;
+  comps.forEach((C, i) => { const bh = i === comps.length - 1 ? Math.max(y + h - top, 0) : tall(C), at = j => top + CL.gap - 1 + j * CL.rl + 11.5;
+    const rows = C.rows.map((r, j) => { const p = obj(r.m.props) ? r.m.props : {};
+      return row('c-row', 'var(--um-text)', at(j), r.text, ` ${font(CL.row, 400, /Operation$/.test(r.m.type || '') && p.isAbstract)}${p.isStatic ? ' text-decoration="underline"' : ''}`); });
+    if (C.more) rows.push(row('c-more', 'var(--um-muted)', at(C.rows.length), `+${C.more} more`, ` ${font(CL.row, 400)}`));
+    out.push(`<g class="c-comp" data-comp="${esc(C.name)}" data-band="${r2(top)} ${r2(top + bh)}"><path d="M${x} ${r2(top)}H${x + w}" class="n-det" stroke="${c}"/>${rows.join('')}</g>`);
+    top += bh; });
+  // its accessible name (A1): "Class Order (entity, abstract), 2 attributes, 1 operation", every member counted, shown or not
+  const counts = all.map(C => `${C.members.length} ${C.members.length === 1 ? C.name.replace(/s$/, '') : C.name}`), why = [...stereo, ...(n.abstract ? ['abstract'] : [])];
+  const name = [`${words(n.type || 'uml.Class')} ${n.label ?? ''}${why.length ? ` (${why.join(', ')})` : ''}`, ...counts].join(', ');
+  return `<g class="node classifier" data-id="${esc(n.id)}" data-shape="classifier" tabindex="-1" role="img" aria-label="${esc(name)}">${out.join('')}</g>`;
+}
+const CLASSIFIER = { // UML's class box (1.5): a rectangle, its name compartment, then one compartment per member kind (classParts)
+  size: n => classParts(n).size, out: boxOut(0), face: n => [n.y, n.y + n.h], inset: () => 0, draw: classSvg };
+CLASSIFIER.ports = (n, side, k = 1) => portsOn(CLASSIFIER, n, side, k);
+SHAPE.classifier = CLASSIFIER;
+
+// A typed view's line (1.5; a map's lines never read it) says how it is drawn in e.end: { from, to, dashed, labels }. from
+// and to name an end in this table, the line's ends as UML draws them (none, or a name it does not hold, draws no marker);
+// dashed: a dependency's or realization's line; labels: each end's role and multiplicity (endLabels). Each end: [its
+// length, half its height, its path pointing right with the tip at its length, its fill]. Its tip is where the line ends,
+// on the node's outline. Hollow is the stage's background, filled the line's own colour (T2), in either theme
+const ENDS = { none: null, arrow: [10, 4, 'M0 0L10 4L0 8Z', 'line'], open: [10, 5, 'M0 0L10 5L0 10', 'none'], triangle: [13, 7, 'M0 0L13 7L0 14Z', 'hollow'],
+  diamond: [16, 6, 'M0 6L8 0L16 6L8 12Z', 'hollow'], 'filled-diamond': [16, 6, 'M0 6L8 0L16 6L8 12Z', 'line'] };
+const endOf = (E, w) => hasKey(ENDS, E[w]) && ENDS[E[w]] ? E[w] : null;
+
+// a typed line's end labels (1.5): each end's role and multiplicity (e.end.labels: { from: { role, mult }, to: { role, mult } }),
+// each in a box reserved by its end. First choice: 4 px out from the outline along the line, 8 px to one side of it, clear of
+// the end's marker; the role above a line that leaves sideways and left of one that leaves up or down, the multiplicity on
+// the other side. A box that would meet a segment of its own line (7.5 px round it, so markers too), either end's node or
+// a box placed before it moves away from the line, 4 px at a time, on its side and then the other, at the end or centred
+// across it (a short end segment, a loop). pts: the line as drawn; e.s and e.t: its nodes. Layout (1.4) may take the boxes
+// as obstacles; it moves them apart where many lines meet (L5)
+function endLabels(e, pts = e.pts, also = []) { // also: boxes to keep clear of too (other lines, their labels: svgOf)
+  const T = e.end && e.end.labels, out = []; if (!T || !pts || pts.length < 2) return out;
+  const meets = (a, b) => a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
+  const keep = [...pts.slice(1).map((q, i) => { const p = pts[i]; return { x: Math.min(p[0], q[0]) - 7.5, y: Math.min(p[1], q[1]) - 7.5, w: Math.abs(q[0] - p[0]) + 15, h: Math.abs(q[1] - p[1]) + 15 }; }),
+    ...[e.s, e.t].filter(n => n && Number.isFinite(n.x)).map(n => ({ x: n.x - 2, y: n.y - 2, w: n.w + 4, h: n.h + 4 })), ...also];
+  [['from', pts[0], pts[1]], ['to', pts[pts.length - 1], pts[pts.length - 2]]].forEach(([end, p, q]) => {
+    const at = T[end] || {}, flat = Math.abs(q[0] - p[0]) >= Math.abs(q[1] - p[1]), dir = Math.sign(flat ? q[0] - p[0] : q[1] - p[1]) || 1;
+    [['role', at.role, -1], ['mult', at.mult, 1]].forEach(([kind, t, side]) => { if (t == null || t === '') return;
+      const w = r2(textW(t, 10) + 6), h = 14, along = (v, d, mid) => mid ? v - d / 2 : dir > 0 ? v + 4 : v - 4 - d, aside = (v, d, s, o) => s < 0 ? v - o - d : v + o;
+      const box = (o, s, mid) => ({ end, kind, text: String(t), x: r2(flat ? along(p[0], w, mid) : aside(p[0], w, s, o)), y: r2(flat ? aside(p[1], h, s, o) : along(p[1], h, mid)), w, h });
+      let b = null;
+      for (let o = 8; !b && o <= 400; o += 4) for (const s of [side, -side]) for (const mid of [false, true]) { const c = box(o, s, mid); if (!b && ![...keep, ...out].some(k => meets(c, k))) b = c; }
+      out.push(b || box(8, side, false)); }); });
+  return out;
+}
+
+// svgOf's typed lines (TYPED.lines): { id, edges, drawn, lstyle, MC } -> defs, the markers of the ends drawn; edge(e, i), a
+// line with ends: its style, its points trimmed for its flow, its markers; labels(i): its end labels' text
+TYPED.lines = ({ id, edges, drawn, lstyle, MC }) => {
+  const ends = [...new Set(edges.flatMap(e => e.end ? ['from', 'to'].map(w => endOf(e.end, w)).filter(Boolean).map(k => k + '-' + lstyle(e).m) : []))];
+  const endMark = km => { const k = km.slice(0, km.lastIndexOf('-')), m = km.slice(k.length + 1), [L, H, p, fl] = ENDS[k];
+    return `<marker id="${id}-${km}" markerWidth="${L}" markerHeight="${2 * H}" refX="${L}" refY="${H}" orient="auto-start-reverse" markerUnits="userSpaceOnUse" overflow="visible"><path d="${p}" fill="${fl === 'line' ? MC[m] : fl === 'hollow' ? 'var(--um-stage-bg)' : 'none'}" stroke="${MC[m]}" stroke-width="1.5" stroke-linejoin="round" stroke-linecap="round"/></marker>`; };
+  // a typed line's end labels keep clear of the other lines, their labels and the end labels placed before them (1.9, L5)
+  const segs = drawn.map(p => p.slice(1).map((q, k) => ({ x: Math.min(p[k][0], q[0]) - 3, y: Math.min(p[k][1], q[1]) - 3, w: Math.abs(q[0] - p[k][0]) + 6, h: Math.abs(q[1] - p[k][1]) + 6 }))), placed = [];
+  const endLabs = i => { const bs = endLabels(edges[i], drawn[i], [...placed, ...segs.flatMap((S, j) => j === i ? [] : [...S, ...(edges[j].lbl ? [edges[j].lbl] : [])])]); placed.push(...bs); return bs; };
+  return {
+    defs: ends.map(endMark).join(''),
+    edge(e, i) { const E = e.end; if (!E) return null;
+      const st = E.dashed ? { ...lstyle(e), dash: '6 4' } : lstyle(e), cut = w => endOf(E, w) ? ENDS[endOf(E, w)][0] : 0, at = w => endOf(E, w) ? `url(#${id}-${endOf(E, w)}-${st.m})` : '';
+      return { st, pts: trimLine(drawn[i], cut('from'), cut('to')), marks: `${at('to') ? `marker-end="${at('to')}"` : ''} ${at('from') ? `marker-start="${at('from')}"` : ''}` }; },
+    labels: i => edges[i].end ? endLabs(i).map(b => `<text x="${r2(b.x + b.w / 2)}" y="${r2(b.y + 10.5)}" text-anchor="middle" class="end-lab" data-i="${i}" data-end="${b.end}" data-box="${b.x} ${b.y} ${b.w} ${b.h}" fill="var(--um-muted)" style="font:500 10px var(--um-sans)">${esc(b.text)}</text>`).join('') : '',
+  };
+};
+/* ---------- the class diagram, uml.class (work package 1.9) ----------
+   The subset of proposal.md §8.2: class, interface, enumeration with literals, data type, primitive type; attributes and
+   operations in UML's text form; stereotypes as text; packages as owners (drawn as a node until stage 2 draws ownership);
+   association with both ends, generalization, interface realization, dependency; comments. A view whose `diagram` is
+   'uml.class' is laid out by layoutTyped (src/typed/layout.js) and drawn with the classifier shape and the line-end table
+   (src/typed/draw.js). Ships in lib/umlimator-all.js only (stage 1 note §2.5). */
+
+const UML_OBJ = x => x !== null && typeof x === 'object' && !Array.isArray(x), UML_ARR = x => (Array.isArray(x) ? x : []);
+const UML_HAS = x => x != null && x !== '';
+const UML_OWN = (o, k) => (o != null && Object.hasOwn(o, k) ? o[k] : undefined); // a lookup by a model's id or type: 'constructor' is not Object's (risks.md M3)
+
+/* ---- the member micro-syntax (risks.md E3, E4) ----
+   A property:  [visibility] [{static}] [/]name [: Type] [[multiplicity]] [= default]      + {static} /total: Money [1] = 0
+   An operation: [visibility] [{static}] [{abstract}] name([direction] name: Type, …) [: Type]   + place(at: Date, in qty: Int): Order
+   A literal:   name
+   A name is letters of any script, digits, _ and $; a type may end in [] (String[]). Visibility is + - # ~. A multiplicity is n, *, n..m or n..*, its text kept as written. parseMember() returns
+   { type, label, props } or { error }; printMember() writes a member back, and print(parse(x)) is stable. */
+const MEMBER_SIGN = { public: '+', private: '-', protected: '#', package: '~' }, SIGN_VIS = { '+': 'public', '-': 'private', '#': 'protected', '~': 'package' };
+const MEMBER_NAME = /^[\p{L}_$][\p{L}\p{M}\p{N}_$]*/u; // a name in any script: Größe, 名前
+const SYNTAX_KEYS = ['visibility', 'valueType', 'multiplicity', 'default', 'isStatic', 'isDerived', 'isAbstract', 'parameters', 'returnType'];
+
+/* a multiplicity's bounds: '1', '*', '0..1', '1..*', '2..5' → { lower, upper } (upper Infinity for *); null for anything else */
+function multBounds(t) {
+  const m = /^\s*(\d+|\*)\s*(?:\.\.\s*(\d+|\*)\s*)?$/.exec(String(t ?? ''));
+  if (!m || (m[2] != null && m[1] === '*')) return null;
+  const n = x => (x === '*' ? Infinity : +x);
+  return m[2] == null ? (m[1] === '*' ? { lower: 0, upper: Infinity } : { lower: +m[1], upper: +m[1] }) : { lower: +m[1], upper: n(m[2]) };
+}
+
+// s split at each `sep` outside brackets of any kind: "a: Map<K, V>, b" → ["a: Map<K, V>", " b"]
+function splitTop(s, sep) {
+  const out = []; let depth = 0, from = 0;
+  for (let i = 0; i < s.length; i++) { const c = s[i];
+    if ('<([{'.includes(c)) depth++; else if ('>)]}'.includes(c)) depth--;
+    else if (c === sep && depth === 0) { out.push(s.slice(from, i)); from = i + 1; } }
+  out.push(s.slice(from));
+  return out;
+}
+
+/* text: a member's line; kind: the member type wanted ('uml.Property', 'uml.Operation', 'uml.EnumerationLiteral'), or
+   none to read it from the text (an operation has brackets). Hand-written and linear (risks.md R2) */
+function parseMember(text, kind) {
+  let s = String(text ?? '').trim();
+  const fail = why => ({ error: `"${String(text ?? '').trim()}" is not a member: ${why}` });
+  if (!s) return fail('it is empty');
+  if (kind === 'uml.EnumerationLiteral') return MEMBER_NAME.test(s) && MEMBER_NAME.exec(s)[0] === s ? { type: kind, label: s, props: {} } : fail('a literal is a name');
+  const props = {};
+  if (SIGN_VIS[s[0]]) { props.visibility = SIGN_VIS[s[0]]; s = s.slice(1).trim(); }
+  for (let m; (m = /^\{\s*(static|abstract)\s*\}\s*/.exec(s));) { props[m[1] === 'static' ? 'isStatic' : 'isAbstract'] = true; s = s.slice(m[0].length); }
+  if (s[0] === '{') return fail('a modifier is {static} or {abstract}');
+  if (s[0] === '/') { props.isDerived = true; s = s.slice(1).trim(); }
+  const nm = MEMBER_NAME.exec(s); if (!nm) return fail('a name comes first, after the visibility (+ - # ~)');
+  const label = nm[0]; s = s.slice(label.length).trim();
+  const op = kind === 'uml.Operation' || (kind == null && s[0] === '(');
+  if (op) {
+    if (s[0] !== '(') return fail('an operation\'s name is followed by its parameters in brackets');
+    if (props.isDerived) return fail('an operation is not derived (/)');
+    let depth = 0, end = -1;
+    for (let i = 0; i < s.length && end < 0; i++) { if (s[i] === '(') depth++; else if (s[i] === ')' && --depth === 0) end = i; }
+    if (end < 0) return fail('a bracket is not closed');
+    const inner = s.slice(1, end).trim(), rest = s.slice(end + 1).trim(), params = [];
+    for (const part of inner ? splitTop(inner, ',') : []) {
+      let p = part.trim(); const a = {}, d = /^(in|out|inout|return)\s+/.exec(p);
+      if (d) { a.direction = d[1]; p = p.slice(d[0].length); }
+      const pn = MEMBER_NAME.exec(p); if (!pn) return fail(`parameter "${part.trim()}" has no name`);
+      a.name = pn[0]; p = p.slice(pn[0].length).trim();
+      if (p) { if (p[0] !== ':' || !p.slice(1).trim()) return fail(`parameter "${part.trim()}" is name: Type`); a.valueType = p.slice(1).trim(); }
+      params.push({ name: a.name, ...(a.valueType != null ? { valueType: a.valueType } : {}), ...(a.direction ? { direction: a.direction } : {}) });
+    }
+    if (params.length) props.parameters = params;
+    if (rest) { if (rest[0] !== ':' || !rest.slice(1).trim()) return fail('after the parameters comes : ReturnType'); props.returnType = rest.slice(1).trim(); }
+    return { type: 'uml.Operation', label, props };
+  }
+  if (props.isAbstract) return fail('a property is not {abstract}');
+  if (s[0] === ':') { // the type: up to a multiplicity or a default outside brackets
+    let i = 1, depth = 0;
+    for (; i < s.length; i++) { const c = s[i]; if (c === '<' || c === '(') depth++; else if (c === '>' || c === ')') depth--; else if (depth === 0 && c === '[' && s[i + 1] === ']') i++; else if (depth === 0 && (c === '[' || c === '=')) break; } // String[]: an array type, not a multiplicity
+    const t = s.slice(1, i).trim(); if (!t) return fail('a type follows the colon');
+    props.valueType = t; s = s.slice(i).trim();
+  }
+  if (s[0] === '[') {
+    const end = s.indexOf(']'); if (end < 0) return fail('a multiplicity is closed by ]');
+    const mult = s.slice(1, end).trim(); if (!multBounds(mult)) return fail(`[${mult}] is not a multiplicity (1, *, 0..1, 1..*)`);
+    props.multiplicity = mult; s = s.slice(end + 1).trim();
+  }
+  if (s[0] === '=') { const d = s.slice(1).trim(); if (!d) return fail('a default follows ='); props.default = d; s = ''; }
+  if (s) return fail(`"${s}" is left over: write name: Type [multiplicity] = default`);
+  return { type: 'uml.Property', label, props };
+}
+
+/* a member back in its text form: the inverse of parseMember */
+function printMember(m) {
+  const p = UML_OBJ(m && m.props) ? m.props : {}, label = String((m && m.label) ?? '');
+  if (m && m.type === 'uml.EnumerationLiteral') return label;
+  const head = (Object.hasOwn(MEMBER_SIGN, p.visibility) ? MEMBER_SIGN[p.visibility] + ' ' : '') + (p.isStatic ? '{static} ' : '') + (p.isAbstract ? '{abstract} ' : '');
+  if (m && m.type === 'uml.Operation') return head + label + '(' + UML_ARR(p.parameters).filter(UML_OBJ).map(a => (UML_HAS(a.direction) ? a.direction + ' ' : '') + (a.name ?? '') + (UML_HAS(a.valueType) ? ': ' + a.valueType : '')).join(', ') + ')' + (UML_HAS(p.returnType) ? ': ' + p.returnType : '');
+  return head + (p.isDerived ? '/' : '') + label + (UML_HAS(p.valueType) ? ': ' + p.valueType : '') + (UML_HAS(p.multiplicity) ? ` [${p.multiplicity}]` : '') + (UML_HAS(p.default) ? ' = ' + p.default : '');
+}
+
+/* a member edited as text: the commands that set it, one transaction; { error } when the text does not parse, and then
+   nothing is applied (E3). Props the syntax does not write (stereotypes, a host's own) are kept */
+function memberEdit(m, text) {
+  const r = parseMember(text, m.type === 'uml.Property' || m.type === 'uml.Operation' || m.type === 'uml.EnumerationLiteral' ? m.type : undefined);
+  if (r.error) return r;
+  const keep = Object.fromEntries(Object.entries(UML_OBJ(m.props) ? m.props : {}).filter(([k]) => !SYNTAX_KEYS.includes(k)));
+  return { commands: [{ op: 'set', id: m.id, path: 'label', value: r.label }, { op: 'set', id: m.id, path: 'props', value: { ...keep, ...r.props } }] };
+}
+
+/* a line typed into an owner's "New member": on an enumeration a bare name is a literal, anything else a property or an operation */
+function memberAdd(text, owner) {
+  const t = String(text ?? '').trim(), nm = MEMBER_NAME.exec(t);
+  return parseMember(t, owner && owner.type === 'uml.Enumeration' && nm && nm[0] === t ? 'uml.EnumerationLiteral' : undefined);
+}
+
+/* ---- the vocabulary (model.md, uml.class) ---- */
+const CLASSIFIERS = ['uml.Class', 'uml.Interface', 'uml.Enumeration', 'uml.DataType', 'uml.PrimitiveType'];
+const IMPLIED = { 'uml.Interface': 'interface', 'uml.Enumeration': 'enumeration', 'uml.DataType': 'dataType', 'uml.PrimitiveType': 'primitive' }; // shown «…» over the name
+const STEREO = { key: 'stereotypes', label: 'Stereotypes', kind: 'list' };
+const endFields = w => [['role', 'text'], ['multiplicity', 'text'], ['aggregation', 'enum', ['none', 'shared', 'composite']], ['navigable', 'bool']]
+  .map(([k, kind, options]) => ({ key: `ends.${w}.${k}`, path: ['ends', w, k], label: `${w === 'from' ? 'From' : 'To'} ${k}`, kind, ...(options ? { options } : {}) }));
+const CLASS_DEF = {
+  title: 'class diagram',
+  elements: [['Class', 'Class'], ['Interface', 'Interface'], ['Enumeration', 'Enumeration'], ['DataType', 'Data type'], ['PrimitiveType', 'Primitive type'], ['Package', 'Package'], ['Comment', 'Comment']]
+    .map(([t, label]) => ({ type: 'uml.' + t, label })),
+  lines: [['Association', 'Association'], ['Generalization', 'Generalization'], ['InterfaceRealization', 'Realization'], ['Dependency', 'Dependency'], ['CommentLink', 'Comment link']]
+    .map(([t, label]) => ({ type: 'uml.' + t, label })),
+  props: {
+    'uml.Class': [{ key: 'isAbstract', label: 'Abstract', kind: 'bool' }, STEREO],
+    'uml.Interface': [STEREO], 'uml.Enumeration': [STEREO], 'uml.DataType': [STEREO], 'uml.PrimitiveType': [STEREO], 'uml.Package': [STEREO],
+    'uml.Association': [...endFields('from'), ...endFields('to'), STEREO],
+    'uml.Dependency': [STEREO], 'uml.Generalization': [], 'uml.InterfaceRealization': [], 'uml.CommentLink': [],
+  },
+};
+
+/* ---- drawing input: the classifier's (src/typed/draw.js draws it) and the note's ---- */
+const COMPARTMENTS = { attributes: 'uml.Property', operations: 'uml.Operation', literals: 'uml.EnumerationLiteral' };
+function compartmentsOf(n) { // a class's attributes and operations; an enumeration's literals, then the others it has
+  const c = name => ({ name, members: UML_ARR(n.members).filter(m => UML_OBJ(m) && m.type === COMPARTMENTS[name]) });
+  if (n.type === 'uml.Package' || n.type === 'uml.Comment') return [];
+  return n.type === 'uml.Enumeration' ? [c('literals'), ...[c('attributes'), c('operations')].filter(x => x.members.length)] : [c('attributes'), c('operations')];
+}
+
+// a comment: a note with a folded corner, its text wrapped at 220 px
+const NOTE = { pad: 8, px: 11, lh: 15, max: 220, fold: 10 };
+function noteLines(t) {
+  const out = []; let line = '';
+  String(t ?? '').split(/\s+/).filter(Boolean).forEach(w => { const next = line ? line + ' ' + w : w;
+    if (line && textW(next, NOTE.px) > NOTE.max) { out.push(line); line = w; } else line = next; });
+  if (line) out.push(line);
+  return out.length ? out : [''];
+}
+SHAPE.note = {
+  size: n => { const ls = noteLines(n.label); return { w: Math.ceil(Math.max(60, ...ls.map(l => Math.min(NOTE.max, textW(l, NOTE.px)))) + 2 * NOTE.pad + NOTE.fold), h: ls.length * NOTE.lh + 2 * NOTE.pad }; },
+  out: SHAPE.classifier.out, face: n => [n.y, n.y + n.h], inset: () => 0, ports: SHAPE.classifier.ports,
+  draw(n, c, f) {
+    const { x, y, w, h } = n, k = NOTE.fold, ls = noteLines(n.label), max = w - 2 * NOTE.pad - k;
+    return `<g class="node note" data-id="${esc(n.id)}" data-shape="note" tabindex="-1" role="img" aria-label="${esc(n.aria || 'Comment: ' + (n.label ?? ''))}">`
+      + `<path d="M${x} ${y}H${x + w - k}L${x + w} ${y + k}V${y + h}H${x}Z" class="n-mask"/><path d="M${x} ${y}H${x + w - k}L${x + w} ${y + k}V${y + h}H${x}Z" class="n-body" fill="${f}" stroke="${c}"/>`
+      + `<path d="M${x + w - k} ${y}V${y + k}H${x + w}" class="n-det" stroke="${c}"/>`
+      + `<g class="c-head" data-band="${r2(y)} ${r2(y + h)}">${ls.map((l, i) => `<text x="${r2(x + NOTE.pad)}" y="${r2(y + NOTE.pad + i * NOTE.lh + 11)}" class="c-row" fill="var(--um-text)" style="font:400 ${NOTE.px}px var(--um-sans)">${esc(fit(l, NOTE.px, max))}</text>`).join('')}</g></g>`;
+  },
+};
+
+/* ---- lines: how each kind is drawn (src/typed/draw.js's ENDS), and its words ---- */
+const endOfLine = (e, w) => { const at = ((UML_OBJ(e.props) && UML_OBJ(e.props.ends) ? e.props.ends : {})[w]) || {};
+  return at.aggregation === 'composite' ? 'filled-diamond' : at.aggregation === 'shared' ? 'diamond' : at.navigable ? 'open' : 'none'; };
+const endsOf = e => (UML_OBJ(e.props) && UML_OBJ(e.props.ends) ? e.props.ends : {});
+function lineLook(e) {
+  switch (e.type) {
+    case 'uml.Generalization': return { from: 'none', to: 'triangle' };
+    case 'uml.InterfaceRealization': return { from: 'none', to: 'triangle', dashed: true };
+    case 'uml.Dependency': return { from: 'none', to: 'open', dashed: true };
+    case 'uml.CommentLink': return { from: 'none', to: 'none', dashed: true };
+    case 'uml.Association': { const E = endsOf(e), lab = w => ({ role: (E[w] || {}).role, mult: (E[w] || {}).multiplicity });
+      return { from: endOfLine(e, 'from'), to: endOfLine(e, 'to'), labels: { from: lab('from'), to: lab('to') } }; }
+    default: return { from: 'none', to: 'arrow' };
+  }
+}
+const stereoText = x => UML_ARR(UML_OBJ(x.props) ? x.props.stereotypes : null).filter(UML_HAS).map(t => `«${t}»`).join(' ');
+const lineLabel = e => [stereoText(e), e.label].filter(UML_HAS).join(' ');
+const LINE_WORDS = { 'uml.Association': ['Association', 'a link between instances'], 'uml.Generalization': ['Generalization', 'is a kind of the one it points to'],
+  'uml.InterfaceRealization': ['Realization', 'implements the interface it points to'], 'uml.Dependency': ['Dependency', 'uses the one it points to'],
+  'uml.CommentLink': ['Comment link', 'what a comment is about'] };
+const LEGEND_ENDS = { // small copies of src/typed/draw.js's ends, pointing right with the tip at x 26
+  none: '', open: '<path d="M17 4L26 8L17 12" fill="none"/>', triangle: '<path d="M16 3L26 8L16 13Z" fill="var(--um-panel)"/>',
+  diamond: '<path d="M12 8L19 4L26 8L19 12Z" fill="var(--um-panel)"/>', 'filled-diamond': '<path d="M12 8L19 4L26 8L19 12Z" fill="var(--um-muted)"/>' };
+const legendItem = (end, dashed, name, says) => `<span class="lgi" title="${esc(name + ' — ' + says)}"><svg class="lgs" viewBox="0 0 28 16" aria-hidden="true"><g stroke="var(--um-muted)" stroke-width="1.4" stroke-linejoin="round"><path d="M2 8H${end === 'none' ? 26 : end.includes('diamond') ? 12 : 17}"${dashed ? ' stroke-dasharray="3 2"' : ''}/>${LEGEND_ENDS[end]}</g></svg><b>${esc(name)}</b><span>${esc(says)}</span></span>`;
+// the legend of a view's lines (pieces.js shows it): each kind drawn, then the association's ends it shows
+function legendOf(edges) {
+  const types = new Set(edges.map(e => e.type)), ends = new Set(edges.filter(e => e.type === 'uml.Association').flatMap(e => [e.end.from, e.end.to]));
+  return [...Object.keys(LINE_WORDS).filter(t => types.has(t)).map(t => { const L = lineLook({ type: t }), [name, says] = LINE_WORDS[t];
+    return legendItem(t === 'uml.Association' ? 'none' : L.to, !!L.dashed, name, says); }),
+    ...[['filled-diamond', 'Composition', 'the whole owns its parts'], ['diamond', 'Aggregation', 'the whole holds its parts'], ['open', 'Navigable end', 'reachable from the other end']]
+      .filter(([k]) => ends.has(k)).map(([k, name, says]) => legendItem(k, false, name, says))];
+}
+
+/* ---- the view laid out: the model's elements as layoutTyped's input ---- */
+// every element by id, with its owner for a member
+function classIndex(model) {
+  const at = new Map(), put = (x, kind, owner, path) => { if (!UML_OBJ(x) || typeof x.id !== 'string' || at.has(x.id)) return;
+    at.set(x.id, { x, kind, owner, path }); UML_ARR(x.members).forEach((y, j) => put(y, 'member', x, `${path}.members[${j}]`)); };
+  UML_ARR(model.nodes).forEach((n, i) => put(n, 'node', null, `nodes[${i}]`));
+  UML_ARR(model.edges).forEach((e, i) => put(e, 'edge', null, `edges[${i}]`));
+  return at;
+}
+const typeWord = t => String(t || 'uml.Class').split('.').pop().replace(/([a-z])([A-Z])/g, (_, a, b) => a + ' ' + b.toLowerCase()); // 'uml.DataType': "Data type"
+const nameOfEl = x => String(x.label ?? x.id);
+const plural = (k, w) => `${k} ${k === 1 ? w : w + 's'}`;
+// an element's accessible name: "Class Order (entity, abstract), 5 attributes, 3 operations"
+function nodeName(n) {
+  if (n.type === 'uml.Comment') return 'Comment: ' + nameOfEl(n);
+  const p = UML_OBJ(n.props) ? n.props : {}, why = [...UML_ARR(p.stereotypes).filter(UML_HAS), ...(p.isAbstract ? ['abstract'] : [])];
+  const counts = compartmentsOf(n).map(c => plural(c.members.length, c.name.replace(/s$/, '')));
+  return [`${typeWord(n.type)} ${nameOfEl(n)}${why.length ? ` (${why.join(', ')})` : ''}`, ...counts].join(', ');
+}
+function lineName(e, at) {
+  const nm = id => { const r = at.get(id); return r ? nameOfEl(r.owner || r.x) + (r.owner ? '.' + nameOfEl(r.x) : '') : id; };
+  const [word] = UML_OWN(LINE_WORDS, e.type) || ['Line'], said = lineLabel(e), E = endsOf(e);
+  const end = w => { const t = [(E[w] || {}).role, (E[w] || {}).multiplicity].filter(UML_HAS); return t.length ? ` (${t.join(', ')})` : ''; };
+  return `${word} from ${nm(e.from)}${end('from')} to ${nm(e.to)}${end('to')}${said ? ': ' + said : ''}`;
+}
+
+/* the class view's geometry: { model, view, pos (col, row by id, the layered layout's ranking or the view's pins), memo,
+   direction }. A line that ends on a member is drawn to the member's owner; a line between two nodes the view does not
+   both show is not drawn */
+function classGeo({ model, view, pos, memo }) {
+  const at = classIndex(model), present = UML_OBJ(view.present) ? view.present : {}, ids = UML_ARR(view.nodeIds).filter(id => (at.get(id) || {}).kind === 'node');
+  const shown = new Set(ids), top = id => { const r = at.get(id); return r && r.owner ? top(r.owner.id) : id; };
+  const nodes = ids.map(id => { const n = at.get(id).x, pr = UML_OBJ(UML_OWN(present, id)) ? present[id] : {}, p = UML_OBJ(n.props) ? n.props : {};
+    const look = n.type === 'uml.Comment' ? { shape: 'note' } : { shape: 'classifier', stereotypes: [...(UML_OWN(IMPLIED, n.type) ? [IMPLIED[n.type]] : []), ...UML_ARR(p.stereotypes).filter(UML_HAS)],
+      abstract: !!p.isAbstract, compartments: compartmentsOf(n), collapsed: UML_ARR(pr.collapsed), ...(Number.isFinite(pr.rows) ? { rows: pr.rows } : {}) };
+    const d = { id, label: nameOfEl(n), type: n.type || 'uml.Class', kind: 'file', ...look, aria: nodeName(n), col: (UML_OWN(pos, id) || [0, 0])[0], row: (UML_OWN(pos, id) || [0, 0])[1] };
+    return { ...d, ...SHAPE[d.shape].size(d) }; });
+  const list = Array.isArray(view.edges) ? view.edges : UML_ARR(model.edges);
+  const edges = list.map(e => (typeof e === 'string' ? (at.get(e) || {}).x : e)).filter(e => UML_OBJ(e) && typeof e.id === 'string')
+    .map(e => ({ e, from: top(e.from), to: top(e.to) })).filter(({ from, to }) => shown.has(from) && shown.has(to))
+    .map(({ e, from, to }) => ({ id: e.id, _id: e.id, type: e.type, from, to, label: lineLabel(e) || undefined, end: lineLook(e), aria: lineName(e, at), ...(UML_OBJ(e.style) || typeof e.style === 'string' ? { style: e.style } : {}) }));
+  const g = layoutTyped({ nodes, edges, direction: view.direction === 'down' ? 'down' : 'right', gap: 96, rgap: 56 }, memo);
+  g.legend = legendOf(g.edges);
+  return g;
+}
+
+/* ---- validators (proposal.md §8.3). Each problem: { level, rule, path, message, ids }; the message names the rule and
+   the elements. Ownership cycles and references that do not resolve are the core's checks (src/core/model.js) ---- */
+const RULES = {
+  'member-names': 'a classifier\'s members have different names',
+  'classifier-names': 'classifiers in one owner have different names',
+  multiplicity: 'a multiplicity is n, *, n..m or n..*, its lower bound not above its upper',
+  'generalization-cycle': 'nothing is its own ancestor',
+  'generalization-kinds': 'a generalization joins two classifiers of one kind (not a package, a comment or a member)',
+  'realization-target': 'an interface realization runs from a classifier to an interface',
+  'interface-composite': 'an interface owns no part by composition',
+  'composite-multiplicity': 'a composite end\'s multiplicity is at most 1',
+  'member-kinds': 'literals belong to enumerations; packages and comments have no members',
+  'comment-link': 'a comment link runs from a comment',
+};
+function classProblems(model) {
+  const out = [], at = classIndex(UML_OBJ(model) ? model : {}), q = id => JSON.stringify(nameOfEl((at.get(id) || { x: { id } }).x));
+  const say = (rule, path, ids, msg, level = 'error') => out.push({ level, rule, path, ids: ids.filter(x => x != null), message: `${rule}: ${msg}` }); // a line with no end names what it has
+  const els = [...at.values()], nodes = els.filter(r => r.kind === 'node' && String(r.x.type || '').startsWith('uml.')), lines = els.filter(r => r.kind === 'edge' && String(r.x.type || '').startsWith('uml.'));
+  const typeOfId = id => (at.get(id) || { x: {} }).x.type, isCls = id => CLASSIFIERS.includes(typeOfId(id));
+  nodes.forEach(({ x, path }) => {
+    const ms = UML_ARR(x.members).filter(UML_OBJ), seen = new Map();
+    ms.forEach((m, j) => { // an operation is told apart by its parameters' types too (overloading)
+      const k = m.type === 'uml.Operation' ? `${m.label}(${UML_ARR((m.props || {}).parameters).map(a => UML_OBJ(a) ? a.valueType ?? '' : '').join(',')})` : `${m.label}`;
+      if (seen.has(k)) say('member-names', `${path}.members[${j}]`, [x.id, seen.get(k), m.id], `${q(x.id)} has two members named "${m.label}" (${seen.get(k)}, ${m.id})`); else seen.set(k, m.id);
+      if (m.type === 'uml.EnumerationLiteral' && x.type !== 'uml.Enumeration') say('member-kinds', `${path}.members[${j}]`, [x.id, m.id], `literal "${m.label}" is in ${q(x.id)}, which is not an enumeration`);
+      const mult = (m.props || {}).multiplicity; if (UML_HAS(mult)) multRule(String(mult), `${path}.members[${j}].props.multiplicity`, [m.id], `${q(x.id)}.${m.label}`); });
+    if ((x.type === 'uml.Package' || x.type === 'uml.Comment') && ms.length) say('member-kinds', `${path}.members`, [x.id], `${q(x.id)} is a ${typeWord(x.type).toLowerCase()}, which has no members`);
+  });
+  function multRule(t, path, ids, what) { const b = multBounds(t);
+    if (!b) say('multiplicity', path, ids, `${what}: [${t}] is not a multiplicity (1, *, 0..1, 1..*)`);
+    else if (b.lower > b.upper) say('multiplicity', path, ids, `${what}: [${t}] has its lower bound above its upper`);
+    return b; }
+  const byOwner = new Map(); nodes.filter(r => CLASSIFIERS.includes(r.x.type)).forEach(({ x, path }) => { const k = (x.parent ?? '') + '\u0000' + nameOfEl(x), was = byOwner.get(k);
+    if (was) say('classifier-names', path, [was, x.id], `${q(x.id)} is named twice in ${x.parent != null ? q(x.parent) : 'the model'} (${was}, ${x.id})`); else byOwner.set(k, x.id); });
+  const parents = new Map();
+  lines.forEach(({ x: e, path }) => {
+    const E = endsOf(e), ends = [e.from, e.to];
+    if (e.type === 'uml.Association') ['from', 'to'].forEach(w => { const at2 = UML_OBJ(E[w]) ? E[w] : {}, who = e[w];
+      const b = UML_HAS(at2.multiplicity) ? multRule(String(at2.multiplicity), `${path}.props.ends.${w}.multiplicity`, [e.id], `the ${w} end of ${lineName(e, at)}`) : null;
+      if (at2.aggregation === 'composite') {
+        if (typeOfId(who) === 'uml.Interface') say('interface-composite', `${path}.props.ends.${w}.aggregation`, [e.id, who], `interface ${q(who)} owns a part by composition (${e.id})`);
+        if (b && b.upper > 1) say('composite-multiplicity', `${path}.props.ends.${w}.multiplicity`, [e.id, who], `the composite end${who != null ? ' at ' + q(who) : ''} has multiplicity [${at2.multiplicity}], more than 1 (${e.id})`); } });
+    if (e.type === 'uml.Generalization') {
+      if (at.has(e.from) && at.has(e.to) && (!isCls(e.from) || !isCls(e.to) || typeOfId(e.from) !== typeOfId(e.to))) say('generalization-kinds', path, [e.id, ...ends], `${typeWord(typeOfId(e.from)).toLowerCase()} ${q(e.from)} specializes ${typeWord(typeOfId(e.to)).toLowerCase()} ${q(e.to)} (${e.id})`);
+      if (!parents.has(e.from)) parents.set(e.from, []); parents.get(e.from).push([e.to, path, e.id]); }
+    if (e.type === 'uml.InterfaceRealization' && (typeOfId(e.to) !== 'uml.Interface' || !isCls(e.from) || typeOfId(e.from) === 'uml.Interface'))
+      say('realization-target', path, [e.id, ...ends], `${e.id} runs from ${q(e.from)} to ${q(e.to)}: from a class, enumeration or data type to an interface`);
+    if (e.type === 'uml.CommentLink' && typeOfId(e.from) !== 'uml.Comment') say('comment-link', path, [e.id, e.from], `${e.id} runs from ${q(e.from)}, which is not a comment`);
+  });
+  // a generalization cycle: said once, at the line that closes it, naming every element on it
+  const state = new Map(), stack = [];
+  const walk = id => { state.set(id, 1); stack.push(id);
+    for (const [p, path, eid] of parents.get(id) || []) {
+      if (state.get(p) === 1) { const loop = stack.slice(stack.indexOf(p)); say('generalization-cycle', path, [...loop, eid], `${loop.map(q).join(' → ')} → ${q(p)} is its own ancestor (${eid})`); }
+      else if (!state.has(p)) walk(p); }
+    stack.pop(); state.set(id, 2); };
+  [...parents.keys()].forEach(id => { if (!state.has(id)) walk(id); });
+  return out;
+}
+
+/* ---- describe(): the view in words, per element: "Class Order (entity), 5 attributes, 3 operations; associated with
+   OrderLine (lines, 1..*)" ---- */
+function classDescribe(model, viewId) {
+  const v = UML_ARR(model && model.views).find(x => UML_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const at = classIndex(model), top = id => { const r = at.get(id); return r && r.owner ? top(r.owner.id) : id; };
+  const ids = UML_ARR(v.nodeIds).filter(id => (at.get(id) || {}).kind === 'node'), shown = new Set(ids), nm = id => nameOfEl(at.get(id).x);
+  const lines = (Array.isArray(v.edges) ? v.edges : UML_ARR(model.edges)).map(e => (typeof e === 'string' ? (at.get(e) || {}).x : e))
+    .filter(e => UML_OBJ(e) && shown.has(top(e.from)) && shown.has(top(e.to)));
+  const end = (e, w) => { const E = endsOf(e)[w] || {}, t = [E.role, E.multiplicity].filter(UML_HAS); return t.length ? ` (${t.join(', ')})` : ''; };
+  const out = [`${v.title || v.id}: a class diagram of ${plural(ids.length, 'element')} and ${plural(lines.length, 'line')}.`];
+  ids.forEach(id => { const said = [];
+    lines.forEach(e => { const f = top(e.from), t = top(e.to), E = endsOf(e);
+      if (e.type === 'uml.Association' && (f === id || t === id)) { const [me, far] = f === id ? ['from', 'to'] : ['to', 'from'], agg = (E[me] || {}).aggregation, whole = (E[far] || {}).aggregation;
+        const verb = agg === 'composite' ? 'composed of' : agg === 'shared' ? 'aggregates' : whole === 'composite' ? 'part of' : whole === 'shared' ? 'held by' : 'associated with';
+        said.push(`${verb} ${nm(far === 'to' ? t : f)}${end(e, far)}${UML_HAS(e.label) ? ` ("${e.label}")` : ''}`); }
+      else if (f === id && e.type === 'uml.Generalization') said.push(`a kind of ${nm(t)}`);
+      else if (f === id && e.type === 'uml.InterfaceRealization') said.push(`realizes ${nm(t)}`);
+      else if (f === id && e.type === 'uml.Dependency') said.push(`depends on ${nm(t)}${stereoText(e) ? ' ' + stereoText(e) : ''}`);
+      else if (f === id && e.type === 'uml.CommentLink') said.push(`about ${nm(t)}`); });
+    out.push(nodeName(at.get(id).x) + (said.length ? '; ' + said.join('; ') : '') + '.'); });
+  return out.join('\n');
+}
+
+/* ---- the type ---- */
+const CLASS_TYPE = registerDiagramType('uml.class', {
+  ...CLASS_DEF,
+  // the layered layout ranks the view's lines as maps are ranked, a generalization and a realization turned round so the
+  // general one comes first: above its specializations in a view laid out down (risks.md L6)
+  rankFlip: e => e.type === 'uml.Generalization' || e.type === 'uml.InterfaceRealization',
+  layout: classGeo,
+  member: { print: printMember, edit: memberEdit, add: memberAdd, holds: n => compartmentsOf(n).length > 0 }, // holds: the panel offers members (not on a comment or a package)
+  validate: classProblems,
+  rules: RULES,
+  describe: classDescribe,
+});
+/* ---------- Mermaid classDiagram: a reader and a writer (plan.md 1.10; risks.md R1 to R4, R7) ----------
+   Written against Mermaid 12.3.0's class diagram page (docs/syntax/classDiagram.md, read 11 Nov 2026). Internal: the CLI
+   (`umlimator.py import`) imports this file through Node; a host gets it once the registry is public.
+
+   readMermaidClass(text) -> { model, report }: a version-2 model with one `uml.class` view, in docs/diagrams/model.md's
+   vocabulary, and a report of what was not read as written, each item { line, status, message }, status `skipped` or
+   `approximated` (R1). The reader is hand-written and linear, and refuses text over MC_LIMIT characters (R2). Ids come
+   from the source's names (a class's, a namespace's; a member is <class>.<name>, a relation <from>-<to>, a note
+   note-<n>; a repeated one -2, -3 ...; a name with "->" has it as "-", reported), so the same source always gives the
+   same ids (R3). It never throws.
+
+   writeMermaidClass(model, viewId?) -> text: one class view as Mermaid. What Mermaid cannot carry is kept in its comments:
+   an id the reader would not derive, as `%% id: <id>` (and `%% link-id:` for a note's line) above its statement; an
+   element the subset leaves out, as `%% not written: <id> (<type>)`, and a property of one Mermaid has no place for, as
+   `%% not written: <id>: <what>` (navigable on an end with a diamond, a class's parent that is not a namespace, an
+   unknown visibility, a stereotype the reader would read as something else). A member whose text has a line break is not
+   written, nor a line that ends on a member. A model with views is written through its uml.class view; with none of them,
+   the text is one `%% not written:` line. A view's layout and present are not written.
+
+   How UML maps onto Mermaid's text, both ways:
+   - classes: `<<interface>>`, `<<enumeration>>`, `<<dataType>>`, `<<primitive>>` pick the type, `<<abstract>>` sets
+     isAbstract; any other annotation is a stereotype;
+   - attributes: `+name : Type[0..1] = default`, `/` for derived, a closing `$` for static; Mermaid's own `Type name`
+     is read too. Operations: `+name(p : T, out q : U) Return`, a closing `*` abstract, `$` static. `List~int~` is
+     List<int>. In an enumeration a bare name is a literal;
+   - relations: `--` an association (`*`, `o` its aggregation, `<`, `>` its navigability, a quoted cardinality
+     "role multiplicity" by each end), `--|>` a generalization, `..|>` an interface realization, `..>` a dependency,
+     its label `«stereotype» text` after `:`. A relation runs left to right, so a child is on the left of `--|>`;
+   - what `..|>` and a lollipop point to is an interface, reported when it is not declared one; Mermaid's `n` and `many`
+     are the multiplicity *, reported;
+   - a member named twice in one class (an operation with the same parameters' types) is read once, the other reported;
+     an interface that realizes another specializes it, reported;
+   - namespaces are packages, notes comments, `note for` a comment with its line; `direction TB` is down (the default),
+     `LR` right; a %%{ ... }%% directive, on one line or several, is passed over. */
+const MC_LIMIT = 1 << 20; // characters; a class diagram a person writes is a few kilobytes
+const mcTable = o => Object.assign(Object.create(null), o); // a lookup table: "constructor" or "__proto__" finds nothing in it
+const MC_VIS = mcTable({ '+': 'public', '-': 'private', '#': 'protected', '~': 'package' });
+const MC_TYPES = mcTable({ interface: 'uml.Interface', enumeration: 'uml.Enumeration', enum: 'uml.Enumeration', datatype: 'uml.DataType', primitive: 'uml.PrimitiveType', primitivetype: 'uml.PrimitiveType' });
+const MC_VIEW = 'class-diagram'; // the view's id when the source does not name it
+const mcWord = c => c != null && /[\p{L}\p{N}_]/u.test(c);
+const mcId = name => String(name).replace(/->+/g, '-'); // an id never holds "->", which names a map's lines by position ("->>" too)
+
+// the first of base, base-2, base-3 ... not in used; where it stopped is kept in next, so asking for one base again
+// resumes there and n repeats of a name cost n steps, not n * n (R2)
+function mcFree(used, next, base) {
+  let k = next.get(base) || 1, id = k > 1 ? `${base}-${k}` : base;
+  while (used.has(id)) id = `${base}-${++k}`;
+  next.set(base, k);
+  return id;
+}
+
+// a multiplicity as UML writes it, Mermaid's n and many read as *; null when the text is not one, or its lower bound is
+// above its upper
+function mcBounds(t) {
+  const m = /^(\d+|\*|n|many)(?:\.\.(\d+|\*|n|many))?$/.exec(t);
+  if (!m) return null;
+  const star = x => (x === 'n' || x === 'many' ? '*' : x), lo = star(m[1]), hi = m[2] == null ? null : star(m[2]);
+  if (hi != null && (lo === '*' || (hi !== '*' && +lo > +hi))) return null;
+  return hi == null ? lo : `${lo}..${hi}`;
+}
+
+// Mermaid's ~generic~ as <generic>: a ~ between two word characters opens, any other one closes an open one
+function mcGeneric(s) {
+  let out = '', depth = 0;
+  for (let k = 0; k < s.length; k++) {
+    const c = s[k];
+    if (c !== '~') out += c;
+    else if (mcWord(s[k - 1]) && mcWord(s[k + 1])) { out += '<'; depth++; }
+    else if (depth > 0) { out += '>'; depth--; }
+    else out += c;
+  }
+  return out;
+}
+
+// text in a label, a note or a cardinality: Mermaid's line breaks and entity codes (#quot; #lt; #35;)
+function mcText(s) {
+  return s.replace(/<br\s?\/?>|\\n/gi, '\n').replace(/#(quot|lt|gt|amp|\d{1,6});/g, (_, e) =>
+    ({ quot: '"', lt: '<', gt: '>', amp: '&' })[e] ?? String.fromCodePoint(Math.min(Number(e), 0x10ffff)));
+}
+
+// where whitespace ends
+function mcSkip(s, k) { while (k < s.length && (s[k] === ' ' || s[k] === '\t')) k++; return k; }
+
+// a name at k: `quoted in backticks`, or word characters with single dashes (and dots, for a namespace) between them
+function mcName(s, k, dots) {
+  if (s[k] === '`') { const e = s.indexOf('`', k + 1); return e > k + 1 ? [s.slice(k + 1, e), e + 1, true] : null; }
+  let e = k;
+  while (e < s.length && (mcWord(s[e]) || ((s[e] === '-' || (dots && s[e] === '.')) && mcWord(s[e - 1]) && mcWord(s[e + 1])))) e++;
+  return e > k ? [s.slice(k, e), e, false] : null;
+}
+
+// a "quoted" string at k: [text, after]
+function mcQuoted(s, k) { if (s[k] !== '"') return null; const e = s.indexOf('"', k + 1); return e < 0 ? null : [s.slice(k + 1, e), e + 1]; }
+
+// the last whitespace outside <...>, or -1: where `Type name` splits
+function mcLastSpace(s) {
+  let depth = 0, at = -1;
+  for (let k = 0; k < s.length; k++) { const c = s[k]; if (c === '<') depth++; else if (c === '>') depth = Math.max(0, depth - 1); else if ((c === ' ' || c === '\t') && depth === 0) at = k; }
+  return at;
+}
+
+// a type with its multiplicity: "String[0..1]" -> ["String", "0..1"], "int[0..n]" -> ["int", "0..*", "0..n"] (as
+// written, when that differs); "int[]" and "int[5..2]" stay types
+function mcMult(type) {
+  const t = type.trim(), lb = t.lastIndexOf('[');
+  if (!t.endsWith(']') || lb < 0) return [t, undefined];
+  const inner = t.slice(lb + 1, -1).replace(/\s/g, ''), mult = mcBounds(inner);
+  return mult ? [t.slice(0, lb).trim(), mult, mult === inner ? undefined : inner] : [t, undefined];
+}
+
+// `name : Type` or Mermaid's `Type name` or `name`, generics already turned to <>: { name, valueType?, multiplicity? }
+function mcTyped(s, colonFirst) {
+  let name, type = '';
+  const colon = colonFirst ? s.indexOf(':') : -1;
+  if (colon >= 0) { name = s.slice(0, colon).trim(); type = s.slice(colon + 1); }
+  else { const sp = mcLastSpace(s.trim()); name = sp < 0 ? s.trim() : s.trim().slice(sp + 1); type = sp < 0 ? '' : s.trim().slice(0, sp); }
+  const [valueType, multiplicity, written] = mcMult(type);
+  return { name, ...(valueType ? { valueType } : {}), ...(multiplicity ? { multiplicity } : {}), ...(written ? { written } : {}) };
+}
+
+// one member's text: an operation (it has parentheses), a literal (a bare name in an enumeration) or an attribute
+function mcMember(raw, inEnum) {
+  let t = raw.trim();
+  if (inEnum && /^[\p{L}\p{N}_]+$/u.test(t)) return { type: 'uml.EnumerationLiteral', label: t };
+  let isStatic = false, isAbstract = false;
+  for (;;) {
+    if (t.endsWith('$')) isStatic = true; else if (t.endsWith('*')) isAbstract = true; else break;
+    t = t.slice(0, -1).trimEnd();
+  }
+  const props = {};
+  if (MC_VIS[t[0]]) { props.visibility = MC_VIS[t[0]]; t = t.slice(1).trimStart(); }
+  t = mcGeneric(t);
+  const open = t.indexOf('(');
+  if (open >= 0) {
+    const close = t.lastIndexOf(')'), inner = t.slice(open + 1, close > open ? close : t.length);
+    let ret = close > open ? t.slice(close + 1).trim() : '';
+    if (ret.startsWith(':')) ret = ret.slice(1).trim();
+    const parameters = [];
+    let depth = 0, from = 0;
+    for (let k = 0; k <= inner.length; k++) {
+      const c = inner[k];
+      if (c === '<') depth++; else if (c === '>') depth = Math.max(0, depth - 1);
+      else if (k === inner.length || (c === ',' && depth === 0)) {
+        let p = inner.slice(from, k).trim(); from = k + 1;
+        if (!p) continue;
+        const sp = p.search(/\s/), first = sp < 0 ? '' : p.slice(0, sp), direction = ['in', 'out', 'inout', 'return'].includes(first) ? first : undefined;
+        if (direction) p = p.slice(sp).trim();
+        const { name, valueType } = mcTyped(p, true);
+        parameters.push({ name, ...(valueType ? { valueType } : {}), ...(direction ? { direction } : {}) });
+      }
+    }
+    if (parameters.length) props.parameters = parameters;
+    if (ret) props.returnType = ret;
+    if (isStatic) props.isStatic = true;
+    if (isAbstract) props.isAbstract = true;
+    return { type: 'uml.Operation', label: t.slice(0, open).trim(), props };
+  }
+  if (t.startsWith('/')) { props.isDerived = true; t = t.slice(1).trimStart(); }
+  const eq = t.indexOf('='), colon = t.indexOf(':');
+  let head = t, def;
+  if (colon >= 0 && (eq < 0 || colon < eq)) { const r = t.slice(colon + 1), e = r.indexOf('='); head = t.slice(0, colon + 1) + (e < 0 ? r : r.slice(0, e)); def = e < 0 ? undefined : r.slice(e + 1).trim(); }
+  else if (eq >= 0) { head = t.slice(0, eq); def = t.slice(eq + 1).trim(); }
+  const { name, valueType, multiplicity, written } = mcTyped(head, true);
+  Object.assign(props, valueType ? { valueType } : {}, multiplicity ? { multiplicity } : {}, def !== undefined ? { default: def } : {}, isStatic ? { isStatic: true } : {});
+  return { type: 'uml.Property', label: name, props, abstractField: isAbstract, multWritten: written };
+}
+
+// a relation: A ["c1"] arrow ["c2"] B [: label], or null when the text is not one
+function mcRelation(s) {
+  const a = mcName(s, 0); if (!a) return null;
+  let k = mcSkip(s, a[1]), c1, c2, left = '', right = '';
+  const q1 = mcQuoted(s, k); if (q1) { c1 = q1[0]; k = mcSkip(s, q1[1]); }
+  for (const m of ['<|', '()', '*', 'o', '<']) if (s.startsWith(m, k)) { left = m; k += m.length; break; }
+  const line = s.startsWith('--', k) ? 'solid' : s.startsWith('..', k) ? 'dashed' : null;
+  if (!line) return null;
+  k += 2;
+  for (const m of ['|>', '()', '*', 'o', '>']) if (s.startsWith(m, k) && (!'*o'.includes(m) || k + 1 >= s.length || ' \t"'.includes(s[k + 1]))) { right = m; k += m.length; break; }
+  k = mcSkip(s, k);
+  const q2 = mcQuoted(s, k); if (q2) { c2 = q2[0]; k = mcSkip(s, q2[1]); }
+  const b = mcName(s, k); if (!b) return null;
+  k = mcSkip(s, b[1]);
+  if (k < s.length && s[k] !== ':') return null;
+  return { a: a[0], b: b[0], c1, c2, left, right, line, label: k < s.length ? s.slice(k + 1).trim() : '' };
+}
+
+// a cardinality's text as an end: "1", "0..*", "lines 1..*", "lines"; Mermaid's "many" and "n" are *
+function mcEnd(text, say) {
+  const t = mcText(text).trim(), sp = t.lastIndexOf(' '), last = sp < 0 ? t : t.slice(sp + 1), role = sp < 0 ? '' : t.slice(0, sp).trim();
+  const mult = mcBounds(last);
+  if (mult && mult !== last) say('approximated', `cardinality "${last}" is read as the multiplicity ${mult}`);
+  return mult ? { ...(role ? { role } : {}), multiplicity: mult } : t ? { role: t } : {};
+}
+
+function readMermaidClass(text) {
+  const report = [], say = (line, status, message) => report.push({ line, status, message });
+  const empty = () => ({ model: { schemaVersion: 2, root: MC_VIEW, nodes: [], edges: [], views: [{ id: MC_VIEW, diagram: 'uml.class', nodeIds: [] }] }, report });
+  if (typeof text !== 'string') { say(1, 'skipped', 'the input is not text: nothing read'); return empty(); }
+  if (text.length > MC_LIMIT) { say(1, 'skipped', `the input is ${text.length} characters, over the limit of ${MC_LIMIT}: nothing read`); return empty(); }
+  const lines = text.split('\n').map(l => l.replace(/\r$/, ''));
+  let i = 0, title;
+
+  // front matter: its title; Mermaid's configuration is not read
+  while (i < lines.length && !lines[i].trim()) i++;
+  if (lines[i] && lines[i].trim() === '---') {
+    let j = i + 1;
+    for (; j < lines.length && lines[j].trim() !== '---'; j++) {
+      const l = lines[j];
+      if (!l.trim() || l.trim().startsWith('#') || /^\s/.test(l)) continue;
+      const c = l.indexOf(':'), key = (c < 0 ? l : l.slice(0, c)).trim(), val = c < 0 ? '' : l.slice(c + 1).trim();
+      if (key === 'title') {
+        if (val.startsWith('"')) { try { title = JSON.parse(val); } catch { title = val.slice(1, -1); } }
+        else title = val.startsWith("'") ? val.slice(1, -1).replaceAll("''", "'") : val;
+      } else say(j + 1, 'skipped', `front matter ${key}: Mermaid's configuration is not read`);
+    }
+    if (j >= lines.length) { say(i + 1, 'skipped', 'the front matter is never closed with ---: nothing read'); return empty(); }
+    i = j + 1;
+  }
+
+  const classes = new Map(), packages = new Map(), order = [], relations = [], notes = [], stack = [];
+  let viewId, direction = 'down', started = false, hint = {}, block = null;
+  // classes and namespaces by their names, their ids given once all are read (a name that is not an id needs the others)
+  const cls = (name, no) => {
+    if (!classes.has(name)) { const rec = { kind: 'class', name, no, node: { id: undefined, type: 'uml.Class', label: name }, anns: [], raw: [] }; classes.set(name, rec); order.push(rec); }
+    return classes.get(name);
+  };
+  const where = () => { for (let k = stack.length - 1; k >= 0; k--) if (stack[k].kind === 'package') return stack[k]; return null; };
+  const annotate = (rec, s) => { const e = s.indexOf('>>', 2); rec.anns.push((e < 0 ? s.slice(2) : s.slice(2, e)).trim()); return e < 0 ? s.length : e + 2; };
+  const member = (rec, s, no) => { if (s.trim()) rec.raw.push({ text: s, line: no, hint: hint.id }); };
+
+  for (; i < lines.length; i++) {
+    const no = i + 1, s = lines[i].trim();
+    if (!s) continue;
+    if (block) { if (s.includes('}')) block = null; continue; } // inside accDescr { ... }
+    if (s.startsWith('%%')) {
+      const c = s.slice(2).trim();
+      if (c.startsWith('{')) {
+        say(no, 'skipped', 'a %%{init}%% directive: Mermaid\'s configuration is not read');
+        if (!s.includes('}%%')) while (i + 1 < lines.length && !lines[++i].includes('}%%')); // over several lines: to its }%%
+      }
+      else if (c.startsWith('id:')) hint.id = c.slice(3).trim();
+      else if (c.startsWith('link-id:')) hint.link = c.slice(8).trim();
+      continue;
+    }
+    if (!started) {
+      if (!/^classDiagram(-v2)?$/.test(s)) { say(no, 'skipped', 'not a Mermaid classDiagram: nothing read'); return empty(); }
+      started = true; viewId = hint.id; hint = {}; continue;
+    }
+    const top = stack[stack.length - 1];
+    const cut = s.search(/[\s{:("[<`]/), word = cut < 0 ? s : s.slice(0, cut);
+    if (top && top.kind === 'class') { // a class body
+      if (s === '}') stack.pop();
+      else if (s.startsWith('<<')) annotate(top.rec, s);
+      else member(top.rec, s, no);
+    } else if (s === '}') {
+      if (top) stack.pop(); else say(no, 'skipped', 'a } that closes nothing');
+    } else if (word === 'direction') {
+      const d = s.slice(9).trim();
+      if (d === 'TB' || d === 'TD') direction = 'down';
+      else if (d === 'LR') direction = 'right';
+      else if (d === 'BT' || d === 'RL') { direction = d === 'BT' ? 'down' : 'right'; say(no, 'approximated', `direction ${d} is drawn ${direction === 'down' ? 'top to bottom' : 'left to right'}`); }
+      else say(no, 'skipped', `direction ${d}: not a direction`);
+    } else if (word === 'class') {
+      const n = mcName(s, mcSkip(s, 5));
+      if (!n) { say(no, 'skipped', 'a class with no name'); hint = {}; continue; }
+      const rec = cls(n[0], no), pkg = where();
+      if (pkg) rec.pkg = pkg;
+      let k = n[1], rest = '';
+      while (k < s.length) {
+        k = mcSkip(s, k);
+        if (k >= s.length) break;
+        if (s[k] === '~') {
+          let depth = 0, e = k;
+          for (; e < s.length; e++) if (s[e] === '~') { if (mcWord(s[e - 1]) && mcWord(s[e + 1]) || e === k) depth++; else if (--depth === 0) break; }
+          rec.node.label = mcGeneric(n[0] + s.slice(k, e + 1));
+          say(no, 'approximated', `class ${n[0]}'s type parameter is kept in its name only, ${rec.node.label} (templates are not in the subset)`);
+          k = e + 1;
+        } else if (s.startsWith('["', k)) {
+          const q = mcQuoted(s, k + 1); if (!q || s[q[1]] !== ']') { rest = s.slice(k); break; }
+          rec.node.label = mcText(q[0]); k = q[1] + 1;
+        } else if (s.startsWith('<<', k)) k = annotate(rec, s.slice(k)) + k;
+        else if (s.startsWith(':::', k)) {
+          const c = mcName(s, k + 3); say(no, 'skipped', `:::${c ? c[0] : ''} on class ${n[0]}: styling is not read`); k = c ? c[1] : k + 3;
+        } else if (s[k] === '{') {
+          const after = s.slice(k + 1).trim();
+          if (after === '}') break;
+          if (after.endsWith('}')) { member(rec, after.slice(0, -1), no); break; }
+          stack.push({ kind: 'class', rec }); member(rec, after, no); break;
+        } else { rest = s.slice(k); break; }
+      }
+      if (rest) say(no, 'skipped', `class ${n[0]}: "${rest}" is not read`);
+    } else if (word === 'namespace') {
+      const n = mcName(s, mcSkip(s, 9), true);
+      if (!n) { say(no, 'skipped', 'a namespace with no name'); hint = {}; continue; }
+      let k = mcSkip(s, n[1]), label;
+      if (s.startsWith('["', k)) { const q = mcQuoted(s, k + 1); if (q && s[q[1]] === ']') { label = mcText(q[0]); k = mcSkip(s, q[1] + 1); } }
+      const segs = n[2] ? [n[0]] : n[0].split('.');
+      let parent = where();
+      segs.forEach((seg, j) => {
+        const path = segs.slice(0, j + 1).join('.');
+        if (!packages.has(path)) {
+          const rec = { kind: 'package', name: path, no, pkg: parent, node: { id: undefined, type: 'uml.Package', label: seg } };
+          packages.set(path, rec); order.push(rec);
+        }
+        parent = packages.get(path);
+      });
+      if (label) parent.node.label = label;
+      if (s[k] === '{') { if (s.slice(k + 1).trim() !== '}') stack.push(parent); }
+      else say(no, 'skipped', `namespace ${n[0]} has no {: what follows is not inside it`);
+    } else if (word === 'note') {
+      let k = mcSkip(s, 4), target;
+      if (s.startsWith('for ', k)) { const n = mcName(s, mcSkip(s, k + 4)); if (n) { target = cls(n[0], no); k = mcSkip(s, n[1]); } }
+      const q = mcQuoted(s, k);
+      if (!q) say(no, 'skipped', 'a note with no "text"');
+      else { const rec = { kind: 'note', node: { type: 'uml.Comment', label: mcText(q[0]) }, target, hint: hint.id, linkHint: hint.link }; notes.push(rec); order.push(rec); }
+    } else if (s.startsWith('<<')) {
+      const e = s.indexOf('>>'), n = e < 0 ? null : mcName(s, mcSkip(s, e + 2));
+      if (n) annotate(cls(n[0], no), s); else say(no, 'skipped', `${s}: an annotation names no class`);
+    } else if (['click', 'link', 'callback'].includes(word)) say(no, 'skipped', `${word}: links and callbacks are not read`);
+    else if (['style', 'classDef', 'cssClass'].includes(word)) say(no, 'skipped', `${word}: styling is not read`);
+    else if (word.startsWith('accTitle') || word.startsWith('accDescr')) {
+      say(no, 'skipped', `${word.startsWith('accTitle') ? 'accTitle' : 'accDescr'}: accessibility text is not read`);
+      if (word.startsWith('accDescr') && s.includes('{') && !s.includes('}')) block = true;
+    } else {
+      const r = mcRelation(s);
+      if (r) { relations.push({ ...r, no, hint: hint.id, from: cls(r.a, no), to: cls(r.b, no) }); hint = {}; continue; }
+      const n = mcName(s, 0), k = n ? mcSkip(s, n[1]) : -1;
+      if (n && s[k] === ':') member(cls(n[0], no), s.slice(k + 1), no);
+      else if (n && k >= s.length) cls(n[0], no);
+      else say(no, 'skipped', `"${s.length > 60 ? s.slice(0, 57) + '...' : s}" is not understood`);
+    }
+    hint = {};
+  }
+  if (!started) { say(1, 'skipped', 'not a Mermaid classDiagram: nothing read'); return empty(); }
+  for (const open of stack) say(lines.length, 'approximated', `${open.kind === 'class' ? 'class ' + open.rec.name : 'namespace ' + open.name} is never closed: read to the end`);
+
+  // ids: a class's name, then a namespace's; a namespace with a class's name is <name>-namespace, and a name the id rule
+  // changes (no "->") is made unique, both reported. Later members, relations and notes, in the order they come, made unique
+  const used = new Set(), next = new Map(), uniq = name => { const id = mcFree(used, next, mcId(name)); used.add(id); return id; };
+  const named = [...classes.values(), ...packages.values()];
+  for (const rec of named) if (mcId(rec.name) === rec.name && !used.has(rec.name)) { rec.node.id = rec.name; used.add(rec.name); }
+  for (const rec of named) if (rec.node.id === undefined) {
+    const kept = mcId(rec.name) === rec.name, what = `${rec.kind === 'class' ? 'class' : 'namespace'} ${rec.name}`;
+    rec.node.id = uniq(kept ? rec.name + '-namespace' : rec.name);
+    say(rec.no, 'approximated', kept ? `${what} has a class's name: it is ${rec.node.id}` : `${what}: an id holds no "->", so it is ${rec.node.id}`);
+  }
+  for (const rec of named) if (rec.pkg) rec.node.parent = rec.pkg.node.id;
+
+  // the relations, as UML's
+  const edges = [];
+  for (const r of relations) {
+    const at = (status, message) => say(r.no, status, message), tri = x => x === '<|' || x === '|>', what = `${r.a} ${r.left}${r.line === 'solid' ? '--' : '..'}${r.right} ${r.b}`;
+    let e = null;
+    if (r.left === '()' || r.right === '()') {
+      const [iface, impl] = r.left === '()' ? [r.from, r.to] : [r.to, r.from];
+      if ((r.left && r.right) || r.line === 'dashed') at('skipped', `${what}: a lollipop joins a class by a solid line`);
+      else { iface.forced = 'uml.Interface'; e = { type: 'uml.InterfaceRealization', from: impl.node.id, to: iface.node.id }; at('approximated', `${what}: the lollipop ${iface.node.id} is an interface ${impl.node.id} realizes, drawn as a box`); }
+    } else if (r.line === 'solid' && !tri(r.left) && !tri(r.right)) {
+      const ends = {};
+      [['from', r.left, r.c1], ['to', r.right, r.c2]].forEach(([k, mark, card]) => {
+        const end = card != null ? mcEnd(card, at) : {};
+        if (mark === '*') end.aggregation = 'composite'; else if (mark === 'o') end.aggregation = 'shared'; else if (mark) end.navigable = true;
+        if (Object.keys(end).length) ends[k] = end;
+      });
+      e = { type: 'uml.Association', from: r.from.node.id, to: r.to.node.id, ...(Object.keys(ends).length ? { props: { ends } } : {}) };
+    } else {
+      const kind = r.line === 'solid' ? 'uml.Generalization' : tri(r.left) || tri(r.right) ? 'uml.InterfaceRealization' : 'uml.Dependency';
+      const mark = kind === 'uml.Generalization' || kind === 'uml.InterfaceRealization' ? tri : x => x === '<' || x === '>';
+      if (mark(r.left) && !r.right) e = { type: kind, from: r.to.node.id, to: r.from.node.id };
+      else if (mark(r.right) && !r.left) e = { type: kind, from: r.from.node.id, to: r.to.node.id };
+      else if (!r.left && !r.right) { e = { type: kind, from: r.from.node.id, to: r.to.node.id }; at('approximated', `${what}: a dashed link with no arrow is read as a dependency from ${r.a} to ${r.b}`); }
+      else at('skipped', `${what}: ${r.left && r.right ? 'a two-way' : 'this'} ${kind === 'uml.Dependency' ? 'dashed relation' : kind === 'uml.Generalization' ? 'inheritance' : 'realization'} has no counterpart in UML's class diagram`);
+      if (e && (r.c1 != null || r.c2 != null)) at('skipped', `${what}: a cardinality is read on an association only`);
+      if (e && kind === 'uml.InterfaceRealization') { // what is realized is an interface, as a lollipop's is
+        const sup = mark(r.left) ? r.from : r.to;
+        if (!sup.forced && !sup.anns.some(a => a.toLowerCase() === 'interface')) at('approximated', `${what}: ${sup.node.id} is realized, so it is read as an interface`);
+        sup.forced = 'uml.Interface';
+      }
+    }
+    if (!e) continue;
+    let label = mcText(r.label);
+    const stereotypes = [];
+    for (;;) {
+      label = label.trim();
+      const [o, c] = label.startsWith('«') ? ['«', '»'] : label.startsWith('<<') ? ['<<', '>>'] : [];
+      const end = o ? label.indexOf(c, o.length) : -1;
+      if (end < 0) break;
+      stereotypes.push(label.slice(o.length, end).trim()); label = label.slice(end + c.length);
+    }
+    if (stereotypes.length) e.props = { ...e.props, stereotypes };
+    if (label) e.label = label;
+    edges.push({ e, hint: r.hint, at, what });
+  }
+
+  // finish the classes: their type from the annotations, then their members
+  for (const rec of classes.values()) {
+    const n = rec.node, stereotypes = [];
+    let type = rec.forced;
+    for (const a of rec.anns) {
+      const k = a.toLowerCase();
+      if (k === 'abstract') n.props = { ...n.props, isAbstract: true };
+      else if (MC_TYPES[k]) type = type || MC_TYPES[k];
+      else stereotypes.push(a);
+    }
+    if (type) n.type = type;
+    if (stereotypes.length) n.props = { ...n.props, stereotypes };
+  }
+  // an interface does not realize one: it specializes it (an interface by its annotation, or as what is realized elsewhere)
+  const typeOf = new Map([...classes.values()].map(c => [c.node.id, c.node.type]));
+  for (const { e, at, what } of edges) if (e.type === 'uml.InterfaceRealization' && typeOf.get(e.from) === 'uml.Interface') {
+    e.type = 'uml.Generalization'; at('approximated', `${what}: ${e.from} is an interface, so it specializes ${e.to}`);
+  }
+
+  for (const rec of classes.values()) {
+    const members = [], seen = new Set(); // a member's name, an operation's with its parameters' types (overloading)
+    for (const r of rec.raw) {
+      const { abstractField, multWritten, ...x } = mcMember(r.text, rec.node.type === 'uml.Enumeration');
+      if (!x.label) { say(r.line, 'skipped', `"${r.text.trim()}": a member with no name`); continue; }
+      if (abstractField) say(r.line, 'approximated', `${rec.node.id}.${x.label}: an attribute is not abstract, so its * is not read`);
+      if (multWritten) say(r.line, 'approximated', `${rec.node.id}.${x.label}: multiplicity [${multWritten}] is read as [${x.props.multiplicity}]`);
+      const key = x.type === 'uml.Operation' ? `${x.label}(${(x.props.parameters || []).map(a => a.valueType ?? '').join(',')})` : x.label;
+      if (seen.has(key)) { say(r.line, 'skipped', `${rec.node.id}.${x.label}: ${rec.node.id} has a member ${key} already`); continue; }
+      seen.add(key);
+      if (x.props && !Object.keys(x.props).length) delete x.props;
+      members.push({ id: uniq(r.hint ?? `${rec.node.id}.${x.label}`), ...x });
+    }
+    if (members.length) rec.node.members = members;
+  }
+  const out = edges.map(({ e, hint }) => ({ id: uniq(hint ?? `${e.from}-${e.to}`), ...e }));
+  notes.forEach((rec, k) => {
+    rec.node = { id: uniq(rec.hint ?? `note-${k + 1}`), ...rec.node };
+    if (rec.target) out.push({ id: uniq(rec.linkHint ?? `${rec.node.id}-link`), type: 'uml.CommentLink', from: rec.node.id, to: rec.target.node.id });
+  });
+
+  const nodes = order.map(x => x.node), view = { id: viewId || MC_VIEW, diagram: 'uml.class', ...(title ? { title } : {}), ...(direction === 'down' ? { direction } : {}), nodeIds: nodes.map(n => n.id) };
+  report.sort((a, b) => a.line - b.line); // stable: one line's items keep their order
+  return { model: { schemaVersion: 2, ...(title ? { title } : {}), root: view.id, nodes, edges: out, views: [view] }, report };
+}
+
+function writeMermaidClass(model, viewId) {
+  const m = model && typeof model === 'object' ? model : {}, arr = x => (Array.isArray(x) ? x : []), isObj = x => !!x && typeof x === 'object';
+  const flat = s => String(s).replace(/\r\n|\r|\n/g, '\\n'), nl = s => /[\r\n]/.test(String(s)); // a comment is one line
+  const views = arr(m.views).filter(isObj);
+  const view = viewId != null ? views.find(v => v.id === viewId) : views.find(v => v.diagram === 'uml.class');
+  // a model with views is written through its class view; one with none, whole
+  if (viewId != null && !view) return `%% not written: view ${flat(viewId)}, which the model does not have\n`;
+  if (views.length && !view) return '%% not written: the model, which has no uml.class view\n';
+  if (view && view.diagram !== 'uml.class') return `%% not written: view ${flat(view.id)}, a ${flat(view.diagram)} view, not a uml.class one\n`;
+  const byId = new Map(arr(m.nodes).filter(isObj).map(n => [n.id, n]));
+  const shown = (view ? arr(view.nodeIds) : [...byId.keys()]).filter(id => byId.has(id));
+  const KIND = mcTable({ 'uml.Class': '', 'uml.Interface': 'interface', 'uml.Enumeration': 'enumeration', 'uml.DataType': 'dataType', 'uml.PrimitiveType': 'primitive' });
+  const VIS = mcTable({ public: '+', private: '-', protected: '#', package: '~' });
+  const ARROW = mcTable({ 'uml.Generalization': '--|>', 'uml.InterfaceRealization': '..|>', 'uml.Dependency': '..>' });
+  const has = x => x != null && x !== '', gen = s => String(s).replace(/[<>]/g, '~');
+  const enc = s => String(s).replace(/"/g, '#quot;').replace(/</g, '#lt;').replace(/>/g, '#gt;').replace(/\n/g, '<br>');
+  const name = id => (/^[\p{L}\p{N}_]+(-[\p{L}\p{N}_]+)*$/u.test(id) ? id : '`' + id + '`');
+  // what Mermaid cannot carry: an element, as `<id> (<type>)`, or one property of one, as `<id>: <what>`
+  const out = [], notWritten = [], skip = x => notWritten.push(`${flat(x.id)} (${flat(x.type)})`), lose = (id, what) => notWritten.push(`${flat(id)}: ${flat(what)}`);
+  const title = view && has(view.title) ? view.title : m.title;
+  if (has(title)) out.push('---', `title: ${/^[\p{L}\p{N}][\p{L}\p{N} _.,()-]*$/u.test(title) && !title.endsWith(' ') ? title : JSON.stringify(String(title))}`, '---');
+  if (view && view.id !== MC_VIEW) { if (nl(view.id)) lose(view.id, "the view's id, which has a line break"); else out.push(`%% id: ${view.id}`); }
+  out.push('classDiagram', view && view.direction === 'down' ? '  direction TB' : '  direction LR');
+
+  // what is written, in the reader's order: namespaces and classes as a tree, then relations, then notes
+  const shownSet = new Set(shown), isPkg = n => n.type === 'uml.Package';
+  const kids = new Map(), roots = [], notes = [], tree = [], boxes = [];
+  for (const id of shown) {
+    const n = byId.get(id), up = shownSet.has(n.parent) ? byId.get(n.parent) : null;
+    if (n.type === 'uml.Comment') { if (nl(n.id)) skip(n); else notes.push(n); }
+    else if ((!isPkg(n) && !(n.type in KIND)) || nl(n.id) || String(n.id).includes('`')) skip(n); // a name is one line, in `...` at most
+    else if (up && isPkg(up)) { boxes.push(n); if (!kids.has(n.parent)) kids.set(n.parent, []); kids.get(n.parent).push(n); }
+    else { if (up) lose(n.id, `its parent ${n.parent}, a ${up.type}, which only a namespace can be`); roots.push(n); }
+  }
+  const walk = n => { tree.push(n); for (const k of kids.get(n.id) || []) walk(k); };
+  roots.forEach(walk);
+  const inTree = new Set(tree);
+  for (const n of boxes) if (!inTree.has(n)) skip(n); // under a namespace that is not written, or in a cycle of parents
+  const written = new Set(tree.filter(n => !isPkg(n)).map(n => n.id));
+  const used = new Set(tree.map(n => n.id)), next = new Map();
+  const idOf = (id, base) => { const d = mcFree(used, next, mcId(base)); used.add(id); return d === id ? null : id; }; // the hint, if one is needed
+
+  const heads = new Map(); // a class's annotations and member rows
+  for (const n of tree) if (!isPkg(n)) {
+    const rows = [], np = isObj(n.props) ? n.props : {};
+    const anns = [...(KIND[n.type] ? [KIND[n.type]] : []), ...(np.isAbstract ? ['abstract'] : []), ...arr(np.stereotypes).filter(s => {
+      const k = String(s).toLowerCase(), ok = !nl(s) && !String(s).includes('>>') && k !== 'abstract' && !(k in MC_TYPES); // one the reader reads back as itself
+      if (!ok) lose(n.id, `stereotype ${s}`);
+      return ok;
+    })];
+    for (const x of arr(n.members).filter(isObj)) {
+      const p = isObj(x.props) ? x.props : {};
+      let text, vis = '';
+      if (has(p.visibility)) { if (p.visibility in VIS) vis = VIS[p.visibility]; else lose(x.id, `visibility ${p.visibility}`); }
+      if (x.type === 'uml.EnumerationLiteral') text = x.label;
+      else if (x.type === 'uml.Operation') {
+        const params = arr(p.parameters).filter(isObj).map(a => (has(a.direction) ? a.direction + ' ' : '') + (a.name ?? '') + (has(a.valueType) ? ' : ' + gen(a.valueType) : ''));
+        text = `${vis}${x.label}(${params.join(', ')})${has(p.returnType) ? ' ' + gen(p.returnType) : ''}${p.isAbstract ? '*' : ''}${p.isStatic ? '$' : ''}`;
+      } else if (x.type === 'uml.Property') {
+        const colon = has(p.valueType) || has(p.multiplicity) || /\s/.test(x.label);
+        text = `${vis}${p.isDerived ? '/' : ''}${x.label}${colon ? ' :' + (has(p.valueType) ? ' ' + gen(p.valueType) : '') : ''}${has(p.multiplicity) ? `[${p.multiplicity}]` : ''}${p.default != null ? ' = ' + p.default : ''}${p.isStatic ? '$' : ''}`;
+      }
+      // a member is one line of the class's body, which a line break, a lone }, a << or a %% would end or turn into another statement
+      if (text == null || !has(x.label) || nl(x.id) || nl(text) || /^(\}$|<<|%%)/.test(text.trim())) { skip(x); continue; }
+      rows.push([idOf(x.id, `${n.id}.${x.label}`), text]);
+    }
+    heads.set(n.id, [anns, rows]);
+  }
+
+  const edgeOf = e => (typeof e === 'string' ? arr(m.edges).find(x => isObj(x) && x.id === e) : e);
+  const owner = new Map(shown.flatMap(id => arr(byId.get(id).members).filter(isObj).map(x => [x.id, id])));
+  const inView = id => shownSet.has(id) || owner.has(id); // a line may end on a member, which Mermaid cannot draw
+  const lines = (view && Array.isArray(view.edges) ? view.edges.map(edgeOf) : arr(m.edges).filter(e => isObj(e) && inView(e.from) && inView(e.to))).filter(isObj);
+  const relations = [], links = [];
+  for (const e of lines) {
+    if (e.type === 'uml.CommentLink') { if (nl(e.id)) skip(e); else links.push(e); continue; }
+    if (!(written.has(e.from) && written.has(e.to)) || !(e.type === 'uml.Association' || e.type in ARROW) || nl(e.id)) { skip(e); continue; }
+    const p = isObj(e.props) ? e.props : {}, ends = isObj(p.ends) ? p.ends : {};
+    const label = [...arr(p.stereotypes).map(s => `«${s}»`), ...(has(e.label) ? [e.label] : [])].join(' ');
+    let arrow = ARROW[e.type], c1 = '', c2 = '';
+    if (!arrow) { // an end has one mark: a diamond, or else an arrowhead
+      const mark = (end, nav, w) => {
+        const dia = end.aggregation === 'composite' ? '*' : end.aggregation === 'shared' ? 'o' : '';
+        if (dia && end.navigable) lose(e.id, `navigable at the ${w} end, which has a ${end.aggregation} diamond`);
+        return dia || (end.navigable ? nav : '');
+      };
+      const card = end => { const t = [end.role, end.multiplicity].filter(has).join(' '); return t ? ` "${enc(t)}"` : ''; };
+      const f = isObj(ends.from) ? ends.from : {}, t = isObj(ends.to) ? ends.to : {};
+      arrow = mark(f, '<', 'from') + '--' + mark(t, '>', 'to'); c1 = card(f); c2 = card(t);
+    }
+    relations.push([idOf(e.id, `${e.from}-${e.to}`), `${name(e.from)}${c1} ${arrow}${c2} ${name(e.to)}${label ? ' : ' + enc(label) : ''}`]);
+  }
+  const noteLines = notes.map((n, k) => {
+    const mine = links.filter(e => e.from === n.id && written.has(e.to));
+    links.filter(e => e.from === n.id && e !== mine[0]).forEach(skip);
+    const hint = idOf(n.id, `note-${k + 1}`), link = mine[0] ? idOf(mine[0].id, `${n.id}-link`) : null;
+    return [hint, link, `note ${mine[0] ? `for ${name(mine[0].to)} ` : ''}"${enc(n.label ?? '')}"`];
+  });
+  links.filter(e => !notes.some(n => n.id === e.from)).forEach(skip);
+
+  const labelled = n => (has(n.label) && n.label !== n.id ? `["${enc(n.label)}"]` : '');
+  const emit = (n, pad) => {
+    if (isPkg(n)) {
+      out.push(`${pad}namespace ${name(n.id)}${labelled(n)} {`);
+      for (const k of kids.get(n.id) || []) emit(k, pad + '  ');
+      return out.push(`${pad}}`);
+    }
+    const [anns, rows] = heads.get(n.id), head = `${pad}class ${name(n.id)}${labelled(n)}`;
+    if (!anns.length && !rows.length) return out.push(head);
+    out.push(head + ' {', ...anns.map(a => `${pad}  <<${a}>>`));
+    for (const [hint, text] of rows) out.push(...(hint ? [`${pad}  %% id: ${hint}`] : []), `${pad}  ${text}`);
+    out.push(`${pad}}`);
+  };
+  roots.forEach(n => emit(n, '  '));
+  for (const [hint, text] of relations) out.push(...(hint ? [`  %% id: ${hint}`] : []), `  ${text}`);
+  for (const [hint, link, text] of noteLines) out.push(...(hint ? [`  %% id: ${hint}`] : []), ...(link ? [`  %% link-id: ${link}`] : []), `  ${text}`);
+  for (const x of notWritten) out.push(`  %% not written: ${x}`);
+  return out.join('\n') + '\n';
+}