umlimator 0.23.0 → 0.24.0

package/lib/umlimator-all.js

@@ -134,7 +134,9 @@ const diagramOf = view => TYPES.get(view && view.diagram != null ? view.diagram
    lib/umlimator-all.js holds (tools/build.mjs): rows, rooms and routes in layoutPass, a typed line's ends in svgOf, the
    gestures of edit.js it takes over (edit), diff()'s words for typed models (diff, order: src/uml/diff.js). Empty in
    umlimator.js, where no view is laid out but as a map (risks.md C5).
-   Stage 6's: across(model), validate()'s rules on the whole model; fields(model, x), more panel fields (notes/stage-6.md §5) */
+   Stage 6's: across(model), validate()'s rules on the whole model; fields(model, x), more panel fields (notes/stage-6.md §5)
+   Milestone 2's (notes/milestone-2.md §6.3, §9): unfolds; text(model, view, id), the PDF's line text; ENDS open to
+   families */
 const TYPED = {};
 
 const propRefs = type => Object.assign({}, ...[...TYPES.values()].map(T => T.refs && Object.hasOwn(T.refs, type) && T.refs[type]));
@@ -210,6 +212,9 @@ export function history(model, limit = 100) {
                                              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
+     addView   { view, index? }              a view, added to views at index (else at the end); refused when its id is
+                                             a view's already, or it is not an object with a string id. Nothing else is
+                                             checked: validate() says what it lacks (notes/milestone-2.md §6.2)
    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). */
 
@@ -402,7 +407,14 @@ function run(m, c, gone) {
       e.x.parent = c.parent;
       return;
     }
-    default: throw new Error(`${JSON.stringify(c.op)} is not a command (set, add, move, hide, delete, reparent)`);
+    case 'addView': {
+      const v = c.view, list = (m.views ||= []);
+      if (!isObj(v) || typeof v.id !== 'string') throw new Error('addView: a view is an object with a string id');
+      if (list.some(x => isObj(x) && x.id === v.id)) throw new Error(`addView: view "${v.id}" is there already`);
+      list.splice(place(list, c.index), 0, structuredClone(v));
+      return;
+    }
+    default: throw new Error(`${JSON.stringify(c.op)} is not a command (set, add, move, hide, delete, reparent, addView)`);
   }
 }
 
@@ -2355,7 +2367,7 @@ function mapContext(model, opts = {}) {
   // the inner view's own cards: those this view shows neither as cards nor as boxes (a card unfolded here already is one, #98)
   const ownOf = (v, C, nid) => (C.nodeIds || []).filter(i => N[i] && i !== nid && !(v.nodeIds || []).includes(i) && !(v.containers || []).some(b => b && b.id === i));
   const unfoldable = (nid, vid) => { const v = V[vid], ids = (v && v.nodeIds) || [], c = ids.includes(nid) && N[nid] && v.render !== 'sequence' ? childOf(nid, vid) : null;
-    if (!c || c === vid || chain(vid).includes(c) || (v.containers || []).some(b => b && b.id === nid) || V[c].diagram != v.diagram) return null;
+    if (!c || c === vid || chain(vid).includes(c) || (v.containers || []).some(b => b && b.id === nid) || V[c].diagram != v.diagram || v.diagram && v.diagram != 'map' && !(diagramOf(v) || {}).unfolds) return null;
     return ownOf(v, V[c], nid).length ? c : null; };
   function unfold(vid, nid) {
     const v = V[vid], c = unfoldable(nid, vid); if (!c) return false;
@@ -5827,8 +5839,8 @@ function tablesOf({ D, N, nodeIn, viewEdges }, v, g) {
       return `<tr><td>${d.step ? `<i class="num">${esc(d.step)}</i>` : ''}<b>${esc(c.label || id)}</b>${d.kids || d.opens ? ' ⤢' : ''}${sub ? `<small>${esc(sub)}</small>` : ''}</td>`
         + (typed ? `<td>${esc(T.word?.(D, id) ?? word(c.type || 'uml.Class'))}</td><td>${(Array.isArray(rs) ? rs : arrOf(c.members).filter(m => m && typeof m === 'object').map(m => asText(m))).map(r => `<p>${esc(r)}</p>`).join('')}</td></tr>`
           : `<td><i class="sw" style="border-color:var(--um-${t[0]});background:var(--um-${t[0]}-f)"></i>${t[1]}</td><td>${c.what ? md(c.what) : ''}</td></tr>`); }) },
-    { title: `Lines <span>${es.length}</span>`, cls: 'lines', head: `${seq || stepped ? '<th class="n">#</th>' : ''}<th>From → to</th><th>Label</th><th>${typed ? 'Kind' : 'Technology'}</th>`, rows: (stepped && !seq ? [...es].sort((a, b) => stepOrder(a.step, b.step)) : es).map((e, i) => { const w = wk.get(e._id) || 'calls';
-      return `<tr>${seq ? `<td>${i + 1}</td>` : stepped ? `<td>${esc(e.step ?? '')}</td>` : ''}<td><i class="w" style="border-color:var(--um-w-${w})"></i>${name(v, e.from)} → ${name(v, e.to)}</td><td>${e.label ? esc(e.label) : typed ? '' : `<span class="up">${w}</span>`}</td><td>${esc(typed ? word(e.type) : e.sublabel || '')}</td></tr>`; }) },
+    { title: `Lines <span>${es.length}</span>`, cls: 'lines', head: `${seq || stepped ? '<th class="n">#</th>' : ''}<th>From → to</th><th>Label</th><th>${typed ? 'Kind' : 'Technology'}</th>`, rows: (stepped && !seq ? [...es].sort((a, b) => stepOrder(a.step, b.step)) : es).map((e, i) => { const w = wk.get(e._id) || 'calls', t = typed && T.text?.(D, v, e._id); // a type's text for the line (S17), else its label
+      return `<tr>${seq ? `<td>${i + 1}</td>` : stepped ? `<td>${esc(e.step ?? '')}</td>` : ''}<td><i class="w" style="border-color:var(--um-w-${w})"></i>${name(v, e.from)} → ${name(v, e.to)}</td><td>${t || e.label ? esc(t || e.label) : typed ? '' : `<span class="up">${w}</span>`}</td><td>${esc(typed ? word(e.type) : e.sublabel || '')}</td></tr>`; }) },
     { title: `Boxes <span>${held.length}</span>`, cls: 'boxes', head: '<th>Box</th><th>Holds</th>', rows: held.map(([c, ins]) => `<tr><td><b>${esc(c.label || c.id)}</b></td><td>${andList(ins.map(i => name(v, i)))}</td></tr>`) },
   ];
 }
@@ -5842,7 +5854,7 @@ function tablesOf({ D, N, nodeIn, viewEdges }, v, g) {
 // 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', 'labelGaps', 'laneGap', 'lanes', 'mainSteps', 'nodeH', 'quick', 'repair', 'reroute', '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', 'cut', 'fromPort', 'toPort', 'inner', 'portRank'];
+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', 'cut', 'fromPort', 'toPort', 'inner', 'portRank', 'portMin'];
 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
@@ -5889,6 +5901,8 @@ function layoutTyped(dg, memo) {
      leaves (a port on the left border leaves right) and its point is on the port's own border
    - a line's portRank: the port's place in its owner's members, breaking ties in the order of ports along a side; a number,
      or [from, to] for a line with a port at each end
+   - a line's portMin: the least length in px of its port's box along the border (milestone 4b's boundary event, a 32 px
+     circle: notes/milestone-4b.md §6.2), its ends centred in it; a number, or [from, to] as portRank. None: 2 + 10 k px
    - a box's pad: its padding in px where it is more than stage 2's 12 (48 where it or a box it holds has ports with lines, §7);
      a box's round: true grows its frame by √2 about its centre, so the ellipse drawn in it holds its contents (§9.3)
    - a box's head: px of header room over stage 2's 24, on the side its title is on (the top; laid out down, the left, which
@@ -5920,10 +5934,12 @@ function placePorts(sides, turned) {
 }
 function spreadPorts({ n, side, ends }, turned) {
   const v = side === 'L' || side === 'R', a0 = v ? n.y : n.x, len = v ? n.h : n.w, far = x => v ? x.other.y + x.other.h / 2 : x.other.x + x.other.w / 2;
-  const rank = x => { const r = x.e.portRank; return (Array.isArray(r) ? r[x.from ? 0 : 1] : r) ?? 1e9; }, byFar = (a, b) => far(a) - far(b), groups = [];
+  const per = (x, r) => Array.isArray(r) ? r[x.from ? 0 : 1] : r, least = x => { const m = per(x, x.e.portMin); return Number.isFinite(m) ? m : 0; };
+  const rank = x => per(x, x.e.portRank) ?? 1e9, byFar = (a, b) => far(a) - far(b), groups = [];
   ends.forEach(x => { const g = x.port != null && groups.find(o => o.port === x.port); if (g) g.ends.push(x); else groups.push({ port: x.port, ends: [x] }); });
   groups.forEach(g => { g.faces = [g.ends.filter(x => !x.inner).sort(byFar), g.ends.filter(x => x.inner).sort(byFar)];
-    g.at = g.ends.reduce((a, x) => a + far(x), 0) / g.ends.length; g.L = g.port == null ? 2 : 2 + 10 * Math.max(...g.faces.map(f => f.length)); });
+    g.at = g.ends.reduce((a, x) => a + far(x), 0) / g.ends.length; g.need = g.port == null ? 2 : 2 + 10 * Math.max(...g.faces.map(f => f.length));
+    g.L = g.port == null ? 2 : Math.max(g.need, ...g.ends.map(least)); });
   groups.sort((a, b) => a.at - b.at || rank(a.ends[0]) - rank(b.ends[0]));
   let lo = a0 + 8, hi = a0 + len - 8;
   if (n.box) { const across = turned ? !v : v; // as layoutPass spreads a box's ends: below the title on a side, off the title and corners elsewhere
@@ -5934,7 +5950,7 @@ function spreadPorts({ n, side, ends }, turned) {
   const B = side === 'L' ? n.x : side === 'R' ? n.x + n.w : side === 'T' ? n.y : n.y + n.h;
   let s = (lo + hi - sum - gap * k) / 2;
   groups.forEach(g => { const box = v ? { x: B - 6, y: s, w: 12, h: g.L } : { x: s, y: B - 6, w: g.L, h: 12 };
-    g.faces.forEach(face => face.forEach((x, j) => { const c = g.port == null ? s + 1 : s + 6 + 10 * j;
+    g.faces.forEach(face => face.forEach((x, j) => { const c = g.port == null ? s + 1 : s + (g.L - g.need) / 2 + 6 + 10 * j;
       x.e[x.from ? 'p1' : 'p2'] = v ? [B, c] : [c, B]; if (g.port != null) x.e[x.from ? 'fpb' : 'tpb'] = { ...box }; }));
     s += g.L + gap; });
 }
@@ -6077,14 +6093,16 @@ 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. The socket
-// (notes/stage-5.md §9.2) is a usage's end on an interface drawn as a 16 px ball: a half circle of radius 11 open towards the
-// ball, its middle on the line 3 px before the end (the ball's outline), its centre 8 px past it (the ball's)
+// dashed: a dependency's or realization's line, 'dot' a dotted one (BPMN's association, notes/milestone-4b.md §10);
+// 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. The socket (notes/stage-5.md §9.2) is a usage's end on
+// an interface drawn as a 16 px ball: a half circle of radius 11 open towards the ball, its middle on the line 3 px before
+// the end (the ball's outline), its centre 8 px past it (the ball's)
 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'], socket: [3, 11, 'M11 0A11 11 0 0 0 11 22', 'none'],
-  'filled-triangle': [13, 7, 'M0 0L13 7L0 14Z', 'line'] }; // an extension's, at the metaclass (notes/stage-6.md §4.1)
+  'filled-triangle': [13, 7, 'M0 0L13 7L0 14Z', 'line'], // an extension's, at the metaclass (notes/stage-6.md §4.1)
+  circle: [8, 4, 'M0 4A4 4 0 1 0 8 4A4 4 0 1 0 0 4Z', 'hollow'] }; // a message flow's start, its far side the line's end (notes/milestone-4b.md §10)
 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 } }),
@@ -6128,7 +6146,7 @@ TYPED.lines = ({ id, edges, drawn, lstyle, MC }) => {
   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})` : '';
+      const st = E.dashed ? { ...lstyle(e), dash: E.dashed === 'dot' ? '2 3' : '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('') : '',
   };
@@ -9595,9 +9613,13 @@ function parseFlow(text) {
    laneRows(pos, laneOf, lanes) -> pos'   pos: { id: [col, row] } as ranked (pins included); laneOf: id -> its innermost
                                           lane's id, or null; lanes: [{ id, parent, order }] outermost first, siblings
                                           by `order`, those with none after them in list order. pos' is new: each lane a run of rows
-   laneBands(g, lanes, laneOf, turned, rgap) -> { bands: [{ id, parent, depth, x, y, w, h, head: { x, y, w, h } }], shift, bounds }
+   laneBands(g, lanes, laneOf, turned, rgap, runs) -> { bands: [{ id, parent, depth, x, y, w, h, head: { x, y, w, h } }], shift, bounds }
                                           g: layoutTyped's geometry, read, never written (§2.4); turned: laid out down;
-                                          rgap: the row gap it was laid out with (else the narrowest gap between two rows).
+                                          rgap: the row gap it was laid out with (else the narrowest gap between two rows);
+                                          runs (optional, milestone 4b §5.2): { key: [first, last] }, each lane's rows as
+                                          the type placed them, in place of counting g's nodes; a lane with no run takes its
+                                          nested lanes' rows, and with none has no band; a key that is no lane (the empty
+                                          row between two pools) only counts its rows.
                                           bands are where they lie once the type has moved its copy of g by shift ({ x, y });
                                           bounds: g's bounds so moved and grown to hold the bands
    Rows: lanes in depth-first order, a lane's own nodes in the rows before its nested lanes'; in each column a lane's nodes
@@ -9606,7 +9628,8 @@ function parseFlow(text) {
    Bands: along the flow, the whole diagram and a 22 px header strip per level of nesting at its start; across it, from the
    divider before a lane's first row to the one after its last, each 12 px past the router's line rgap / 2 before the later
    row (gapLinesY), toward it; the outer edges 12 px inside the router's line. An empty lane at an end takes a row that
-   leaves its band 120 px across at least. */
+   leaves its band 120 px across at least. A box's frame (g.families) counts toward the extent of the first and last rows
+   of the nodes it holds, so no divider crosses it (milestone 4b §5.2; the activity type has no boxes). */
 
 const LN = { head: 22, off: 12, pad: 16, gap: 44, row: 64, min: 120 }; // a header level; a divider off the router's line; the bands' margin; the row gap when g has none to measure; an empty end row's least size; an empty end lane's least width
 
@@ -9645,16 +9668,23 @@ function laneRows(pos, laneOf, lanes) {
   return out;
 }
 
-function laneBands(g, lanes, laneOf, turned, rgap) {
+function laneBands(g, lanes, laneOf, turned, rgap, runs) {
   const order = laneOrder(lanes), nodes = (g && g.nodes) || [], b = (g && g.bounds) || { x: 0, y: 0, w: 0, h: 0 };
   const [A, S, L, T] = turned ? ['x', 'w', 'y', 'h'] : ['y', 'h', 'x', 'w']; // across the flow, its size; along it, its size
-  const { start, count, rows } = laneRuns(nodes.map(n => [n.id, n.col]), laneOf, order);
+  let first, last, rows;
+  if (runs && typeof runs === 'object') { const ok = r => Array.isArray(r) && Number.isInteger(r[0]) && Number.isInteger(r[1]) && r[0] >= 0 && r[0] <= r[1], R = Object.values(runs).filter(ok);
+    const run = id => (Object.hasOwn(runs, id) && ok(runs[id]) ? runs[id] : [Infinity, -Infinity]);
+    first = order.map(l => run(l.id)[0]); last = order.map(l => run(l.id)[1]);
+    rows = Math.max(0, ...R.map(r => r[1] + 1), ...nodes.map(n => (Number.isInteger(n.row) ? n.row + 1 : 0))); }
+  else { const c = laneRuns(nodes.map(n => [n.id, n.col]), laneOf, order); rows = c.rows; first = c.start.slice(0, order.length); last = order.map((l, s) => c.start[s] + c.count[s] - 1); }
   // each row's extent across the flow: from its nodes, else between its neighbours; a gap is the narrowest between two rows
   const lo = [], hi = [];
   nodes.forEach(n => { const r = n.row; if (!Number.isInteger(r)) return; lo[r] = Math.min(lo[r] ?? Infinity, n[A]); hi[r] = Math.max(hi[r] ?? -Infinity, n[A] + n[S]); });
   let gap = Infinity; for (let r = 0; r + 1 < rows; r++) if (lo[r] != null && lo[r + 1] != null) gap = Math.min(gap, lo[r + 1] - hi[r]);
   if (gap === Infinity) gap = LN.gap;
   if (Number.isFinite(rgap) && rgap > 0) gap = rgap;
+  ((g && g.families) || []).forEach(f => { const rs = nodes.filter(n => Number.isInteger(n.row) && n.x >= f.x && n.y >= f.y && n.x + n.w <= f.x + f.w && n.y + n.h <= f.y + f.h).map(n => n.row);
+    if (!rs.length) return; const r0 = Math.min(...rs), r1 = Math.max(...rs); lo[r0] = Math.min(lo[r0], f[A]); hi[r1] = Math.max(hi[r1], f[A] + f[S]); });
   const end = Math.max(LN.row, LN.min + 2 * LN.off - gap); // an empty end row: its band, the row and a gap less two offsets, 120 px at least
   for (let r = 0; r < rows;) { if (lo[r] != null) { r++; continue; }
     let e = r; while (e < rows && lo[e] == null) e++; // rows r to e - 1 hold nothing
@@ -9664,13 +9694,13 @@ function laneBands(g, lanes, laneOf, turned, rgap) {
     r = e; }
   const before = r => lo[r] - gap / 2 + LN.off, after = r => (r + 1 < rows ? before(r + 1) : hi[r] + gap / 2 - LN.off); // off the router's lines, which lie rgap / 2 from each row
   // each lane's rows: its own and its nested lanes'
-  const first = start.slice(0, order.length), last = order.map((l, s) => start[s] + count[s] - 1), at = new Map(order.map((l, s) => [l.id, s]));
+  const at = new Map(order.map((l, s) => [l.id, s]));
   order.forEach((l, s) => { for (let p = order[at.get(l.parent)]; p; p = order[at.get(p.parent)]) { const q = at.get(p.id); first[q] = Math.min(first[q], first[s]); last[q] = Math.max(last[q], last[s]); } });
   const levels = order.length ? 1 + Math.max(...order.map(l => l.depth)) : 0, shift = { x: 0, y: 0, [L]: levels * LN.head };
   const a0 = b[L] + LN.pad, a1 = b[L] + b[T] + shift[L] - LN.pad;
-  const bands = order.map((l, s) => { const c0 = before(first[s]), c1 = after(last[s]), s0 = a0 + l.depth * LN.head;
+  const bands = order.flatMap((l, s) => { if (!(first[s] <= last[s])) return []; const c0 = before(first[s]), c1 = after(last[s]), s0 = a0 + l.depth * LN.head;
     const box = len => ({ [L]: r2(s0), [T]: r2(len), [A]: r2(c0), [S]: r2(c1 - c0) });
-    return { id: l.id, parent: l.parent, depth: l.depth, ...box(a1 - s0), head: box(LN.head) }; });
+    return [{ id: l.id, parent: l.parent, depth: l.depth, ...box(a1 - s0), head: box(LN.head) }]; });
   const x0 = Math.min(b.x + shift.x, ...bands.map(d => d.x - LN.pad)), y0 = Math.min(b.y + shift.y, ...bands.map(d => d.y - LN.pad));
   const x1 = Math.max(b.x + b.w + shift.x, ...bands.map(d => d.x + d.w + LN.pad)), y1 = Math.max(b.y + b.h + shift.y, ...bands.map(d => d.y + d.h + LN.pad));
   return { bands, shift, bounds: { x: r2(x0), y: r2(y0), w: r2(x1 - x0), h: r2(y1 - y0) } };
@@ -10257,6 +10287,7 @@ const ACT_TYPE = registerDiagramType('uml.activity', {
   validate: actProblems,
   rules: ACT_RULES,
   describe: actDescribe,
+  unfolds: true, // a call behaviour action unfolds its activity in place (notes/milestone-2.md §6.3)
   edits: { connect: actConnect, moveTo: actMoveTo, add: actAdd, remove: actRemove, rename: actRename },
   // the PDF's tables (§15): a node's kind, and its partition
   word: (model, id) => { const x = AC_ARR(model && model.nodes).find(n => AC_OBJ(n) && n.id === id); return x && Object.hasOwn(AC_LOOK, x.type) ? AC_LOOK[x.type][1] : null; },
@@ -13674,15 +13705,3396 @@ const TM_TYPE = registerDiagramType('uml.timing', {
   rows: tmRows,
   edits: { connect: tmConnect, moveTo: tmMoveTo, add: tmAdd, remove: tmRemove, rename: tmRename, key: tmKeyHook },
 });
+/* ---------- the entity-relationship diagram, er (work package M2.2, notes/milestone-2.md §4, §7.1) ----------
+   Entities (tables) with their columns as rows, the key columns first under a divider; relationships from the referenced
+   entity to the referring one (model.md rule 7), each end chosen from its multiplicity and drawn in the view's notation:
+   crow's foot (the default) or IDEF1X, a repaint on one geometry (§4.3). Identifying solid, non-identifying dashed, in both.
+   A column's row reads and prints `name type [PK] [FK table.column] [UK] [NULL]` (S9). Laid out by layoutTyped with a 48 px
+   gap, labelGaps and labels cut at 280 px; repair and reroute off (S19). Ships in lib/umlimator-all.js only. */
+
+const ER_OBJ = x => x !== null && typeof x === 'object' && !Array.isArray(x), ER_ARR = x => (Array.isArray(x) ? x : []);
+const ER_HAS = x => x != null && x !== '';
+const erName = x => String(x.label ?? x.id);
+const erProps = x => (ER_OBJ(x.props) ? x.props : {});
+const erCols = n => ER_ARR(n.members).filter(c => ER_OBJ(c) && c.type === 'er.Column');
+const erPlural = (k, w) => `${k} ${k === 1 ? w : w + 's'}`;
+const erAnd = a => (a.length < 2 ? a.join('') : a.slice(0, -1).join(', ') + ' and ' + a.at(-1));
+
+// the model read once: nodes by id, every entity's columns by id ({ c, e }), the lines. Each column remembers the model it
+// was last read in, which print (the panel's rows, given a column alone) needs to name what it references
+const ER_SEEN = new WeakMap();
+function erIndex(model) {
+  const at = new Map(), col = new Map();
+  ER_ARR(model && model.nodes).forEach(n => { if (!ER_OBJ(n) || typeof n.id !== 'string' || at.has(n.id)) return; at.set(n.id, n);
+    if (n.type === 'er.Entity') erCols(n).forEach(c => { ER_SEEN.set(c, model); if (typeof c.id === 'string' && !col.has(c.id)) col.set(c.id, { c, e: n }); }); });
+  return { at, col, R: ER_ARR(model && model.edges).filter(e => ER_OBJ(e) && typeof e.id === 'string') };
+}
+
+/* ---- a column's row (S9): name type [PK] [FK table.column] [UK] [NULL], the flags in any order and either case. FK names
+   the referenced column by its entity's and its own labels (or by its id), resolved to its id when the row is read ---- */
+const ER_FLAG = { pk: 'primaryKey', fk: 'foreignKey', uk: 'unique', null: 'nullable' };
+const ER_SYNTAX = ['dataType', 'primaryKey', 'foreignKey', 'unique', 'nullable', 'references'];
+const erFlag = t => Object.hasOwn(ER_FLAG, String(t).toLowerCase());
+function erTokens(s) { // split at spaces outside brackets: "amount numeric(10, 2) NULL"; null when a bracket is left open or closes none
+  const out = []; let depth = 0, cur = '';
+  for (const ch of s) { if ('([{<'.includes(ch)) depth++; else if (')]}>'.includes(ch) && --depth < 0) return null;
+    if (/\s/.test(ch) && !depth) { if (cur) out.push(cur); cur = ''; } else cur += ch; }
+  if (cur) out.push(cur);
+  return depth ? null : out;
+}
+// a column named by table.column, its entity's label and its own, when exactly one column has them; else by its id. Labels
+// first: an id (`<entity id>.<label>`, erNewId) can read as another column's labels once a table is renamed
+function erRef(t, I) {
+  const k = t.indexOf('.'), hit = k > 0 ? [...I.col].filter(([, { c, e }]) => erName(e) === t.slice(0, k) && erName(c) === t.slice(k + 1)) : [];
+  return hit.length === 1 ? hit[0][0] : I.col.has(t) ? t : null;
+}
+// a row's name: its first word, or "in quotes" when it has a space (printColumn writes it so)
+function parseColumn(text, I) {
+  const s = String(text ?? '').trim(), q = /^"([^"]*)"(?=\s|$)/.exec(s), t = erTokens(q ? s.slice(q[0].length) : s), fail = why => ({ error: `"${s}" is not a column: ${why}` });
+  if (!t) return fail('its brackets do not pair');
+  if (q ? !q[1].trim() : !t.length) return fail('it is empty');
+  const label = q ? q[1] : t.shift(), props = {}, type = [];
+  while (t.length && !erFlag(t[0])) type.push(t.shift()); // a type of several words: "double precision", "timestamp with time zone"
+  if (type.length) props.dataType = type.join(' ');
+  while (t.length) { const k = t.shift(), f = erFlag(k) && ER_FLAG[k.toLowerCase()];
+    if (!f) return fail(`"${k}" is left over: write name type [PK] [FK table.column] [UK] [NULL]`);
+    if (props[f]) return fail(`${k.toUpperCase()} is written twice`);
+    props[f] = true;
+    if (f === 'foreignKey' && t.length && !erFlag(t[0])) { const r = t.shift(), id = erRef(r, I); if (id == null) return fail(`FK ${r} names no column (table.column)`); props.references = id; } }
+  return { label, props };
+}
+function printColumn(c, I = erIndex(ER_SEEN.get(c))) {
+  const p = erProps(c), r = ER_HAS(p.references) && I.col.get(p.references), pair = r && `${erName(r.e)}.${erName(r.c)}`;
+  const ref = r && !/[\s.]/.test(erName(r.e) + erName(r.c)) && erRef(pair, I) === p.references ? pair : p.references, name = String(c.label ?? '');
+  return [/\s/.test(name) ? `"${name}"` : name, ER_HAS(p.dataType) && String(p.dataType), p.primaryKey === true && 'PK', (p.foreignKey === true || ER_HAS(ref)) && 'FK', ref, p.unique === true && 'UK', p.nullable === true && 'NULL'].filter(x => typeof x === 'string' && x !== '').join(' ');
+}
+
+/* ---- the entity (§7.1): its name in a 24 px header, then its key columns, a divider, the rest; each row its marks (PK, FK,
+   UK, ? for a nullable column) in a left column, its name, its type in --um-muted; 120 to 320 px wide, every text cut with
+   fit. present.<id>.rows and collapsed (the sections 'keys', 'columns') as the classifier's. Drawing input: label;
+   sections [{ name, rows: [{ marks, name, type }] }]; dep: IDEF1X's dependent entity, drawn with rounded corners ---- */
+const ER = { pad: 8, head: 24, name: 13, px: 11, fpx: 9, rl: 15, gap: 4, empty: 10, sep: 8, minW: 120, maxW: 320, round: 8 };
+const ER_MARK = [['primaryKey', 'PK'], ['foreignKey', 'FK'], ['unique', 'UK'], ['nullable', '?']];
+function erParts(n) {
+  const cap = Number.isFinite(n.rows) ? Math.max(0, Math.floor(n.rows)) : Infinity, hidden = new Set(ER_ARR(n.collapsed));
+  const secs = ER_ARR(n.sections).filter(S => !hidden.has(S.name)).map(S => ({ name: S.name, rows: S.rows.slice(0, cap), more: Math.max(0, S.rows.length - cap) }));
+  const rows = secs.flatMap(S => S.rows), W = (k, px) => Math.max(0, ...rows.map(r => textW(r[k], px)));
+  const fw = W('marks', ER.fpx), nw = W('name', ER.px), tw = W('type', ER.px), lead = fw ? fw + ER.sep : 0;
+  const w = Math.ceil(Math.min(ER.maxW, Math.max(ER.minW, 2 * ER.pad + lead + nw + (tw ? ER.sep + tw : 0), textW(n.label ?? '', ER.name) + 2 * ER.pad,
+    ...secs.filter(S => S.more).map(S => 2 * ER.pad + lead + textW(`+${S.more} more`, ER.px)))));
+  const tall = S => { const k = S.rows.length + (S.more ? 1 : 0); return k ? 2 * ER.gap + k * ER.rl : ER.empty; };
+  return { secs, fw, nw, tw, lead, w, tall, h: ER.head + secs.reduce((a, S) => a + tall(S), 0) };
+}
+function erSvg(n, c, f) {
+  const P = erParts(n), { x, y, w, h } = n, avail = w - 2 * ER.pad - P.lead, nx = x + ER.pad + P.lead, tx = nx + (P.tw ? Math.min(P.nw + ER.sep, Math.max(avail * 0.6, avail - P.tw)) : avail);
+  const rx = n.dep ? ` rx="${ER.round}"` : '', box = `x="${x}" y="${y}" width="${w}" height="${h}"${rx}`;
+  const txt = (X, Y, t, px, wt, fill, cls, max) => `<text x="${r2(X)}" y="${r2(Y)}" class="${cls}" fill="${fill}" style="font:${wt} ${px}px var(--um-sans)">${esc(fit(t, px, max))}</text>`;
+  const out = [`<rect ${box} class="n-mask"/><rect ${box} class="n-body" fill="${f}" stroke="${c}"/>`,
+    `<g class="c-head" data-band="${r2(y)} ${r2(y + ER.head)}"><text x="${r2(x + w / 2)}" y="${r2(y + 16.5)}" text-anchor="middle" class="c-name" fill="var(--um-text)" style="font:600 ${ER.name}px var(--um-sans)" data-o="${esc(n.id)}">${esc(fit(n.label ?? '', ER.name, w - 2 * ER.pad))}</text></g>`];
+  let top = y + ER.head;
+  P.secs.forEach(S => { const at = j => top + ER.gap - 1 + j * ER.rl + 11.5;
+    const rows = S.rows.map((r, j) => (r.marks ? txt(x + ER.pad, at(j), r.marks, ER.fpx, 600, 'var(--um-muted)', 'er-mark', P.fw) : '')
+      + txt(nx, at(j), r.name, ER.px, 400, 'var(--um-text)', 'c-row', P.tw ? tx - nx - ER.sep : avail) + (r.type ? txt(tx, at(j), r.type, ER.px, 400, 'var(--um-muted)', 'er-type', x + w - ER.pad - tx) : ''));
+    if (S.more) rows.push(txt(nx, at(S.rows.length), `+${S.more} more`, ER.px, 400, 'var(--um-muted)', 'c-more', avail));
+    out.push(`<g class="c-comp" data-comp="${S.name}" data-band="${r2(top)} ${r2(top + P.tall(S))}"><path d="M${x} ${r2(top)}H${x + w}" class="n-det" stroke="${c}"/>${rows.join('')}</g>`);
+    top += P.tall(S); });
+  return `<g class="node entity" data-id="${esc(n.id)}" data-shape="entity" tabindex="-1" role="img" aria-label="${esc(n.aria || 'Table ' + (n.label ?? ''))}">${out.join('')}</g>`;
+}
+const ENTITY = { size: n => { const P = erParts(n); return { w: P.w, h: P.h }; }, out: boxOut(0), face: n => [n.y, n.y + n.h], inset: () => 0, draw: erSvg };
+ENTITY.ports = (n, side, k = 1) => portsOn(ENTITY, n, side, k);
+SHAPE.entity = ENTITY;
+
+/* ---- the ends (§4.1, §4.2): six rows of src/typed/draw.js's table, pointing right with the tip on the entity's outline.
+   Crow's foot's are 18 px long, a ring hollow (the stage's background); IDEF1X's dot is a filled 6 px circle, its letter an
+   end label; its diamond, at an optional parent, hollow ---- */
+const ER_RING = 'M1 7A4 4 0 1 0 9 7A4 4 0 1 0 1 7Z';
+Object.assign(ENDS, { 'cf-one': [18, 7, 'M0 7H18M8 0V14M12 0V14', 'none'], 'cf-zero-one': [18, 7, `M0 7H1M9 7H18M13 0V14${ER_RING}`, 'hollow'],
+  'cf-one-many': [18, 7, 'M0 7H18M4 0V14M8 7L18 0M8 7L18 14', 'none'], 'cf-zero-many': [18, 7, `M0 7H1M9 7H18M10 7L18 0M10 7L18 14${ER_RING}`, 'hollow'],
+  'idef-dot': [6, 3, 'M0 3A3 3 0 1 0 6 3A3 3 0 1 0 0 3Z', 'line'], 'idef-diamond': [12, 5, 'M0 5L6 0L12 5L6 10Z', 'hollow'] });
+
+// a multiplicity's bounds when a relationship's end can have them (an upper bound of 1 or more, the lower not above it)
+const erBounds = t => { const b = ER_HAS(t) ? multBounds(t) : null; return b && b.upper >= 1 && b.lower <= b.upper ? b : null; };
+const ER_FORMS = { '1 1': ['cf-one', 'exactly one', '1'], '0 1': ['cf-zero-one', 'zero or one', 'Z'], '1 Infinity': ['cf-one-many', 'one or more', 'P'], '0 Infinity': ['cf-zero-many', 'zero or more', undefined] };
+const erForm = b => ER_FORMS[`${b.lower} ${b.upper}`];
+const erMult = (e, w) => { const E = erProps(e).ends; return ER_OBJ(E) && ER_OBJ(E[w]) ? E[w].multiplicity : undefined; };
+const erSay = t => { const b = erBounds(t); return b && erForm(b) ? erForm(b)[1] : ER_HAS(t) ? String(t) : 'no multiplicity'; };
+// an end as drawn: [its name in ENDS, its end label]. Crow's foot: the nearest of the four by its bounds, the text written
+// when it is none of them; IDEF1X: at the parent (from) nothing for 1, a diamond for 0..1, else a dot; at the child a dot,
+// with 1, Z, P, nothing or the text. Unreadable: no end, the text as its label
+function erEnd(e, w, idef) {
+  const t = erMult(e, w), b = erBounds(t), s = ER_HAS(t) ? String(t) : undefined;
+  if (!b) return ['none', s];
+  const F = erForm(b);
+  if (!idef) return [ER_FORMS[`${b.lower ? 1 : 0} ${b.upper > 1 ? 'Infinity' : 1}`][0], F ? undefined : s];
+  if (w === 'from' && b.upper === 1) return [b.lower ? 'none' : 'idef-diamond'];
+  return ['idef-dot', F ? F[2] : s];
+}
+const erIdentifying = e => erProps(e).identifying === true;
+function erLook(e, idef) {
+  if (e.type !== 'er.Relationship') return { from: 'none', to: 'none', dashed: true }; // a comment link
+  const [f, fl] = erEnd(e, 'from', idef), [t, tl] = erEnd(e, 'to', idef);
+  return { from: f, to: t, dashed: !erIdentifying(e), labels: { from: { mult: fl }, to: { mult: tl } } };
+}
+
+/* ---- names (A1) and the view's words ---- */
+function erNodeName(n) {
+  if (n.type === 'uml.Comment') return 'Comment: ' + erName(n);
+  const cs = erCols(n), keys = cs.filter(c => erProps(c).primaryKey === true).map(erName);
+  return `Table ${erName(n)}, ${keys.length ? 'key ' + erAnd(keys) : 'no key'}, ${erPlural(cs.length, 'column')}`;
+}
+// "Identifying relationship contains from order (exactly one) to order_line (one or more)"
+function erLineName(e, I) {
+  const nm = id => (I.at.has(id) ? erName(I.at.get(id)) : String(id));
+  if (e.type !== 'er.Relationship') return `Comment link from ${nm(e.from)} to ${nm(e.to)}`;
+  return `${erIdentifying(e) ? 'Identifying' : 'Non-identifying'} relationship ${ER_HAS(e.label) ? e.label + ' ' : ''}from ${nm(e.from)} (${erSay(erMult(e, 'from'))}) to ${nm(e.to)} (${erSay(erMult(e, 'to'))})`;
+}
+const erShown = (model, view) => { const I = erIndex(model); return { I, ids: [...new Set(ER_ARR(view.nodeIds))].filter(id => I.at.has(id)) }; };
+// the lines drawn: those the view lists, or with no list the model's relationships and comment links, between two it shows
+function erLines(view, I, ids) {
+  const shown = new Set(ids), E = new Map(I.R.map(e => [e.id, e]));
+  const list = Array.isArray(view.edges) ? view.edges.map(x => (typeof x === 'string' ? E.get(x) : x)) : I.R.filter(e => e.type === 'er.Relationship' || e.type === 'uml.CommentLink');
+  return list.filter(e => ER_OBJ(e) && typeof e.id === 'string' && shown.has(e.from) && shown.has(e.to));
+}
+
+/* ---- the legend: the two line looks drawn, then each end drawn, a small copy of its ENDS row ---- */
+const ER_SAYS = { 'cf-one': ['Exactly one', 'one and only one at that end'], 'cf-zero-one': ['Zero or one', 'at most one at that end'],
+  'cf-one-many': ['One or more', 'at least one at that end'], 'cf-zero-many': ['Zero or more', 'any number at that end'],
+  'idef-dot': ['Child end', 'zero or more; P one or more, Z zero or one, a number exactly that many'], 'idef-diamond': ['Optional parent', 'zero or one parent'] };
+const erGlyph = (end, dashed, name, says) => { const E = end !== 'none' && ENDS[end], k = 0.7, L = E ? E[0] * k : 0;
+  const mark = E ? `<g transform="translate(${r2(26 - L)} ${r2(8 - E[1] * k)}) scale(${k})"><path d="${E[2]}" fill="${E[3] === 'line' ? 'var(--um-muted)' : E[3] === 'hollow' ? 'var(--um-panel)' : 'none'}"/></g>` : '';
+  return `<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${r2(26 - L)}"${dashed ? ' stroke-dasharray="3 2"' : ''}/>${mark}</g></svg><b>${esc(name)}</b><span>${esc(says)}</span></span>`; };
+function erLegend(edges, dep) {
+  const rel = edges.filter(e => e.type === 'er.Relationship'), ends = new Set(rel.flatMap(e => [e.end.from, e.end.to]));
+  return [...(rel.some(e => !e.end.dashed) ? [erGlyph('none', false, 'Identifying', 'the child\'s key holds the parent\'s key')] : []),
+    ...(rel.some(e => e.end.dashed) ? [erGlyph('none', true, 'Non-identifying', 'the child refers to the parent outside its key')] : []),
+    ...Object.keys(ER_SAYS).filter(k => ends.has(k)).map(k => erGlyph(k, false, ...ER_SAYS[k])),
+    ...(dep ? [`<span class="lgi" title="Dependent entity — its key holds its parent's"><svg class="lgs" viewBox="0 0 28 16" aria-hidden="true"><rect x="3" y="2" width="22" height="12" rx="4" fill="none" stroke="var(--um-muted)" stroke-width="1.4"/></svg><b>Dependent entity</b><span>rounded corners: its key holds its parent's</span></span>`] : []),
+    ...(edges.some(e => e.type === 'uml.CommentLink') ? [erGlyph('none', true, 'Comment link', 'what a comment is about')] : [])];
+}
+
+/* ---- the view laid out: one geometry for both notations (§4.3): the notation picks the ends and IDEF1X's rounded corners,
+   neither in the geometry key, so a switch repaints ---- */
+const erPick = (o, k) => (ER_OBJ(o) && Object.hasOwn(o, k) ? o[k] : undefined);
+function erSections(n) {
+  const row = c => { const p = erProps(c); return { name: erName(c), type: ER_HAS(p.dataType) ? String(p.dataType) : '', marks: ER_MARK.filter(([k]) => p[k] === true).map(m => m[1]).join(' ') }; };
+  const cs = erCols(n), keys = cs.filter(c => erProps(c).primaryKey === true), rest = cs.filter(c => erProps(c).primaryKey !== true);
+  return [...(keys.length ? [{ name: 'keys', rows: keys.map(row) }] : []), ...(rest.length || !keys.length ? [{ name: 'columns', rows: rest.map(row) }] : [])];
+}
+// IDEF1X's dependent entity: the child of an identifying relationship (its key holds the parent's)
+const erDependent = (I, id) => I.R.some(e => e.type === 'er.Relationship' && e.to === id && erIdentifying(e));
+function erGeo({ model, view, pos, memo }) {
+  const { I, ids } = erShown(model, view), idef = view.notation === 'idef1x', lines = erLines(view, I, ids), P = id => erPick(pos, id) || [0, 0];
+  const nodes = ids.map(id => { const n = I.at.get(id), pr = ER_OBJ(erPick(view.present, id)) ? view.present[id] : {};
+    const d = n.type === 'uml.Comment' ? { shape: 'note' } : { shape: 'entity', sections: erSections(n), collapsed: ER_ARR(pr.collapsed), ...(Number.isFinite(pr.rows) ? { rows: pr.rows } : {}), ...(idef && erDependent(I, id) ? { dep: true } : {}) };
+    const x = { id, label: erName(n), type: n.type || 'er.Entity', kind: 'file', ...d, aria: erNodeName(n), col: P(id)[0], row: P(id)[1] };
+    return { ...x, ...SHAPE[x.shape].size(x) }; });
+  const edges = lines.map(e => ({ id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, label: ER_HAS(e.label) ? String(e.label) : undefined, end: erLook(e, idef), aria: erLineName(e, I), cut: 280,
+    ...(ER_OBJ(e.style) || typeof e.style === 'string' ? { style: e.style } : {}) }));
+  const g = layoutTyped({ nodes, edges, direction: view.direction === 'down' ? 'down' : 'right', gap: 48, rgap: 56, labelGaps: true, repair: false, reroute: false }, memo);
+  return { ...g, legend: erLegend(g.edges, nodes.some(n => n.dep)), order: [...ids, ...lines.map(e => e.id)] }; // a new object: what layoutTyped returned is not edited
+}
+
+/* ---- validators (§7.1). Each problem: { level, rule, path, message, ids } ---- */
+const ER_RULES = {
+  'pk-exists': 'an entity has a primary key column',
+  'column-names': 'column names are unique within an entity',
+  'fk-target': 'a column\'s references names a column of an entity (an error), one that is a key or unique (a warning)',
+  'fk-flag': 'a column with references is a foreign key, and a foreign key has references',
+  'relationship-fk': 'a relationship from A to B has a column of B that references a column of A',
+  'identifying-key': 'an identifying relationship\'s foreign key columns are part of the child\'s primary key',
+  'identifying-parent': 'an identifying relationship\'s parent end is 1',
+  'relationship-ends': 'each end\'s multiplicity is readable (an error), and one of 1, 0..1, 1..* and 0..* (a warning)',
+  'relationship-tables': 'a relationship joins two tables',
+  'notation': 'an er view\'s notation is crowsfoot or idef1x',
+};
+// the columns of entity b that reference a column of entity a
+const erFks = (I, a, b) => erCols(I.at.get(b) || {}).filter(c => { const r = I.col.get(erProps(c).references); return r && r.e.id === a; });
+function erProblems(model) {
+  const out = [], I = erIndex(model), say = (level, rule, path, ids, msg) => out.push({ level, rule, path, ids: ids.filter(x => x != null), message: `${rule}: ${msg}` });
+  const q = id => JSON.stringify(I.at.has(id) ? erName(I.at.get(id)) : String(id)), qc = r => JSON.stringify(`${erName(r.e)}.${erName(r.c)}`);
+  ER_ARR(model && model.nodes).forEach((n, i) => { if (!ER_OBJ(n) || n.type !== 'er.Entity' || I.at.get(n.id) !== n) return;
+    const seen = new Map();
+    if (!erCols(n).some(c => erProps(c).primaryKey === true)) say('warning', 'pk-exists', `nodes[${i}]`, [n.id], `${q(n.id)} has no primary key column`);
+    ER_ARR(n.members).forEach((c, j) => { if (!ER_OBJ(c) || c.type !== 'er.Column') return;
+      const path = `nodes[${i}].members[${j}]`, p = erProps(c), me = qc({ e: n, c }), was = seen.get(erName(c));
+      if (was) say('error', 'column-names', path, [n.id, was, c.id], `${q(n.id)} has two columns named ${JSON.stringify(erName(c))} (${was}, ${c.id})`); else seen.set(erName(c), c.id);
+      if (ER_HAS(p.references)) { const r = I.col.get(p.references);
+        if (!r) say('error', 'fk-target', `${path}.props.references`, [c.id], `${me} references ${JSON.stringify(String(p.references))}, which is no column of an entity`);
+        else if (erProps(r.c).primaryKey !== true && erProps(r.c).unique !== true) say('warning', 'fk-target', `${path}.props.references`, [c.id, r.c.id], `${me} references ${qc(r)}, which is neither a key nor unique`); }
+      if (ER_HAS(p.references) && p.foreignKey !== true) say('warning', 'fk-flag', path, [c.id], `${me} references a column but is not marked FK`);
+      if (p.foreignKey === true && !ER_HAS(p.references)) say('warning', 'fk-flag', path, [c.id], `${me} is a foreign key that references no column`); }); });
+  ER_ARR(model && model.edges).forEach((e, i) => { if (!ER_OBJ(e) || e.type !== 'er.Relationship') return;
+    const path = `edges[${i}]`, A = e.from, B = e.to, ent = id => (I.at.get(id) || {}).type === 'er.Entity';
+    ['from', 'to'].forEach(w => { const t = erMult(e, w), b = erBounds(t);
+      if (!b) say('error', 'relationship-ends', `${path}.props.ends.${w}.multiplicity`, [e.id], `the ${w} end of ${e.id} has ${ER_HAS(t) ? `multiplicity ${JSON.stringify(String(t))}, which is not readable` : 'no multiplicity'}`);
+      else if (!erForm(b)) say('warning', 'relationship-ends', `${path}.props.ends.${w}.multiplicity`, [e.id], `the ${w} end of ${e.id} has multiplicity ${JSON.stringify(String(t))}, none of 1, 0..1, 1..* and 0..*: drawn as the nearest, with its text`); });
+    if (!ent(A) || !ent(B)) { const not = [A, B].filter(id => I.at.has(id) && !ent(id)); // a missing end is the core's to say
+      if (not.length) say('error', 'relationship-tables', path, [e.id, ...not], `${e.id} joins ${erAnd(not.map(q))}, which ${not.length === 1 ? 'is not a table' : 'are not tables'}`);
+      return; }
+    const fks = erFks(I, A, B);
+    if (!fks.length) say('warning', 'relationship-fk', path, [e.id, A, B], `${e.id} runs from ${q(A)} to ${q(B)}, and no column of ${q(B)} references a column of ${q(A)}`);
+    if (!erIdentifying(e)) return;
+    const b = erBounds(erMult(e, 'from'));
+    if (b && (b.lower !== 1 || b.upper !== 1)) say('error', 'identifying-parent', `${path}.props.ends.from.multiplicity`, [e.id, A], `${e.id} is identifying, so its parent end at ${q(A)} is 1, not ${JSON.stringify(String(erMult(e, 'from')))}`);
+    // a column out of the key may be another relationship's of the pair, a non-identifying one: then one in the key will do.
+    // ponytail: the model does not say which columns are which relationship's; a relationship naming its columns would
+    const out2 = fks.filter(c => erProps(c).primaryKey !== true), shared = I.R.some(x => x !== e && x.type === 'er.Relationship' && x.from === A && x.to === B && !erIdentifying(x));
+    if (out2.length && (!shared || out2.length === fks.length)) say('error', 'identifying-key', path, [e.id, B, ...out2.map(c => c.id)], `${e.id} is identifying, but ${erAnd(out2.map(erName))} of ${q(B)} ${out2.length === 1 ? 'is' : 'are'} not in its primary key`); });
+  ER_ARR(model && model.views).forEach((v, i) => { if (ER_OBJ(v) && v.diagram === 'er' && v.notation != null && v.notation !== 'crowsfoot' && v.notation !== 'idef1x')
+    say('warning', 'notation', `views[${i}].notation`, [v.id], `${JSON.stringify(String(v.id))} has notation ${JSON.stringify(String(v.notation))}, drawn as crowsfoot: write crowsfoot or idef1x`); });
+  return out;
+}
+
+/* ---- describe(): the view in sentences, each element by its accessible name and an entity's rows, in reading order, then
+   each line ---- */
+function erDescribe(model, viewId) {
+  const v = ER_ARR(model && model.views).find(x => ER_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const { I, ids } = erShown(model, v), lines = erLines(v, I, ids), say = n => { const cs = erCols(n); return erNodeName(n) + (cs.length ? ': ' + cs.map(c => printColumn(c, I)).join('; ') : ''); };
+  return [`${v.title || v.id}: an entity-relationship diagram of ${erPlural(ids.length, 'element')} and ${erPlural(lines.length, 'line')}.`,
+    ...ids.map(id => say(I.at.get(id)) + '.'), ...lines.map(e => erLineName(e, I) + '.')].join('\n');
+}
+
+/* ---- editing (§7.1) ---- */
+const erNewId = (model, base) => { const used = new Set(); JSON.stringify(model, (k, v) => { if (k === 'id' && typeof v === 'string') used.add(v); return v; });
+  let k = 2, id = base; while (used.has(id)) id = `${base}-${k++}`; return id; };
+// a row of the panel's Members, read as S9's: a new column, or a column's name and syntax props set (its other props kept)
+function erMember(model, view, owner, id, text) {
+  const I = erIndex(model); if ((I.at.get(owner) || {}).type !== 'er.Entity') return null;
+  const r = parseColumn(text, I); if (r.error) return r;
+  if (id == null) return [{ op: 'add', element: { id: erNewId(model, `${owner}.${r.label}`), type: 'er.Column', label: r.label, ...(Object.keys(r.props).length ? { props: r.props } : {}) }, owner }];
+  const m = (I.col.get(id) || {}).c; if (!m) return null;
+  const keep = Object.fromEntries(Object.entries(erProps(m)).filter(([k]) => !ER_SYNTAX.includes(k)));
+  return [{ op: 'set', id, path: 'label', value: r.label }, { op: 'set', id, path: 'props', value: { ...keep, ...r.props } }];
+}
+// connect: a relationship joins two tables (the palette's entry gives it 1 to 0..*, non-identifying); else said
+function erConnect(model, view, from, to, at, line) {
+  if (!ER_OBJ(line) || line.type !== 'er.Relationship') return null;
+  const I = erIndex(model), ent = id => (I.at.get(id) || {}).type === 'er.Entity';
+  return ent(from) && ent(to) ? null : { error: 'A relationship joins two tables' };
+}
+
+/* ---- the type ---- */
+const erMultField = w => ({ key: `ends.${w}.multiplicity`, path: ['ends', w, 'multiplicity'], label: `${w === 'from' ? 'Parent' : 'Child'} multiplicity`, kind: 'text' });
+const ER_TYPE = registerDiagramType('er', {
+  title: 'entity-relationship diagram',
+  elements: [{ type: 'er.Entity', label: 'Table' }, { type: 'uml.Comment', label: 'Comment' }],
+  lines: [{ type: 'er.Relationship', label: 'Relationship', props: { identifying: false, ends: { from: { multiplicity: '1' }, to: { multiplicity: '0..*' } } } }, { type: 'uml.CommentLink', label: 'Comment link' }],
+  props: { 'er.Entity': [], 'uml.Comment': [], 'uml.CommentLink': [],
+    'er.Column': [['dataType', 'Type', 'text'], ['primaryKey', 'Primary key', 'bool'], ['foreignKey', 'Foreign key', 'bool'], ['references', 'References (column id)', 'text'], ['unique', 'Unique', 'bool'], ['nullable', 'Nullable', 'bool']].map(([key, label, kind]) => ({ key, label, kind })),
+    'er.Relationship': [{ key: 'identifying', label: 'Identifying', kind: 'bool' }, erMultField('from'), erMultField('to')] },
+  refs: { 'er.Column': { 'props.references': 'drop' } }, // a deleted column leaves the columns that referenced it
+  layout: erGeo,
+  // ponytail: the panel's member.print is given a column alone; the panel asks owners, with the live model, just before it,
+  // so that model is read here and print names a referenced column by labels. No Owner field (null). A hook given the model ends this
+  owners: model => (erIndex(model), null),
+  member: { print: c => printColumn(c), holds: n => n.type === 'er.Entity' }, // rows are read by edits.member, which has the model
+  validate: erProblems,
+  rules: ER_RULES,
+  describe: erDescribe,
+  // the PDF's tables (§9): an entity's word and its columns as S9 prints them; a relationship's multiplicities
+  word: (model, id) => ((erIndex(model).at.get(id) || {}).type === 'er.Entity' ? 'Table' : null),
+  rows: (model, view, id) => { const I = erIndex(model), n = I.at.get(id); return n && n.type === 'er.Entity' ? erCols(n).map(c => printColumn(c, I)) : null; },
+  text: (model, view, id) => { const e = erIndex(model).R.find(x => x.id === id);
+    return e && e.type === 'er.Relationship' ? `${ER_HAS(e.label) ? e.label + ': ' : ''}${erMult(e, 'from') ?? '?'} to ${erMult(e, 'to') ?? '?'}, ${erIdentifying(e) ? 'identifying' : 'non-identifying'}` : null; },
+  edits: { member: erMember, connect: erConnect },
+});
+/* ---------- the flowchart, flowchart (work package M2.3, notes/milestone-2.md §7.2) ----------
+   Ten symbols: the decision is stage 4's diamond and the connector a circle over SHAPE.initial's outline, both read only;
+   the database is drawn over the map's cylinder's outline with a lid line of its own (the cylinder's det is tinted by a map
+   kind); the other seven are this file's, each with size, out, inset (a line's end slid onto it, stage 4 §4.2), face, ports
+   and draw. A node's text is flowWrap's, three lines of 180 px, then cut, inside the shape's text box (its padding per
+   side, FC_SHAPES). Flows are solid with a filled arrow, their labels cut at 280 px. Laid out down unless the view says
+   right (model.md row 21), gap 48 with gapAfter's widening, labelGaps, repair and reroute off (§11). Ships in
+   lib/umlimator-all.js only. */
+
+const FC_OBJ = x => x !== null && typeof x === 'object' && !Array.isArray(x), FC_ARR = x => (Array.isArray(x) ? x : []);
+const FC_TXT = x => (x != null && String(x).trim() !== '' ? String(x).trim() : '');
+const FC = { px: 12, lh: 16, max: 180, padX: 12, padY: 8, minW: 96, minH: 40, slant: 14, wave: 5, slope: 12, side: 8, line: 'var(--um-muted)', ink: 'var(--um-text)', bg: 'var(--um-stage-bg)' };
+// each node type: its shape and its word (accessible names, the PDF, the legend)
+const FC_LOOK = {
+  'flow.Terminator': ['terminator', 'Terminator'], 'flow.Process': ['process', 'Process'], 'flow.Decision': ['diamond', 'Decision'],
+  'flow.InputOutput': ['io', 'Input/output'], 'flow.PredefinedProcess': ['predefined', 'Predefined process'], 'flow.Document': ['doc', 'Document'],
+  'flow.Database': ['database', 'Database'], 'flow.ManualInput': ['manual', 'Manual input'], 'flow.Delay': ['delay', 'Delay'],
+  'flow.Connector': ['connector', 'Connector'], 'uml.Comment': ['note', 'Comment'],
+};
+const FC_NODES = Object.keys(FC_LOOK).filter(t => t !== 'uml.Comment'); // what a flow may end on
+const fcLook = x => (Object.hasOwn(FC_LOOK, x.type) ? FC_LOOK[x.type] : ['process', String(x.type || 'Node').split('.').pop()]);
+
+/* ---- the shapes ---- */
+const arcIn = (r, u) => r - Math.sqrt(Math.max(0, r * r - Math.min(r, Math.abs(u)) ** 2)); // a circle's depth at u from its axis
+const grow = (n, d) => ({ x: n.x - d, y: n.y - d, w: n.w + 2 * d, h: n.h + 2 * d });
+const WAVE = FC.wave / 0.2887; // a cubic's control offset that swings its curve by FC.wave each way
+// the document's wavy bottom at u (0 at its right, 1 at its left): how far above the box's bottom it is
+const waveIn = u => FC.wave - 3 * WAVE * u * (1 - u) * (2 * u - 1);
+// [text padding left, right, top, bottom] past FC.padX and FC.padY, out(n, d), inset(n, side, t), det(n): a shape's own
+const FC_SHAPES = {
+  process: [() => [0, 0, 0, 0], boxOut(0), () => 0],
+  terminator: [h => [h / 4, h / 4, 0, 0], (n, d = 0) => boxOut(n.h / 2)(n, d),
+    (n, s, t) => { const r = n.h / 2; return s === 'L' || s === 'R' ? arcIn(r, t - n.y - r) : t < n.x + r ? arcIn(r, n.x + r - t) : t > n.x + n.w - r ? arcIn(r, t - n.x - n.w + r) : 0; }],
+  io: [() => [FC.slant, FC.slant, 0, 0], (n, d = 0) => { const { x, y, w, h } = grow(n, d), k = FC.slant; return `M${r2(x + k)} ${r2(y)}H${r2(x + w)}L${r2(x + w - k)} ${r2(y + h)}H${r2(x)}Z`; },
+    (n, s, t) => { const k = FC.slant, v = Math.min(1, Math.max(0, (t - n.y) / n.h)), u = Math.max(0, Math.min(1, (n.x + k - t) / k)), b = Math.max(0, Math.min(1, (t - n.x - n.w + k) / k));
+      return s === 'L' ? k * (1 - v) : s === 'R' ? k * v : s === 'T' ? n.h * u : n.h * b; }],
+  predefined: [() => [FC.side, FC.side, 0, 0], boxOut(0), () => 0,
+    n => `<path d="M${r2(n.x + FC.side)} ${r2(n.y)}V${r2(n.y + n.h)}M${r2(n.x + n.w - FC.side)} ${r2(n.y)}V${r2(n.y + n.h)}" class="n-det" stroke="${FC.line}"/>`],
+  doc: [() => [0, 0, 0, 2 * FC.wave], (n, d = 0) => { const { x, y, w, h } = grow(n, d), b = y + h - FC.wave;
+    return `M${r2(x)} ${r2(y)}H${r2(x + w)}V${r2(b)}C${r2(x + 2 * w / 3)} ${r2(b - WAVE)} ${r2(x + w / 3)} ${r2(b + WAVE)} ${r2(x)} ${r2(b)}Z`; },
+  (n, s, t) => (s === 'B' ? waveIn(Math.max(0, Math.min(1, (n.x + n.w - t) / n.w))) : 0), null, n => [n.y, n.y + n.h - FC.wave]],
+  // the map's cylinder's outline; its lid's front edge drawn here, in the typed line colour
+  database: [() => [0, 0, 12, 6], (n, d = 0) => SHAPE.cylinder.out(n, d), (n, s, t) => SHAPE.cylinder.inset(n, s, t),
+    n => { const ry = SHAPE.cylinder.ry(n); return `<path d="M${r2(n.x)} ${r2(n.y + ry)}A${r2(n.w / 2)} ${ry} 0 0 0 ${r2(n.x + n.w)} ${r2(n.y + ry)}" class="n-det" fill="none" stroke="${FC.line}"/>`; },
+    n => SHAPE.cylinder.face(n)],
+  manual: [() => [0, 0, FC.slope, 0], (n, d = 0) => { const { x, y, w, h } = grow(n, d); return `M${r2(x)} ${r2(y + FC.slope)}L${r2(x + w)} ${r2(y)}V${r2(y + h)}H${r2(x)}Z`; },
+    (n, s, t) => (s === 'T' ? FC.slope * Math.max(0, Math.min(1, 1 - (t - n.x) / n.w)) : s === 'L' && t < n.y + FC.slope ? n.w * (n.y + FC.slope - t) / FC.slope : 0), null, n => [n.y + FC.slope, n.y + n.h]],
+  delay: [h => [0, h / 2, 0, 0], (n, d = 0) => { const { x, y, w, h } = grow(n, d), r = h / 2; return `M${r2(x)} ${r2(y)}H${r2(x + w - r)}A${r2(r)} ${r2(r)} 0 0 1 ${r2(x + w - r)} ${r2(y + h)}H${r2(x)}Z`; },
+    (n, s, t) => { const r = n.h / 2; return s === 'R' ? arcIn(r, t - n.y - r) : (s === 'T' || s === 'B') && t > n.x + n.w - r ? arcIn(r, t - n.x - n.w + r) : 0; }],
+};
+const fcG = (n, shape, said, inner) => `<g class="node ${shape}" data-id="${esc(n.id)}" data-shape="${shape}" tabindex="-1" role="img" aria-label="${esc(n.aria || said)}">${inner}</g>`;
+const fcBody = d => `<path d="${d}" class="n-mask"/><path d="${d}" class="n-body" fill="${FC.bg}" stroke="${FC.line}"/>`;
+const fcText = (cx, y, t) => `<text x="${r2(cx)}" y="${r2(y)}" text-anchor="middle" class="c-name" fill="${FC.ink}" style="font:600 ${FC.px}px var(--um-sans)">${esc(t)}</text>`;
+const fcSaid = (n, word) => (FC_TXT(n.label) ? `${word} ${FC_TXT(n.label)}` : word);
+for (const [shape, [pad, out, inset, det, face]] of Object.entries(FC_SHAPES)) {
+  const word = Object.values(FC_LOOK).find(l => l[0] === shape)[1];
+  const S = SHAPE[shape] = { out, inset, face: face || (n => [n.y, n.y + n.h]),
+    size(n) { const ls = flowWrap(n.label, FC.px, FC.max, 3), h = Math.max(FC.minH, 2 * FC.padY + Math.max(1, ls.length) * FC.lh), [l, r, t, b] = pad(h);
+      return { w: Math.ceil(Math.max(FC.minW, ...ls.map(x => textW(x, FC.px) + 2 * FC.padX)) + l + r), h: Math.ceil(h + t + b) }; },
+    draw(n) { const [l, r, t, b] = pad(n.h), w = n.w - l - r - 2 * FC.padX, ls = flowWrap(n.label, FC.px, FC.max, 3);
+      const y0 = n.y + t + (n.h - t - b - ls.length * FC.lh) / 2, cx = n.x + l + (n.w - l - r) / 2;
+      return fcG(n, shape, fcSaid(n, word), fcBody(out(n)) + (det ? det(n) : '') + ls.map((x, i) => fcText(cx, y0 + i * FC.lh + 12, fit(x, FC.px, w))).join('')); } };
+  S.ports = (n, side, k = 1) => portsOn(S, n, side, k);
+}
+// the connector: a circle 28 px across, or as wide as its label (one or two characters) up to 40 px, a longer label cut
+SHAPE.connector = { out: SHAPE.initial.out, inset: SHAPE.initial.inset, face: n => [n.y, n.y + n.h],
+  size: n => { const d = Math.min(40, Math.max(28, Math.ceil(textW(FC_TXT(n.label), FC.px) + 10))); return { w: d, h: d }; },
+  draw: n => fcG(n, 'connector', fcSaid(n, 'Connector'), fcBody(SHAPE.initial.out(n)) + (FC_TXT(n.label) ? fcText(n.x + n.w / 2, n.y + n.h / 2 + 4, fit(FC_TXT(n.label), FC.px, n.w - 6)) : '')) };
+SHAPE.connector.ports = (n, side, k = 1) => portsOn(SHAPE.connector, n, side, k);
+
+/* ---- the view read: its nodes, its lines, its flows in and out of each node, its starts and ends, its reading order ---- */
+function fcIndex(model, view) {
+  const N = new Map(), E = new Map(), path = new Map();
+  FC_ARR(model && model.nodes).forEach((n, k) => { if (FC_OBJ(n) && typeof n.id === 'string' && !N.has(n.id)) { N.set(n.id, n); path.set(n.id, `nodes[${k}]`); } });
+  FC_ARR(model && model.edges).forEach((e, k) => { if (FC_OBJ(e) && typeof e.id === 'string' && !E.has(e.id)) { E.set(e.id, e); path.set(e.id, `edges[${k}]`); } });
+  const ids = view ? [...new Set(FC_ARR(view.nodeIds).filter(id => N.has(id)))] : [...N.keys()].filter(id => Object.hasOwn(FC_LOOK, N.get(id).type)), on = new Set(ids);
+  const list = view && Array.isArray(view.edges) ? view.edges.map(x => (typeof x === 'string' ? E.get(x) : x)) : [...E.values()].filter(e => e.type === 'flow.Flow' || e.type === 'uml.CommentLink');
+  const lines = list.filter(e => FC_OBJ(e) && typeof e.id === 'string' && on.has(e.from) && on.has(e.to)), flows = lines.filter(e => e.type === 'flow.Flow');
+  const ins = id => flows.filter(e => e.to === id), outs = id => flows.filter(e => e.from === id);
+  const term = id => N.get(id).type === 'flow.Terminator', starts = ids.filter(id => term(id) && !ins(id).length), ends = ids.filter(id => term(id) && !outs(id).length);
+  // reading order: from each start along its flows, depth first, a decision's exits in the model's order (one branch read to its end before the next)
+  const walk = [], seen = new Set(), visit = s => { const q = [s]; while (q.length) { const id = q.pop(); if (seen.has(id)) continue; seen.add(id); walk.push(id); outs(id).reverse().forEach(e => q.push(e.to)); } };
+  starts.forEach(visit); const reached = new Set(seen); ids.forEach(visit);
+  return { N, E, path, ids, lines, flows, ins, outs, starts, ends, walk, reached };
+}
+const fcName = x => String(x.label ?? x.id);
+const fcCalled = x => (x ? (FC_TXT(x.label) || fcLook(x)[1].toLowerCase()) : '?');
+const fcPlural = (k, w) => `${k} ${k === 1 ? w : w + 's'}`;
+
+// accessible names (A1): "Decision Fit for resale?, exits yes to Refund the payment, no to Rejection letter"; "Terminator Return closed, an end"
+function fcNodeName(I, x) {
+  if (x.type === 'uml.Comment') return 'Comment: ' + fcName(x);
+  const [, word] = fcLook(x), head = FC_TXT(x.label) ? `${word} ${FC_TXT(x.label)}` : word, o = I.outs(x.id);
+  if (x.type === 'flow.Decision') return `${head}, ${o.length ? 'exits ' + o.map(e => `${FC_TXT(e.label) ? FC_TXT(e.label) + ' ' : ''}to ${fcCalled(I.N.get(e.to))}`).join(', ') : 'no exits'}`;
+  if (x.type === 'flow.Terminator') return `${head}, ${I.starts.includes(x.id) ? 'a start' : I.ends.includes(x.id) ? 'an end' : 'flows in and out'}`;
+  return head;
+}
+function fcLineName(I, e) {
+  const t = FC_TXT(e.label), ends = `from ${fcCalled(I.N.get(e.from))} to ${fcCalled(I.N.get(e.to))}`;
+  return e.type === 'uml.CommentLink' ? `Comment link ${ends}` : `Flow ${ends}${t ? ': ' + t : ''}`;
+}
+
+/* ---- the legend: each line kind and each symbol the view draws (1.9's legendItem form) ---- */
+const fcKey = (svg, 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" fill="none">${svg}</g></svg><b>${esc(name)}</b><span>${esc(says)}</span></span>`;
+const FC_KEYS = [
+  ['flow.Flow', '<path d="M2 8H18"/><path d="M17 4L26 8L17 12Z" fill="var(--um-muted)"/>', 'Flow', 'the next step'],
+  ['uml.CommentLink', '<path d="M2 8H26" stroke-dasharray="3 2"/>', 'Comment link', 'what a comment is about'],
+  ['flow.Terminator', '<rect x="3" y="3" width="22" height="10" rx="5"/>', 'Terminator', 'a start or an end'],
+  ['flow.Process', '<rect x="3" y="3" width="22" height="10"/>', 'Process', 'a step'],
+  ['flow.Decision', '<path d="M14 2L24 8L14 14L4 8Z"/>', 'Decision', 'a question, an exit per answer'],
+  ['flow.InputOutput', '<path d="M7 3H25L21 13H3Z"/>', 'Input/output', 'data read or written'],
+  ['flow.PredefinedProcess', '<rect x="3" y="3" width="22" height="10"/><path d="M6 3V13M22 3V13"/>', 'Predefined process', 'steps written out elsewhere'],
+  ['flow.Document', '<path d="M3 3H25V11C19 7 9 16 3 11Z"/>', 'Document', 'a document made or read'],
+  ['flow.Database', '<path d="M6 4V12A8 2 0 0 0 22 12V4"/><ellipse cx="14" cy="4" rx="8" ry="2"/>', 'Database', 'stored data'],
+  ['flow.ManualInput', '<path d="M3 7L25 3V13H3Z"/>', 'Manual input', 'data keyed in by hand'],
+  ['flow.Delay', '<path d="M4 3H18A5 5 0 0 1 18 13H4Z"/>', 'Delay', 'a wait'],
+  ['flow.Connector', '<circle cx="14" cy="8" r="5"/>', 'Connector', 'flows joined, or carried on elsewhere'],
+  ['uml.Comment', '<path d="M4 3H20L24 7V13H4Z"/>', 'Comment', 'a note on the chart'],
+];
+
+/* ---- the view laid out: { model, view, pos, memo } ---- */
+function fcGeo({ model, view, pos, memo }) {
+  const I = fcIndex(model, view), down = view.direction == null || view.direction === 'down', at = id => (FC_OBJ(pos) && Array.isArray(pos[id]) ? pos[id] : [0, 0]);
+  const nodes = I.ids.map(id => { const x = I.N.get(id), [shape] = fcLook(x), d = { id, label: fcName(x), type: x.type, kind: 'file', shape, aria: fcNodeName(I, x), col: at(id)[0], row: at(id)[1] };
+    return { ...d, ...SHAPE[shape].size(d) }; });
+  const edges = I.lines.map(e => { const note = e.type === 'uml.CommentLink', label = note ? '' : FC_TXT(e.label);
+    return { id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, ...(label ? { label, cut: 280 } : {}), end: note ? { from: 'none', to: 'none', dashed: true } : { from: 'none', to: 'arrow' },
+      aria: fcLineName(I, e), ...(FC_OBJ(e.style) || typeof e.style === 'string' ? { style: e.style } : {}) }; });
+  const g = layoutTyped({ nodes, edges, direction: down ? 'down' : 'right', gap: 48, rgap: 56, labelGaps: true, repair: false, reroute: false }, memo);
+  const types = new Set([...I.lines.map(e => e.type), ...I.ids.map(id => I.N.get(id).type)]);
+  // a new object: what layoutTyped returned is never edited (stage 4 §2.4). The slots: one per node, so L and the palette hear the selection
+  return { ...g, order: [...I.walk, ...I.lines.map(e => e.id)], slots: g.nodes.map(n => ({ after: n.id, x: n.x + n.w / 2, y: n.y + n.h / 2 })),
+    legend: FC_KEYS.filter(([t]) => types.has(t)).map(([, svg, name, says]) => fcKey(svg, name, says)) };
+}
+
+/* ---- validators (§7.2). Each problem: { level, rule, path, message, ids } ---- */
+const FC_RULES = {
+  'flow-ends': 'a flow joins two flowchart nodes',
+  'start-end': 'a view has exactly one start (a terminator with no flow in) and at least one end (a terminator with no flow out)',
+  'terminator-flows': 'a start has one flow out; an end has none out',
+  'decision-exits': 'a decision has two or more flows out, each labelled, no two with one label',
+  reachable: 'every node is reached from a start',
+};
+function fcProblems(model, view) {
+  const I = fcIndex(model, view), out = [], q = id => { const x = I.N.get(id); return x && FC_TXT(x.label) ? `${id} ("${FC_TXT(x.label)}")` : id; };
+  const say = (rule, path, ids, msg, level = 'warning') => out.push({ level, rule, path, ids, message: `${rule}: ${msg}` });
+  const shown = new Set(I.ids), mine = id => I.N.has(id) && FC_NODES.includes(I.N.get(id).type), list = es => es.map(e => e.id).join(', ');
+  I.E.forEach((e, id) => { if (e.type !== 'flow.Flow' || !(shown.has(e.from) || shown.has(e.to))) return;
+    [e.from, e.to].forEach(end => { if (I.N.has(end) && !mine(end)) say('flow-ends', I.path.get(id), [id, end], `flow ${id} ends on ${q(end)}, a ${String(I.N.get(end).type).split('.').pop()}: a flow joins two flowchart nodes`, 'error'); }); });
+  if (!view) return out;
+  const vp = `views[${FC_ARR(model.views).indexOf(view)}]`;
+  if (I.starts.length !== 1) say('start-end', vp, [view.id, ...I.starts], `view ${view.id} has ${fcPlural(I.starts.length, 'start')}${I.starts.length ? ` (${I.starts.map(q).join(', ')})` : ''}; it wants one`);
+  if (!I.ends.length) say('start-end', vp, [view.id], `view ${view.id} has no end: no terminator without a flow out`);
+  I.ids.forEach(id => { const x = I.N.get(id), i = I.ins(id), o = I.outs(id), p = I.path.get(id);
+    if (x.type === 'flow.Terminator' && !i.length && o.length !== 1) say('terminator-flows', p, [id, ...o.map(e => e.id)], `the start ${q(id)} has ${o.length ? `${o.length} flows out (${list(o)})` : 'no flow out'}; it wants one`);
+    if (x.type === 'flow.Terminator' && i.length && o.length) say('terminator-flows', p, [id, ...o.map(e => e.id)], `the end ${q(id)} has flows out (${list(o)}); a terminator with flows in is an end`);
+    if (x.type === 'flow.Decision') { const bare = o.filter(e => !FC_TXT(e.label)), by = new Map(); o.forEach(e => { const k = FC_TXT(e.label).toLowerCase(); if (k) by.set(k, [...(by.get(k) || []), e]); }); // as connect reads them
+      const twice = [...by.values()].filter(es => es.length > 1).flat();
+      if (o.length < 2) say('decision-exits', p, [id, ...o.map(e => e.id)], `${q(id)} has ${fcPlural(o.length, 'exit')}; a decision wants two or more`);
+      if (bare.length) say('decision-exits', p, [id, ...bare.map(e => e.id)], `${fcPlural(bare.length, 'exit')} of ${q(id)} ${bare.length === 1 ? 'has' : 'have'} no label (${list(bare)})`);
+      if (twice.length) say('decision-exits', p, [id, ...twice.map(e => e.id)], `exits of ${q(id)} share a label (${list(twice)})`); }
+    if (I.starts.length && mine(id) && !I.reached.has(id)) say('reachable', p, [id], `${q(id)} is reached from no start`); });
+  return out;
+}
+
+/* ---- describe(): the view in sentences: each node in reading order (from the start, along its flows), then each line ---- */
+function fcDescribe(model, viewId) {
+  const v = FC_ARR(model && model.views).find(x => FC_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const I = fcIndex(model, v);
+  return [`${v.title || v.id}: a flowchart of ${fcPlural(I.ids.length, 'node')} and ${fcPlural(I.flows.length, 'flow')}.`,
+    ...I.walk.map(id => fcNodeName(I, I.N.get(id)) + '.'), ...I.lines.map(e => fcLineName(I, e) + '.')].join('\n');
+}
+
+/* ---- editing: each hook returns commands, null to leave the gesture to the default, or { error } for the hint line ---- */
+const fcId = (model, base) => { const used = new Set(); JSON.stringify(model, (k, v) => { if (k === 'id' && typeof v === 'string') used.add(v); return v; });
+  let k = 1; while (used.has(base + k)) k++; return base + k; }; // as the canvas names a line: 'flow1'
+// connect: a flow joins two flowchart nodes (refused otherwise); a decision's second exit is labelled to answer its first,
+// yes then no, and an unlabelled first exit becomes yes
+function fcConnect(model, view, from, to, at, line) {
+  if (!FC_OBJ(view) || !FC_OBJ(line) || line.type !== 'flow.Flow') return null;
+  const I = fcIndex(model, null), bad = [from, to].find(id => !I.N.has(id) || !FC_NODES.includes(I.N.get(id).type));
+  if (bad != null) return { error: `flow-ends: a flow joins two flowchart nodes, and ${fcCalled(I.N.get(bad))} is not one` };
+  const o = [...I.E.values()].filter(e => e.type === 'flow.Flow' && e.from === from);
+  if (I.N.get(from).type !== 'flow.Decision' || o.length !== 1) return null;
+  const was = FC_TXT(o[0].label).toLowerCase(), label = was === 'yes' || !was ? 'no' : was === 'no' ? 'yes' : null;
+  if (!label) return null;
+  return [...(was ? [] : [{ op: 'set', id: o[0].id, path: 'label', value: 'yes' }]), { op: 'add', element: { id: fcId(model, 'flow'), type: 'flow.Flow', from, to, label }, view: view.id }];
+}
+// moveTo: a line dragged (or Alt + arrows on it) is refused, said on the hint line: a flow follows its ends. A view with no direction is laid out down, which the canvas's drop reads as laid out right (render.js hintAt reads
+// a view that says down): the pin is read here with the axes turned, as hintAt reads one. Anything else: null, the default
+function fcMoveTo(model, view, id, at) {
+  if (FC_ARR(model && model.edges).some(e => FC_OBJ(e) && e.id === id)) return { error: 'A flow follows its nodes: move a node instead' };
+  if (!FC_OBJ(view) || view.direction != null || !FC_OBJ(at) || !Array.isArray(at.pt) || !FC_OBJ(at.geo)) return null;
+  const ns = FC_ARR(at.geo.nodes).filter(m => FC_OBJ(m) && Number.isFinite(m.col) && Number.isFinite(m.row) && !m.aside), n = ns.find(m => m.id === id);
+  if (!n) return null;
+  const [y, x] = at.pt, X = m => m.y + m.h / 2, Y = m => m.x, cols = [...new Set(ns.map(m => m.col))].sort((a, b) => a - b);
+  const mid = c => { const k = ns.filter(m => m.col === c); return k.reduce((s, m) => s + X(m), 0) / k.length; };
+  const first = cols[0], last = cols.at(-1), step = cols.length > 1 ? (mid(last) - mid(first)) / (last - first) : 260;
+  let col = first, best = Infinity; cols.forEach(c => { const d = Math.abs(mid(c) - x); if (d < best) { best = d; col = c; } });
+  if (x > mid(last) + step / 2) col = last + Math.round((x - mid(last)) / step); else if (x < mid(first) - step / 2) col = Math.max(0, first - Math.round((mid(first) - x) / step));
+  const a = ns[0], b = ns.find(m => m.row !== a.row), pitch = b ? (Y(b) - Y(a)) / (b.row - a.row) : 108, row = Math.max(0, Math.round((y - (Y(a) - a.row * pitch) - 32) / pitch));
+  return col === n.col && row === n.row ? [] : [{ op: 'set', view: view.id, path: ['layout', id], value: [col, row] }];
+}
+
+/* ---- the type ---- */
+const FC_TYPE = registerDiagramType('flowchart', {
+  title: 'flowchart',
+  elements: [...FC_NODES, 'uml.Comment'].map(type => ({ type, label: FC_LOOK[type][1] })),
+  lines: [{ type: 'flow.Flow', label: 'Flow' }, { type: 'uml.CommentLink', label: 'Comment link' }],
+  layout: fcGeo,
+  validate: fcProblems,
+  rules: FC_RULES,
+  describe: fcDescribe,
+  // F2 on a node or a flow sets its label: the default
+  edits: { connect: fcConnect, moveTo: fcMoveTo },
+  // the PDF's tables: a node's symbol; a line's text, which flags a decision's exit with no label (milestone 2 §9)
+  word: (model, id) => { const x = FC_ARR(model && model.nodes).find(n => FC_OBJ(n) && n.id === id); return x && Object.hasOwn(FC_LOOK, x.type) ? FC_LOOK[x.type][1] : null; },
+  text: (model, view, id) => { const by = x => FC_ARR(x).find(y => FC_OBJ(y) && y.id === id), e = by(model && model.edges), d = e && e.type === 'flow.Flow' && FC_ARR(model.nodes).find(n => FC_OBJ(n) && n.id === e.from);
+    return e && !FC_TXT(e.label) && d && d.type === 'flow.Decision' ? `an exit of ${fcCalled(d)} with no label` : null; },
+});
+/* ---------- the data flow diagram, dfd (work package M2.4, notes/milestone-2.md §4.3, §6.1, §6.4, §7.3) ----------
+   Processes, data stores and external entities, joined by data flows; comments. Two skins on one geometry (§4.3): each
+   node is sized for the larger of its Yourdon and its Gane and Sarson look, and its shape's name carries the skin
+   (dfd-process-yourdon), so a change of view.notation repaints and lays nothing out (`shape` is no geometry, `notation`
+   no view geometry). Numbers are stored (props.number) and checked under their parent process's; a process that opens a
+   level (opensView, a dfd view whose parent is the view the process is on) balances against it (§6.4). D on a selected
+   process that opens no view makes its level, balanced from the start (§6.1). Laid out by layoutTyped from the host's
+   ranking, repair and reroute off (S19). Ships in lib/umlimator-all.js only. */
+
+const DFD_OBJ = x => x !== null && typeof x === 'object' && !Array.isArray(x), DFD_ARR = x => (Array.isArray(x) ? x : []);
+const DFD_HAS = x => x != null && String(x).trim() !== '';
+const dfdNum = x => (DFD_OBJ(x && x.props) && DFD_HAS(x.props.number) ? String(x.props.number).trim() : '');
+const dfdPlural = (k, w) => `${k} ${k === 1 ? w : w + 's'}`;
+const DFD_LINES = ['dfd.DataFlow', 'uml.CommentLink'];
+const DFD_KIND = { 'dfd.Process': 'process', 'dfd.DataStore': 'store', 'dfd.ExternalEntity': 'entity' };
+const DFD_WORD = { 'dfd.Process': 'Process', 'dfd.DataStore': 'Data store', 'dfd.ExternalEntity': 'External entity', 'uml.Comment': 'Comment' };
+const dfdSkin = view => (view && view.notation === 'gane-sarson' ? 'gane-sarson' : 'yourdon');
+
+/* ---- the shapes (§4.3): one size for both skins; each draws its number and name inside its box ---- */
+const DF = { px: 12, lh: 16, nmax: 160, num: 11, numh: 14, pad: 10, k: 1.42, band: 22, shadow: 4, minW: 96 };
+const dfdName = (t, k) => flowWrap(t, DF.px, DF.nmax, k);
+const dfdTextW = ls => Math.max(0, ...ls.map(l => textW(l, DF.px)));
+const dfdText = (x, y, t, px, wt, fill, max, cls, anchor = 'middle', more = '') => `<text x="${r2(x)}" y="${r2(y)}" text-anchor="${anchor}" class="${cls}" fill="${fill}"${more} style="font:${wt} ${px}px var(--um-sans)">${esc(fit(t, px, max))}</text>`;
+const dfdNode = (n, kind, inner) => `<g class="node dfd-${kind}" data-id="${esc(n.id)}" data-shape="${n.shape}" tabindex="-1" role="img" aria-label="${esc(n.aria || n.label || '')}">${inner}</g>`;
+const dfdBody = (d, c, f) => `<path d="${d}" class="n-mask"/><path d="${d}" class="n-body" fill="${f}" stroke="${c}"/>`;
+const dfdRect = (x, y, w, h) => `M${r2(x)} ${r2(y)}H${r2(x + w)}V${r2(y + h)}H${r2(x)}Z`;
+const dfdSquare = { out: (n, d = 0) => dfdRect(n.x - d, n.y - d, n.w + 2 * d, n.h + 2 * d), inset: () => 0 };
+// name lines centred in the band [y0, y1] of the box, the first with data-o (F2's field goes over it)
+const dfdNameSvg = (n, ls, cx, y0, y1, max) => { const y = (y0 + y1) / 2 - ls.length * DF.lh / 2;
+  return ls.map((l, i) => dfdText(cx, y + i * DF.lh + 12, l, DF.px, 600, 'var(--um-text)', max, 'c-name', 'middle', i ? '' : ` data-o="${esc(n.id)}"`)).join(''); };
+
+// a process: Yourdon's ellipse round its number over its name (the text block 1.42 times, so its corners fit inside it), or
+// Gane and Sarson's rounded rectangle with the number in a band across its top
+const dfdProcParts = n => { const num = String(n.number ?? ''), ls = dfdName(n.label, 3), tw = Math.max(dfdTextW(ls), num ? Math.min(DF.nmax, textW(num, DF.num)) : 0), th = (num ? DF.numh : 0) + ls.length * DF.lh;
+  return { num, ls, w: Math.ceil(Math.max(DF.minW, tw * DF.k + 16, tw + 2 * DF.pad)), h: Math.ceil(Math.max(56, th * DF.k + 12, DF.band + ls.length * DF.lh + 2 * DF.pad)) }; };
+const dfdProcess = skin => ({
+  size: n => { const p = dfdProcParts(n); return { w: p.w, h: p.h }; },
+  ...(skin === 'yourdon' ? { out: SHAPE.ellipse.out, inset: SHAPE.ellipse.inset } : { out: SHAPE.box.out, inset: SHAPE.box.inset }),
+  draw(n, c, f) {
+    const { num, ls } = dfdProcParts(n), cx = n.x + n.w / 2;
+    if (skin === 'yourdon') { const max = (n.w - 16) / DF.k, y0 = n.y + n.h / 2 - ((num ? DF.numh : 0) + ls.length * DF.lh) / 2;
+      return dfdNode(n, 'process', dfdBody(SHAPE.ellipse.out(n), c, f) + (num ? dfdText(cx, y0 + 10.5, num, DF.num, 500, 'var(--um-muted)', max, 'c-st') : '')
+        + dfdNameSvg(n, ls, cx, y0 + (num ? DF.numh : 0), n.y + n.h / 2 + ((num ? DF.numh : 0) + ls.length * DF.lh) / 2, max)); }
+    const max = n.w - 2 * DF.pad;
+    return dfdNode(n, 'process', dfdBody(SHAPE.box.out(n), c, f) + `<path d="M${r2(n.x)} ${r2(n.y + DF.band)}H${r2(n.x + n.w)}" class="n-det" stroke="${c}"/>`
+      + (num ? dfdText(cx, n.y + 15, num, DF.num, 500, 'var(--um-muted)', max, 'c-st') : '') + dfdNameSvg(n, ls, cx, n.y + DF.band, n.y + n.h, max));
+  },
+});
+// a data store: Yourdon's two lines with the number before the name, or Gane and Sarson's rectangle open on the right,
+// its number in an id box on the left
+const dfdStoreParts = n => { const num = String(n.number ?? ''), ls = dfdName(n.label, 2), nw = num ? Math.min(DF.nmax, textW(num, DF.num)) : 0, ib = Math.max(28, Math.ceil(nw) + 12), tw = dfdTextW(ls);
+  return { num, ls, nw, ib, w: Math.ceil(Math.max(DF.minW, ib + tw + 2 * DF.pad, nw + 8 + tw + 2 * DF.pad)), h: Math.max(36, ls.length * DF.lh + 16) }; };
+const dfdStore = skin => ({
+  size: n => { const p = dfdStoreParts(n); return { w: p.w, h: p.h }; },
+  ...dfdSquare,
+  draw(n, c, f) {
+    const { num, ls, nw, ib } = dfdStoreParts(n), { x, y, w, h } = n, mask = `<path d="${dfdRect(x, y, w, h)}" class="n-mask"/>`;
+    if (skin === 'yourdon') { const tx = x + DF.pad + (num ? nw + 8 : 0), max = x + w - DF.pad - tx;
+      return dfdNode(n, 'store', mask + `<path d="${dfdRect(x, y, w, h)}" fill="${f}" stroke="none"/><path d="M${r2(x)} ${r2(y)}H${r2(x + w)}M${r2(x)} ${r2(y + h)}H${r2(x + w)}" class="n-body" fill="none" stroke="${c}"/>`
+        + (num ? dfdText(x + DF.pad, y + h / 2 + 4, num, DF.num, 500, 'var(--um-muted)', nw + 1, 'c-st', 'start') : '') + dfdNameSvg(n, ls, tx + max / 2, y, y + h, max)); }
+    const max = w - ib - 2 * DF.pad;
+    return dfdNode(n, 'store', mask + `<path d="${dfdRect(x, y, w, h)}" fill="${f}" stroke="none"/><path d="M${r2(x + w)} ${r2(y)}H${r2(x)}V${r2(y + h)}H${r2(x + w)}M${r2(x + ib)} ${r2(y)}V${r2(y + h)}" class="n-body" fill="none" stroke="${c}"/>`
+      + (num ? dfdText(x + ib / 2, y + h / 2 + 4, num, DF.num, 500, 'var(--um-muted)', ib - 6, 'c-st') : '') + dfdNameSvg(n, ls, x + ib + DF.pad + max / 2, y, y + h, max));
+  },
+});
+// an external entity: a rectangle; in Gane and Sarson a 4 px shadow inside the box, at its right and bottom
+const dfdEntityParts = n => { const ls = dfdName(n.label, 3); return { ls, w: Math.ceil(Math.max(DF.minW, dfdTextW(ls) + 2 * DF.pad + DF.shadow)), h: ls.length * DF.lh + 16 + DF.shadow }; };
+const dfdEntity = skin => ({
+  size: n => { const p = dfdEntityParts(n); return { w: p.w, h: p.h }; },
+  ...dfdSquare,
+  draw(n, c, f) {
+    const { ls } = dfdEntityParts(n), { x, y, w, h } = n, s = skin === 'yourdon' ? 0 : DF.shadow;
+    const body = s ? `<path d="${dfdRect(x, y, w, h)}" class="n-mask"/><path d="${dfdRect(x + s, y + s, w - s, h - s)}" class="n-det" fill="${c}" stroke="${c}"/><path d="${dfdRect(x, y, w - s, h - s)}" class="n-body" fill="${f}" stroke="${c}"/>` : dfdBody(dfdRect(x, y, w, h), c, f);
+    return dfdNode(n, 'entity', body + dfdNameSvg(n, ls, x + (w - s) / 2, y, y + h - s, w - s - 2 * DF.pad));
+  },
+});
+for (const skin of ['yourdon', 'gane-sarson']) for (const [kind, make] of [['process', dfdProcess], ['store', dfdStore], ['entity', dfdEntity]]) {
+  const S = SHAPE[`dfd-${kind}-${skin}`] = make(skin); S.face = n => [n.y, n.y + n.h]; S.ports = (n, side, k = 1) => portsOn(S, n, side, k); }
+
+/* ---- the model read: its elements, the lines a view draws, its levels ---- */
+function dfdIndex(model) {
+  const at = new Map(), path = new Map(), views = new Map();
+  DFD_ARR(model && model.nodes).forEach((x, i) => { if (DFD_OBJ(x) && typeof x.id === 'string' && !at.has(x.id)) { at.set(x.id, x); path.set(x.id, `nodes[${i}]`); } });
+  DFD_ARR(model && model.views).forEach(v => { if (DFD_OBJ(v) && typeof v.id === 'string' && !views.has(v.id)) views.set(v.id, v); });
+  const flows = DFD_ARR(model && model.edges).map((e, i) => [e, `edges[${i}]`]).filter(([e]) => DFD_OBJ(e) && e.type === 'dfd.DataFlow');
+  const ty = id => (at.get(id) || {}).type, proc = id => ty(id) === 'dfd.Process';
+  const name = id => { const x = at.get(id); if (!x) return String(id); const k = dfdNum(x); return (k ? k + ' ' : '') + String(x.label ?? x.id); };
+  const q = id => `${(DFD_WORD[ty(id)] || 'element').toLowerCase()} "${name(id)}"`;
+  // a level: the view a process opens, its parent view, and its own processes, those it shows and its parent view does not
+  const level = p => { const v = views.get((at.get(p) || {}).opensView), pv = v && views.get(v.parent), up = new Set(DFD_ARR(pv && pv.nodeIds));
+    return v ? { v, pv, up, kids: DFD_ARR(v.nodeIds).filter(id => proc(id) && id !== p && !up.has(id)) } : null; };
+  const parentOf = vid => [...at.values()].find(x => x.type === 'dfd.Process' && x.opensView === vid) || null; // the process a view is the level of
+  return { at, path, views, flows, ty, proc, name, q, level, parentOf };
+}
+// the lines drawn: those the view lists, or with no list the model's of this type's kinds, between two nodes it shows; on a
+// level (a view a process opens) with no list, not those with both ends on its parent view: they are the parent level's,
+// and reach the level only through its own processes (Yourdon and DeMarco's levelling)
+function dfdLines(model, view) {
+  const E = new Map(); DFD_ARR(model.edges).forEach(e => { if (DFD_OBJ(e) && typeof e.id === 'string' && !E.has(e.id)) E.set(e.id, e); });
+  const shown = new Set(DFD_ARR(view.nodeIds)), listed = Array.isArray(view.edges), list = listed ? view.edges.map(x => (typeof x === 'string' ? E.get(x) : x)) : [...E.values()].filter(e => DFD_LINES.includes(e.type));
+  const lv = !listed && view.parent !== view.id && DFD_ARR(model.nodes).some(x => DFD_OBJ(x) && x.type === 'dfd.Process' && x.opensView === view.id);
+  const up = new Set(lv ? DFD_ARR((DFD_ARR(model.views).find(v => DFD_OBJ(v) && v.id === view.parent) || {}).nodeIds) : []);
+  return list.filter(e => DFD_OBJ(e) && typeof e.id === 'string' && shown.has(e.from) && shown.has(e.to) && !(up.has(e.from) && up.has(e.to)));
+}
+// accessible names (A1): "Process 1 Take order, opens level 1 Take order, 2 flows in, 2 out"; a flow: "Data flow basket from Customer to 1 Take order"
+function dfdNodeName(I, id, lines) {
+  const x = I.at.get(id); if (x.type === 'uml.Comment') return 'Comment: ' + String(x.label ?? '');
+  const ins = lines.filter(e => e.type === 'dfd.DataFlow' && e.to === id && e.from !== id).length, outs = lines.filter(e => e.type === 'dfd.DataFlow' && e.from === id && e.to !== id).length;
+  const v = x.type === 'dfd.Process' && I.views.get(x.opensView);
+  return `${DFD_WORD[x.type] || String(x.type).split('.').pop()} ${I.name(id)}${v ? `, opens level ${v.title || v.id}` : ''}, ${dfdPlural(ins, 'flow')} in, ${outs} out`;
+}
+const dfdLineName = (I, e) => `${e.type === 'dfd.DataFlow' ? 'Data flow' : 'Comment link'}${DFD_HAS(e.label) ? ' ' + e.label : ''} from ${I.name(e.from)} to ${I.name(e.to)}`;
+// reading order: the processes by number, then the stores, the entities and the rest as the view lists them, then the lines
+function dfdOrder(I, ids, lines) {
+  const rank = id => ['dfd.Process', 'dfd.DataStore', 'dfd.ExternalEntity'].indexOf(I.ty(id)) + 1 || 4, byNum = (a, b) => dfdNum(I.at.get(a)).localeCompare(dfdNum(I.at.get(b)), undefined, { numeric: true });
+  return [...[...ids].sort((a, b) => rank(a) - rank(b) || (rank(a) === 1 ? byNum(a, b) : 0)), ...lines.map(e => e.id)];
+}
+
+/* ---- the legend: each symbol drawn, in the view's skin, and the line kinds ---- */
+const DFD_GLYPH = {
+  'process-yourdon': '<ellipse cx="14" cy="8" rx="12" ry="6.5" fill="var(--um-panel)"/>', 'process-gane-sarson': '<rect x="3" y="1.5" width="22" height="13" rx="3" fill="var(--um-panel)"/><path d="M3 5.5H25"/>',
+  'store-yourdon': '<path d="M2 3H26M2 13H26"/>', 'store-gane-sarson': '<path d="M26 3H2V13H26M8 3V13"/>',
+  'entity-yourdon': '<rect x="3" y="2" width="22" height="12" fill="var(--um-panel)"/>', 'entity-gane-sarson': '<rect x="5" y="4" width="21" height="11" fill="var(--um-muted)"/><rect x="3" y="2" width="21" height="11" fill="var(--um-panel)"/>',
+  'dfd.DataFlow': '<path d="M2 8H17"/><path d="M17 4L26 8L17 12Z" fill="var(--um-muted)"/>', 'uml.CommentLink': '<path d="M2 8H26" stroke-dasharray="3 2"/>',
+};
+const DFD_SAYS = { process: 'transforms the data flowing in into the data flowing out', store: 'holds data at rest', entity: 'outside the system: a source or a sink of data',
+  'dfd.DataFlow': 'data moving, named by what it carries', 'uml.CommentLink': 'what a comment is about' };
+const dfdLegendItem = (glyph, 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" fill="none">${glyph}</g></svg><b>${esc(name)}</b><span>${esc(says)}</span></span>`;
+const dfdLegend = (I, ids, lines, skin) => [
+  ...['process', 'store', 'entity'].filter(k => ids.some(id => DFD_KIND[I.ty(id)] === k)).map(k => dfdLegendItem(DFD_GLYPH[`${k}-${skin}`], DFD_WORD[Object.keys(DFD_KIND).find(t => DFD_KIND[t] === k)], DFD_SAYS[k])),
+  ...DFD_LINES.filter(t => lines.some(e => e.type === t)).map(t => dfdLegendItem(DFD_GLYPH[t], t === 'dfd.DataFlow' ? 'Data flow' : 'Comment link', DFD_SAYS[t]))];
+
+/* ---- the view laid out (§7): labels cut at 280 with room made for them (labelGaps); a gap of 64 px, as 48 laid a label of
+   22-data-flow.json on a line, down (the note's §7.3, amended) ---- */
+const DFD_END = { 'dfd.DataFlow': { from: 'none', to: 'arrow' }, 'uml.CommentLink': { from: 'none', to: 'none', dashed: true } };
+function dfdGeo({ model, view, pos, memo }) {
+  const I = dfdIndex(model), ids = DFD_ARR(view.nodeIds).filter((id, k, a) => I.at.has(id) && a.indexOf(id) === k), lines = dfdLines(model, view), skin = dfdSkin(view), P = id => (pos && Object.hasOwn(pos, id) ? pos[id] : [0, 0]);
+  const nodes = ids.map(id => { const x = I.at.get(id), k = DFD_KIND[x.type];
+    const d = { id, label: String(x.label ?? id), type: x.type || 'dfd.Process', kind: 'file', ...(k ? { shape: `dfd-${k}-${skin}`, number: dfdNum(x) } : x.type === 'uml.Comment' ? { shape: 'note' } : { shape: 'classifier', compartments: [] }),
+      aria: dfdNodeName(I, id, lines), col: P(id)[0], row: P(id)[1] };
+    return { ...d, ...SHAPE[d.shape].size(d) }; });
+  const edges = lines.map(e => ({ id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, ...(DFD_HAS(e.label) ? { label: String(e.label), cut: 280 } : {}),
+    end: DFD_END[e.type] || DFD_END['dfd.DataFlow'], aria: dfdLineName(I, e), ...(DFD_OBJ(e.style) || typeof e.style === 'string' ? { style: e.style } : {}) }));
+  const g = layoutTyped({ nodes, edges, direction: view.direction === 'down' ? 'down' : 'right', gap: 64, rgap: 56, labelGaps: true, repair: false, reroute: false }, memo);
+  return { ...g, legend: dfdLegend(I, ids, lines, skin), order: dfdOrder(I, ids, lines) }; // a new object: what layoutTyped returned is never edited (§2.6)
+}
+
+/* ---- validators (§6.4, §7.3). Each problem: { level, rule, path, message, ids }; on the whole model, once a type ---- */
+const DFD_RULES = {
+  'dfd-flow-process': 'a flow has a process at one end at least: no flow between two stores, two entities, or an entity and a store',
+  'dfd-process-io': 'a process has a flow in and a flow out',
+  'dfd-flow-label': 'a flow to or from a process has a label',
+  'dfd-numbers': 'a level\'s processes are numbered under their parent process\'s (1.1, 1.2 under 1); no number is used twice',
+  'dfd-balance': 'the flows between a process and the rest of its level match its level\'s flows across the level\'s edge, by label, far end and direction',
+  'dfd-level': 'a process opens a dfd view whose parent is a view showing the process; the level is that process\'s alone and does not show it',
+};
+function dfdProblems(model) {
+  const I = dfdIndex(model), out = [], say = (level, rule, path, ids, msg) => out.push({ level, rule, path, ids: ids.filter(x => x != null), message: `${rule}: ${msg}` });
+  const procs = [...I.at.values()].filter(x => x.type === 'dfd.Process');
+  I.flows.forEach(([e, path]) => { if (!I.at.has(e.from) || !I.at.has(e.to)) return;
+    if (!I.proc(e.from) && !I.proc(e.to)) say('warning', 'dfd-flow-process', path, [e.id, e.from, e.to], `${e.id} runs from ${I.q(e.from)} to ${I.q(e.to)}: a flow has a process at one end at least`);
+    else if (!DFD_HAS(e.label)) say('warning', 'dfd-flow-label', path, [e.id], `${e.id}, from ${I.q(e.from)} to ${I.q(e.to)}, has no label: a flow is named by the data it carries`); });
+  procs.forEach(p => { const has = w => I.flows.some(([e]) => e[w] === p.id && e[w === 'from' ? 'to' : 'from'] !== p.id), miss = ['in', 'out'].filter((k, i) => !has(i ? 'from' : 'to'));
+    if (miss.length) say('warning', 'dfd-process-io', I.path.get(p.id), [p.id], `${I.q(p.id)} has no flow ${miss.join(' and no flow ')}`); });
+  // numbers: none used twice among processes, nor among stores; a level's processes under their parent's
+  for (const t of ['dfd.Process', 'dfd.DataStore']) { const by = new Map(); [...I.at.values()].filter(x => x.type === t && dfdNum(x)).forEach(x => by.set(dfdNum(x), [...(by.get(dfdNum(x)) || []), x.id]));
+    by.forEach((list, k) => { if (list.length > 1) say('warning', 'dfd-numbers', I.path.get(list[1]), list, `${list.length} ${t === 'dfd.Process' ? 'processes' : 'stores'} are numbered ${k}: ${list.map(id => JSON.stringify(String(I.at.get(id).label ?? id))).join(', ')}`); }); }
+  procs.forEach(p => { const L = I.level(p.id), n = dfdNum(p); if (!L || L.v.diagram !== 'dfd' || !n || I.parentOf(L.v.id) !== p) return;
+    L.kids.filter(id => !new RegExp(`^${n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.\\d+$`).test(dfdNum(I.at.get(id)))).forEach(id =>
+      say('warning', 'dfd-numbers', I.path.get(id), [id, p.id], `${I.q(id)}, on the level of ${I.q(p.id)}, is numbered ${dfdNum(I.at.get(id)) || 'nothing'}: its number is ${n}.1, ${n}.2, …`)); });
+  // a level: a dfd view whose parent shows the process; then balanced (§6.4), each pair by label, far end and direction
+  procs.filter(p => p.opensView != null).forEach(p => { const L = I.level(p.id), path = I.path.get(p.id);
+    const first = L && I.parentOf(L.v.id), bad = !L ? `opens "${p.opensView}", which is no view` : L.v.diagram !== 'dfd' ? `opens "${L.v.id}", a ${L.v.diagram || 'map'} view, not a level`
+      : L.v === L.pv ? `opens "${L.v.id}", whose parent view is itself` : !L.up.has(p.id) ? `opens "${L.v.id}", whose parent view ${L.pv ? `"${L.pv.id}" does not show it` : `is ${L.v.parent == null ? 'not given' : `"${L.v.parent}", which is no view`}`}`
+        : first !== p ? `opens "${L.v.id}", which ${I.q(first.id)} opens already: a level is one process's` : DFD_ARR(L.v.nodeIds).includes(p.id) ? `opens "${L.v.id}", which shows the process itself: its level shows its parts` : '';
+    if (bad) return say('warning', 'dfd-level', path, [p.id, ...(first && first !== p ? [first.id] : [])], `${I.q(p.id)} ${bad}`);
+    // the flows each view draws: the process's on its parent view; on the level, those across the edge of its own processes,
+    // but to a store the parent view does not show (a local store)
+    const kids = new Set(L.kids), key = (e, mine) => { const o = e.from === mine ? e.to : e.from; return [e.from === mine ? 'out' : 'in', o, String(e.label ?? '').trim()]; };
+    const drawn = v => dfdLines(model, v).filter(e => e.type === 'dfd.DataFlow');
+    const outer = drawn(L.pv).filter(e => (e.from === p.id) !== (e.to === p.id)).map(e => [e, key(e, p.id)]);
+    const inner = drawn(L.v).filter(e => { const o = kids.has(e.from) ? e.to : e.from; return kids.has(e.from) !== kids.has(e.to) && o !== p.id && (L.up.has(o) || I.ty(o) !== 'dfd.DataStore'); }).map(e => [e, key(e, kids.has(e.from) ? e.from : e.to)]);
+    const left = [...inner], miss = outer.filter(([, k]) => { const i = left.findIndex(([, j]) => j.join('\u0001') === k.join('\u0001')); if (i < 0) return true; left.splice(i, 1); return false; });
+    if (!miss.length && !left.length) return;
+    const said = ([e, [dir, o, l]]) => `"${l}" ${dir === 'in' ? 'in from' : 'out to'} ${I.q(o)} (${e.id})`, lv = `level "${L.v.title || L.v.id}"`;
+    say('error', 'dfd-balance', path, [p.id, ...miss.map(([e]) => e.id), ...left.map(([e]) => e.id)], `${I.q(p.id)} does not balance with ${lv}: ${[
+      miss.length ? `its flow${miss.length > 1 ? 's' : ''} ${miss.map(said).join(', ')} ${miss.length > 1 ? 'have' : 'has'} none at the level` : '',
+      left.length ? `the level's flow${left.length > 1 ? 's' : ''} ${left.map(said).join(', ')} ${left.length > 1 ? 'are' : 'is'} not the process's` : ''].filter(Boolean).join('; ')}`); });
+  return out;
+}
+
+/* ---- describe(): the view in sentences, each element by its accessible name in reading order, then each line ---- */
+function dfdDescribe(model, viewId) {
+  const v = DFD_ARR(model && model.views).find(x => DFD_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const I = dfdIndex(model), ids = DFD_ARR(v.nodeIds).filter((id, k, a) => I.at.has(id) && a.indexOf(id) === k), lines = dfdLines(model, v), by = new Map(lines.map(e => [e.id, e])), up = I.parentOf(v.id);
+  return [`${v.title || v.id}: a data flow diagram${up ? `, the level of ${I.q(up.id)},` : ''} of ${dfdPlural(ids.length, 'element')} and ${dfdPlural(lines.length, 'line')}.`,
+    ...dfdOrder(I, ids, lines).map(id => (by.has(id) ? dfdLineName(I, by.get(id)) : dfdNodeName(I, id, lines)) + '.')].join('\n');
+}
+
+/* ---- editing (§6.1, §7.3) ---- */
+const dfdUsed = model => { const used = new Set(); JSON.stringify(model, (k, v) => { if (k === 'id' && typeof v === 'string') used.add(v); return v; }); return used; };
+// a free id: base, else base-2, base-3, …; numbered (the palette's): base1, base2, …. Taken once given
+const dfdFree = (used, base, numbered) => { let k = 1, id = numbered ? base + 1 : base; while (used.has(id)) id = base + (numbered ? '' : '-') + ++k; used.add(id); return id; };
+// the next free number of a type after pre: pre1, pre2, …
+const dfdFreeNum = (I, type, pre) => { const taken = new Set([...I.at.values()].filter(x => x.type === type).map(dfdNum)); let k = 1; while (taken.has(pre + k)) k++; return pre + k; };
+// the next free number: under the view's parent process (1.1, 1.2 under 1), else 1, 2, …; a store's D1, D2, …
+function dfdNextNumber(model, view, type) {
+  const I = dfdIndex(model), up = type === 'dfd.Process' && I.parentOf(view.id);
+  return dfdFreeNum(I, type, type === 'dfd.DataStore' ? 'D' : up && dfdNum(up) ? dfdNum(up) + '.' : '');
+}
+// the palette's add: a process or a store with the next free number
+function dfdAdd(model, view, entry, label) {
+  if (!['dfd.Process', 'dfd.DataStore'].includes(entry.type)) return null;
+  const id = dfdFree(dfdUsed(model), entry.type === 'dfd.Process' ? 'process' : 'store', true);
+  return [{ op: 'add', element: { id, type: entry.type, ...(label ? { label } : {}), props: { number: dfdNextNumber(model, view, entry.type) } }, view: view.id }];
+}
+/* D on a selected process that opens no view (§6.1): its level, in one transaction. The new view (<id>-level, the next
+   free) shows the far ends of the process's flows drawn on this view and one child process, numbered <n>.1 (the next
+   free under <n>) and named as its parent; each of those flows is copied with the process's end moved to the child, so the level balances from the start */
+function dfdKey(model, view, ids, key) {
+  if (key !== 'd' && key !== 'D') return null;
+  const I = dfdIndex(model), p = ids.length === 1 && I.proc(ids[0]) ? I.at.get(ids[0]) : null; if (!p) return null;
+  if (p.opensView != null) return { error: `${I.q(p.id)} opens "${p.opensView}" already: Enter opens it` };
+  const used = dfdUsed(model), n = dfdNum(p), kn = dfdFreeNum(I, 'dfd.Process', n ? n + '.' : '');
+  const flows = dfdLines(model, view).filter(e => e.type === 'dfd.DataFlow' && (e.from === p.id) !== (e.to === p.id));
+  const vid = dfdFree(new Set(DFD_ARR(model.views).filter(DFD_OBJ).map(v => v.id)), p.id + '-level'), kid = dfdFree(used, `${p.id}-${kn}`), title = `${n ? n + ' ' : ''}${p.label ?? p.id}`;
+  return { commands: [
+    { op: 'addView', view: { id: vid, diagram: 'dfd', title, parent: view.id, ...(view.notation != null ? { notation: view.notation } : {}), ...(view.direction != null ? { direction: view.direction } : {}),
+      nodeIds: [...new Set(flows.map(e => (e.from === p.id ? e.to : e.from)))] } },
+    { op: 'add', element: { id: kid, type: 'dfd.Process', ...(p.label != null ? { label: p.label } : {}), props: { number: kn } }, view: vid },
+    ...flows.map(e => ({ op: 'add', element: { id: dfdFree(used, `${e.id}-${kn}`), type: 'dfd.DataFlow', from: e.from === p.id ? kid : e.from, to: e.to === p.id ? kid : e.to, ...(e.label != null ? { label: e.label } : {}) } })),
+    { op: 'set', id: p.id, path: 'opensView', value: vid }],
+  say: `Made level ${title}, balanced with ${dfdPlural(flows.length, 'flow')}: Enter opens it` };
+}
+
+const DFD_NUMBER = { key: 'number', label: 'Number', kind: 'text' };
+const DFD_TYPE = registerDiagramType('dfd', {
+  title: 'data flow diagram',
+  elements: [['dfd.Process', 'Process', 'dfd'], ['dfd.DataStore', 'Data store'], ['dfd.ExternalEntity', 'External entity'], ['uml.Comment', 'Comment']].map(([type, label, opens]) => ({ type, label, ...(opens ? { opens } : {}) })),
+  lines: [{ type: 'dfd.DataFlow', label: 'Data flow' }, { type: 'uml.CommentLink', label: 'Comment link' }],
+  props: { 'dfd.Process': [DFD_NUMBER], 'dfd.DataStore': [DFD_NUMBER], 'dfd.ExternalEntity': [], 'dfd.DataFlow': [], 'uml.CommentLink': [] },
+  layout: dfdGeo,
+  validate: dfdProblems,
+  rules: DFD_RULES,
+  describe: dfdDescribe,
+  edits: { add: dfdAdd, key: dfdKey },
+  // the PDF's tables (§9): an element's kind; a process's number and the level it opens, a store's number
+  word: (model, id) => { const x = dfdIndex(model).at.get(id); return x && Object.hasOwn(DFD_WORD, x.type) ? DFD_WORD[x.type] : null; },
+  rows: (model, view, id) => { const I = dfdIndex(model), x = I.at.get(id); if (!x || !['dfd.Process', 'dfd.DataStore'].includes(x.type)) return null;
+    const v = x.type === 'dfd.Process' && I.views.get(x.opensView); return [...(dfdNum(x) ? [`number ${dfdNum(x)}`] : []), ...(v ? [`opens level ${v.title || v.id}`] : [])]; },
+});
+/* ---------- the information flow diagram, uml.information-flow (work package M2.5, notes/milestone-2.md §7.4) ----------
+   Classes and interfaces (the class type's classifier, name only), components (src/uml/structure.js's look) and actors (the
+   use case type's figure), each read only; information items, a classifier with a small filled triangle at its top right
+   (UML 2.5.1 §20.2.4); comments. Information flows: a dashed line with an open arrow, its label «flow» then what it conveys
+   by name (`Order, Card details`), after its own name when it has one (`place: Order`), cut at 280; comment links.
+   props.conveyed is a declared reference (refs: drop), so deleting an element drops it from every flow. Laid out by
+   layoutTyped from the host's ranking: gap 48 with gapAfter's widening, labelGaps, repair and reroute off (S19). Ships in
+   lib/umlimator-all.js only. */
+
+const IF_OBJ = x => x !== null && typeof x === 'object' && !Array.isArray(x), IF_ARR = x => (Array.isArray(x) ? x : []);
+const IF_HAS = x => x != null && x !== '';
+const ifName = x => String(x.label ?? x.id);
+const ifStereo = x => IF_ARR(IF_OBJ(x.props) ? x.props.stereotypes : null).filter(IF_HAS).map(String);
+const ifPlural = (k, w) => `${k} ${k === 1 ? w : w + 's'}`;
+const ifAnd = a => (a.length < 2 ? a.join('') : `${a.slice(0, -1).join(', ')} and ${a.at(-1)}`);
+const IF_ENDS = ['uml.Class', 'uml.Interface', 'uml.Component', 'uml.Actor']; // what a flow joins (§3, §13)
+// what a flow may convey: UML 2.5.1 §20.2.4's convey_classifiers, a class, an interface, an information item, a signal or a component
+const IF_CONVEY = ['uml.InformationItem', 'uml.Class', 'uml.Interface', 'uml.Component', 'uml.Signal'];
+const IF_LINES = ['uml.InformationFlow', 'uml.CommentLink'];
+const IF_WORD = { 'uml.Class': 'Class', 'uml.Interface': 'Interface', 'uml.Component': 'Component', 'uml.Actor': 'Actor', 'uml.InformationItem': 'Information item', 'uml.Comment': 'Comment',
+  'uml.Signal': 'Signal' };
+const ifWord = t => (Object.hasOwn(IF_WORD, t) ? IF_WORD[t] : String(t ?? 'untyped').split('.').pop());
+// the keyword over a classifier's name: an interface's, a signal's, and any other kind a view shows its own («useCase»), so none passes for a class
+const IF_KEY = { 'uml.Class': null, 'uml.InformationItem': null, 'uml.PrimitiveType': 'primitive' };
+const ifKey = t => (Object.hasOwn(IF_KEY, t) ? IF_KEY[t] : String(t ?? '').split('.').pop().replace(/^./, c => c.toLowerCase()) || null);
+
+/* ---- the information item: the classifier, 32 px wider, its centred name kept 8 px clear of the triangle at its top right ---- */
+const IF_IT = { pad: 8, name: 13, more: 32 };
+// the classifier's own markup, named by n.aria (A1) and by its shape
+const ifClassifier = (n, c, f, shape = 'classifier') => SHAPE.classifier.draw(n, c, f).replace(/data-shape="classifier" tabindex="-1" role="img" aria-label="[^"]*"/,
+  `data-shape="${shape}" tabindex="-1" role="img" aria-label="${esc(n.aria || n.label || '')}"`);
+// a class or an interface: the classifier, named by its accessible name rather than the classifier's own («interface» twice)
+SHAPE['if-classifier'] = { ...SHAPE.classifier, draw: (n, c, f) => ifClassifier(n, c, f) };
+SHAPE['information-item'] = { ...SHAPE.classifier,
+  size: n => { const s = SHAPE.classifier.size(n); return { w: s.w + IF_IT.more, h: s.h }; },
+  draw(n, c, f) { const x = n.x + n.w - 16, y = n.y + 6, tri = `<path d="M${r2(x)} ${r2(y)}L${r2(x + 10)} ${r2(y + 5)}L${r2(x)} ${r2(y + 10)}Z" class="if-icon" fill="${c}" stroke="${c}" stroke-linejoin="round"/>`;
+    return ifClassifier({ ...n, label: fit(String(n.label ?? ''), IF_IT.name, n.w - 2 * IF_IT.pad - IF_IT.more / 2 - 16) }, c, f, 'information-item').replace(/<\/g>$/, tri + '</g>'); },
+};
+
+/* ---- the model read ---- */
+function ifIndex(model) {
+  const at = new Map(); IF_ARR(model && model.nodes).forEach(n => { if (IF_OBJ(n) && typeof n.id === 'string' && !at.has(n.id)) at.set(n.id, n); });
+  const E = IF_ARR(model && model.edges).filter(e => IF_OBJ(e) && typeof e.id === 'string');
+  const conveyed = e => IF_ARR(IF_OBJ(e.props) ? e.props.conveyed : null);
+  const nm = id => (at.has(id) ? ifName(at.get(id)) : String(id)); // a conveyed id that is gone: said as itself (conveyed-kind)
+  return { at, E, conveyed, nm, flowsOf: id => E.filter(e => e.type === 'uml.InformationFlow' && conveyed(e).includes(id)) };
+}
+// what a flow says: its name, then what it conveys by name ("place: Order, Card details"); the PDF's line text (S17)
+const ifSays = (I, e) => `${IF_HAS(e.label) ? e.label + ': ' : ''}${I.conveyed(e).map(I.nm).join(', ')}`;
+// the lines drawn: those the view lists, or with no list the model's of this type's kinds, between two elements it shows
+function ifLines(I, view, shown) {
+  const by = new Map(I.E.map(e => [e.id, e])), list = Array.isArray(view.edges) ? view.edges.map(x => (typeof x === 'string' ? by.get(x) : x)) : I.E.filter(e => IF_LINES.includes(e.type));
+  return list.filter(e => IF_OBJ(e) && typeof e.id === 'string' && shown.has(e.from) && shown.has(e.to));
+}
+const ifShown = (I, view) => [...new Set(IF_ARR(view && view.nodeIds))].filter(id => I.at.has(id));
+
+/* ---- accessible names (§7.4): "Information item Order, conveyed by 4 flows"; "Information flow from Shopper to Storefront,
+   conveys Order and Card details" ---- */
+function ifNodeName(I, n) {
+  if (n.type === 'uml.Comment') return 'Comment: ' + ifName(n);
+  const st = ifStereo(n), w = ifWord(n.type), k = I.flowsOf(n.id).length;
+  return `${w} ${ifName(n)}${st.length ? ` (${st.join(', ')})` : ''}${k ? `, conveyed by ${ifPlural(k, 'flow')}` : ''}`;
+}
+function ifLineName(I, e) {
+  const ends = `from ${I.nm(e.from)} to ${I.nm(e.to)}`;
+  if (e.type === 'uml.CommentLink') return `Comment link ${ends}`;
+  if (e.type !== 'uml.InformationFlow') return `Line ${ends}`;
+  const c = I.conveyed(e).map(I.nm);
+  return `Information flow${IF_HAS(e.label) ? ' ' + e.label : ''} ${ends}${c.length ? ', conveys ' + ifAnd(c) : ''}`;
+}
+
+/* ---- the legend. ponytail: copies class.js's legendItem, which it does not export ---- */
+const IF_SAYS = { 'uml.InformationFlow': ['Information flow', '«flow»: what travels from one end to the other'], 'uml.CommentLink': ['Comment link', 'what a comment is about'] };
+const ifLegend = edges => IF_LINES.filter(t => edges.some(e => e.type === t)).map(t => { const [name, says] = IF_SAYS[t], flow = t === 'uml.InformationFlow';
+  return `<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${flow ? 17 : 26}" stroke-dasharray="3 2"/>${flow ? '<path d="M17 4L26 8L17 12" fill="none"/>' : ''}</g></svg><b>${esc(name)}</b><span>${esc(says)}</span></span>`; });
+
+/* ---- the view laid out ----
+   A flow back over two columns or more (a reply that closes a loop: an email to the shopper) leaves its source's bottom and
+   comes into its target's bottom, in the layout's axes, under the rows it passes: through the middle it crosses the lines
+   between them (15-information-flow.json, right and down). ponytail: one fixed side, not a search; a view whose long back
+   flows still cross would take the router's side choice (reroute), which S19 leaves off for the edits' time */
+function ifGeo({ model, view, pos, memo }) {
+  const I = ifIndex(model), ids = ifShown(I, view), lines = ifLines(I, view, new Set(ids)), P = id => (IF_OBJ(pos) && Object.hasOwn(pos, id) ? pos[id] : [0, 0]);
+  const nodes = ids.map(id => { const n = I.at.get(id), st = ifStereo(n), pr = IF_OBJ(n.props) ? n.props : {};
+    const look = n.type === 'uml.Comment' ? { shape: 'note' } : n.type === 'uml.Actor' ? { shape: 'actor', stereotypes: st } : n.type === 'uml.Component' ? { shape: 'component', stereotypes: st, keyword: !!pr.keyword }
+      : n.type === 'uml.InformationItem' ? { shape: 'information-item', stereotypes: st, compartments: [] } : { shape: 'if-classifier', stereotypes: [...[ifKey(n.type || 'uml.Class')].filter(Boolean), ...st], compartments: [] };
+    const d = { id, label: ifName(n), type: n.type || 'uml.Class', kind: 'file', ...look, aria: ifNodeName(I, n), col: P(id)[0], row: P(id)[1] };
+    return { ...d, ...SHAPE[d.shape].size(d) }; });
+  const edges = lines.map(e => { const flow = e.type === 'uml.InformationFlow', label = flow ? '«flow» ' + ifSays(I, e) : e.label;
+    return { id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, label: IF_HAS(label) ? label : undefined, end: flow ? { from: 'none', to: 'open', dashed: true } : { from: 'none', to: 'none', dashed: true },
+      aria: ifLineName(I, e), cut: 280, ...(P(e.from)[0] - P(e.to)[0] > 1 ? { fromSide: 'bottom', toSide: 'bottom' } : {}), ...(IF_OBJ(e.style) || typeof e.style === 'string' ? { style: e.style } : {}) }; });
+  const g = layoutTyped({ nodes, edges, direction: view.direction === 'down' ? 'down' : 'right', gap: 48, rgap: 56, labelGaps: true, repair: false, reroute: false }, memo);
+  return { ...g, legend: ifLegend(g.edges), order: [...ids, ...lines.map(e => e.id)] }; // a new object: what layoutTyped returned is never edited (§2.6)
+}
+
+/* ---- validators (§7.4). Each problem: { level, rule, path, message, ids } ---- */
+const IF_RULES = {
+  'conveyed-some': 'an information flow conveys one element at least',
+  'conveyed-kind': 'each element a flow conveys is an information item, a class, an interface, a component or a signal of the model',
+  'conveyed-once': 'a flow conveys each element once (UML: conveyed is a set)',
+  'flow-ends': 'an information flow joins two classes, interfaces, components or actors, never an information item or a comment',
+};
+function ifProblems(model) {
+  const out = [], I = ifIndex(model), say = (rule, path, ids, msg) => out.push({ level: 'error', rule, path, ids: ids.filter(x => x != null), message: `${rule}: ${msg}` });
+  const q = id => JSON.stringify(I.nm(id)), kind = id => (I.at.has(id) ? ifWord(I.at.get(id).type).toLowerCase() : 'nothing');
+  IF_ARR(model && model.edges).forEach((e, i) => { if (!IF_OBJ(e) || e.type !== 'uml.InformationFlow') return; const path = `edges[${i}]`, c = I.conveyed(e);
+    if (!c.length) say('conveyed-some', path, [e.id], `${e.id} conveys nothing: a flow conveys one element at least`);
+    c.forEach((id, j) => { if (c.indexOf(id) < j) say('conveyed-once', `${path}.props.conveyed[${j}]`, [e.id, typeof id === 'string' ? id : null], `${e.id} conveys ${q(id)} twice: a flow conveys each element once`);
+      else if (!I.at.has(id) || !IF_CONVEY.includes(I.at.get(id).type))
+      say('conveyed-kind', `${path}.props.conveyed[${j}]`, [e.id, typeof id === 'string' ? id : null], I.at.has(id) ? `${e.id} conveys ${q(id)}, a ${kind(id)}: it conveys information items, classes, interfaces, components and signals` : `${e.id} conveys ${JSON.stringify(id)}, which the model does not hold`); });
+    if (!IF_ENDS.includes((I.at.get(e.from) || {}).type) || !IF_ENDS.includes((I.at.get(e.to) || {}).type))
+      say('flow-ends', path, [e.id, e.from, e.to], `${e.id} runs from ${q(e.from)} (${kind(e.from)}) to ${q(e.to)} (${kind(e.to)}): a flow joins two classes, interfaces, components or actors`); });
+  return out;
+}
+
+/* ---- describe(): the view in sentences, each element by its accessible name in the view's order, then each line ---- */
+function ifDescribe(model, viewId) {
+  const v = IF_ARR(model && model.views).find(x => IF_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const I = ifIndex(model), ids = ifShown(I, v), lines = ifLines(I, v, new Set(ids));
+  return [`${v.title || v.id}: an information flow diagram of ${ifPlural(ids.length, 'element')} and ${ifPlural(lines.length, 'line')}.`,
+    ...ids.map(id => ifNodeName(I, I.at.get(id)) + '.'), ...lines.map(e => ifLineName(I, e) + '.')].join('\n');
+}
+
+/* ---- editing (§7.4) ---- */
+// the elements a flow may convey, information items first, then classifiers, each in the model's order
+const ifConveyable = I => [...I.at.values()].filter(n => IF_CONVEY.includes(n.type)).sort((a, b) => (b.type === 'uml.InformationItem') - (a.type === 'uml.InformationItem'));
+// connect: a flow between two classifiers or actors asks which element it conveys; other ends are refused, said on the hint line
+function ifConnect(model, view, from, to, at, line) {
+  if (!IF_OBJ(line) || line.type !== 'uml.InformationFlow') return null;
+  const I = ifIndex(model);
+  if (![from, to].every(id => IF_ENDS.includes((I.at.get(id) || {}).type))) return { error: 'An information flow joins two classes, interfaces, components or actors' };
+  const can = ifConveyable(I); if (!can.length) return { error: 'Add an information item for the flow to convey first' };
+  const used = new Set(); JSON.stringify(model, (k, v) => { if (k === 'id' && typeof v === 'string') used.add(v); return v; });
+  let k = 1; while (used.has('flow' + k)) k++;
+  return { pick: can.map(ifName), then: i => [{ op: 'add', element: { id: 'flow' + k, type: 'uml.InformationFlow', from, to, props: { conveyed: [can[i].id] } }, view: view.id }] };
+}
+// rename (F2, a double-click on a selected flow): the flow's text as drawn, `[name:] element, element`, «flow» left out or not;
+// each element by its name (an information item first), else by its id; a name may hold `:` or `,` (`Billing::Receipt`). The
+// text is read with no name first, then named at each `:` in turn; the reading that keeps the flow as it is wins, else the first
+// that names elements throughout. Sets conveyed (each once) and the name, each when it changed
+function ifRename(model, view, id, text) {
+  const I = ifIndex(model), e = I.E.find(x => x.id === id); if (!e || e.type !== 'uml.InformationFlow') return null;
+  const t = String(text ?? '').replace(/^\s*«flow»\s*/, ''), can = ifConveyable(I), find = s => can.find(n => ifName(n) === s) || can.find(n => n.id === s);
+  // a list read entry by entry, each the longest run of comma-separated parts that names an element
+  const list = s => { const p = s.split(','), ids = []; let i = 0;
+    while (i < p.length) { if (!p[i].trim()) { i++; continue; }
+      let j = p.length, x; while (j > i && !(x = find(p.slice(i, j).join(',').trim()))) j--;
+      if (!x) return { error: `No information item or classifier is named ${p[i].trim()}` }; ids.push(x.id); i = j; }
+    return ids.length ? { ids: [...new Set(ids)] } : { error: 'A flow conveys one element at least' }; };
+  const reads = [-1, ...[...t].flatMap((ch, k) => (ch === ':' ? [k] : []))].map(k => ({ name: k < 0 ? '' : t.slice(0, k).trim(), ...list(k < 0 ? t : t.slice(k + 1)) }));
+  const same = r => r.ids && r.name === (e.label ?? '') && JSON.stringify(r.ids) === JSON.stringify(I.conveyed(e));
+  const r = reads.find(same) || reads.find(x => x.ids); if (!r) return { error: reads[reads.length > 1 ? 1 : 0].error };
+  return [...(JSON.stringify(r.ids) !== JSON.stringify(I.conveyed(e)) ? [{ op: 'set', id, path: 'props.conveyed', value: r.ids }] : []),
+    ...(r.name !== (e.label ?? '') ? [{ op: 'set', id, path: 'label', value: r.name || undefined }] : [])];
+}
+
+// remove: Shift + Delete on what flows convey takes every flow left conveying nothing (conveyed-some), in the same
+// transaction, said on the hint line; a flow conveying something else keeps it (apply() drops the id: refs). Else the default
+function ifRemove(model, view, ids, fromModel) {
+  const I = ifIndex(model), gone = new Set(IF_ARR(ids)), flows = fromModel ? I.E.filter(e => e.type === 'uml.InformationFlow' && ![e.id, e.from, e.to].some(x => gone.has(x))
+    && I.conveyed(e).length && I.conveyed(e).every(x => gone.has(x))) : [];
+  if (!flows.length) return null;
+  return { commands: [...gone, ...flows.map(e => e.id)].map(id => ({ op: 'delete', id })),
+    say: `Deleted ${[...gone].map(id => { const l = I.E.find(e => e.id === id); return l ? `the line ${I.nm(l.from)} → ${I.nm(l.to)}` : JSON.stringify(I.nm(id)); }).join(', ')} and the ${ifPlural(flows.length, 'flow')} that conveyed nothing else: ${flows.map(e => `${I.nm(e.from)} → ${I.nm(e.to)}`).join(', ')}` };
+}
+
+const IF_STEREO = { key: 'stereotypes', label: 'Stereotypes', kind: 'list' };
+const IF_TYPE = registerDiagramType('uml.information-flow', {
+  title: 'information flow diagram',
+  elements: [['Class', 'Class'], ['Interface', 'Interface'], ['Component', 'Component'], ['Actor', 'Actor'], ['InformationItem', 'Information item'], ['Comment', 'Comment']].map(([t, label]) => ({ type: 'uml.' + t, label })),
+  lines: [['InformationFlow', 'Information flow'], ['CommentLink', 'Comment link']].map(([t, label]) => ({ type: 'uml.' + t, label })),
+  props: { 'uml.Class': [IF_STEREO], 'uml.Interface': [IF_STEREO], 'uml.Component': [IF_STEREO], 'uml.Actor': [IF_STEREO], 'uml.InformationItem': [], 'uml.InformationFlow': [], 'uml.CommentLink': [] },
+  refs: { 'uml.InformationFlow': { 'props.conveyed': 'drop' } }, // a deleted element leaves every flow that conveys it
+  layout: ifGeo,
+  validate: ifProblems,
+  rules: IF_RULES,
+  describe: ifDescribe,
+  edits: { connect: ifConnect, rename: ifRename, remove: ifRemove },
+  // the PDF (§9): an element's kind; an information item's rows, and any conveyed element's, the flows that convey it; a flow's text, what it conveys
+  word: (model, id) => { const x = ifIndex(model).at.get(id); return x && Object.hasOwn(IF_WORD, x.type) ? IF_WORD[x.type] : null; },
+  rows: (model, view, id) => { const I = ifIndex(model), x = I.at.get(id); return x && (x.type === 'uml.InformationItem' || I.flowsOf(id).length) ? I.flowsOf(id).map(e => `${I.nm(e.from)} → ${I.nm(e.to)}`) : null; },
+  text: (model, view, id) => { const I = ifIndex(model), e = I.E.find(x => x.id === id); return e && e.type === 'uml.InformationFlow' ? ifSays(I, e) : null; },
+});
+/* ---------- C4's elements and static views, c4.landscape, c4.context, c4.container, c4.component (work package M2.6,
+   notes/milestone-2.md §5.1, §5.2, §6.1, §6.5, §7.5, §7.5.1) ----------
+   People, software systems, containers and components, each drawn in the map's card shape its props.shape names (a person
+   `person`, the rest `box`, by default: S11) with C4's three lines over it: its name, [Container: technology], its
+   description; an external element grey. A view's subject, when it lists it, is a dashed boundary holding what it owns
+   that the view shows (ownersOn). A relationship whose end the view does not show is drawn between the nearest owners it
+   shows, one implied line a pair, dashed, unless a relationship joins them already (§5.2): derived when drawn, never stored,
+   its id `<from>-><to>`. Each view kind checks what it may show (§5.1). D on a software system or a container that opens
+   no view makes its container or component view (§6.1). One definition, registered under the four view names; the
+   dynamic and deployment views are src/c4/views.js's, on the helpers exported here. Laid out by layoutTyped from the
+   host's ranking, repair and reroute off (§11). Ships in lib/umlimator-all.js only. */
+
+const C4_OBJ = x => x !== null && typeof x === 'object' && !Array.isArray(x), C4_ARR = x => (Array.isArray(x) ? x : []);
+const C4_HAS = x => x != null && String(x).trim() !== '';
+const C4_P = x => (C4_OBJ(x.props) ? x.props : {});
+const c4Name = x => String(x.label ?? x.id);
+const c4Plural = (k, w) => `${k} ${k === 1 ? w : w + 's'}`;
+const C4_WORD = { 'c4.Person': 'Person', 'c4.SoftwareSystem': 'Software system', 'c4.Container': 'Container', 'c4.Component': 'Component',
+  'c4.DeploymentNode': 'Deployment node', 'c4.ContainerInstance': 'Container instance', 'uml.Comment': 'Comment' };
+const C4_TAG = { 'c4.Person': 'Person', 'c4.SoftwareSystem': 'Software System', 'c4.Container': 'Container', 'c4.Component': 'Component' };
+const c4Word = x => (Object.hasOwn(C4_WORD, x.type) ? C4_WORD[x.type] : String(x.type ?? '').split('.').pop());
+const C4_STATIC = ['c4.Person', 'c4.SoftwareSystem', 'c4.Container', 'c4.Component'], C4_DEPLOY = ['c4.DeploymentNode', 'c4.ContainerInstance'];
+// the map's card shapes an element may name (S11): all but UML's node, which is the deployment view's
+const C4_SHAPES = ['box', 'person', 'robot', 'browser', 'window', 'terminal', 'mobile', 'cylinder', 'pipe', 'folder', 'document', 'hexagon'];
+const c4Shape = x => { const s = String(C4_P(x).shape ?? '').toLowerCase(); return C4_SHAPES.includes(s) ? s : x.type === 'c4.Person' ? 'person' : 'box'; };
+const c4Ext = x => C4_P(x).external === true;
+// "[Container: Python, FastAPI]", "[Software System]", "[Person]"
+const c4TagOf = x => { const t = C4_TAG[x.type] || c4Word(x), tech = C4_P(x).technology; return `[${t}${C4_HAS(tech) && x.type !== 'c4.Person' && x.type !== 'c4.SoftwareSystem' ? ': ' + tech : ''}]`; };
+
+/* ---- the element (§7.5): the map shape's outline, det and face, sized by its text ---- */
+const C4 = { name: 13, nlh: 17, tag: 10, tlh: 14, d: 11, dlh: 14, dw: 220, dk: 4, minW: 160, maxW: 280, px: 14, py: 10, gap: 4 };
+const C4_TOP = { person: 26, robot: 16, browser: 14, window: 14, terminal: 14, folder: 9 }, C4_SIDE = { mobile: 12, pipe: 12, hexagon: 12 };
+function c4Parts(n) {
+  const pad = C4.px + (C4_SIDE[n.sh] || 0), max = C4.maxW - 2 * pad, name = flowWrap(n.label, C4.name, max, 2), tag = fit(n.tag || '', C4.tag, max);
+  const desc = C4_HAS(n.desc) ? flowWrap(n.desc, C4.d, Math.min(C4.dw, max), C4.dk) : [];
+  const w = Math.ceil(Math.min(C4.maxW, Math.max(C4.minW, Math.max(...name.map(t => textW(t, C4.name) * 1.05), textW(tag, C4.tag), ...desc.map(t => textW(t, C4.d))) + 2 * pad)));
+  const text = Math.max(1, name.length) * C4.nlh + C4.tlh + (desc.length ? C4.gap + desc.length * C4.dlh : 0), body = text + 2 * C4.py;
+  let h = (C4_TOP[n.sh] || 0) + body, top = C4_TOP[n.sh] || 0;
+  if (n.sh === 'cylinder') { for (let k = 0; k < 4; k++) h = body + 3 * Math.max(5, Math.round(h * .11)); top = 2 * Math.max(5, Math.round(h * .11)); } // the lid above, its rim below
+  return { name, tag, desc, w, h: Math.ceil(h), top, text, pad };
+}
+const c4Text = (x, y, t, px, wt, fill, cls, more = '') => `<text x="${r2(x)}" y="${r2(y)}" text-anchor="middle" class="${cls}"${more} fill="${fill}" style="font:${wt} ${px}px var(--um-sans)">${esc(t)}</text>`;
+const C4_EL = {
+  size: n => { const p = c4Parts(n); return { w: p.w, h: p.h }; },
+  out: (n, d = 0) => SHAPE[n.sh || 'box'].out(n, d), face: n => SHAPE[n.sh || 'box'].face(n),
+  inset: (n, s, t) => SHAPE[n.sh || 'box'].inset(n, s, t),
+  // its outline, the map shape's details (a person's head, a cylinder's lid) and C4's three lines, centred under its top
+  draw(n, c, f) {
+    const S = SHAPE[n.sh || 'box'], P = c4Parts(n), cx = n.x + n.w / 2, max = n.w - 2 * P.pad, bottom = n.sh === 'cylinder' ? P.top / 2 : 0;
+    let y = n.y + P.top + (n.h - P.top - bottom - P.text) / 2;
+    const tx = [];
+    P.name.forEach((t, i) => { tx.push(c4Text(cx, y + 13, fit(t, C4.name, max), C4.name, 600, 'var(--um-text)', 'c-name', i ? '' : ` data-o="${esc(n.id)}"`)); y += C4.nlh; });
+    tx.push(c4Text(cx, y + 10, fit(P.tag, C4.tag, max), C4.tag, 400, 'var(--um-muted)', 'c-st')); y += C4.tlh + C4.gap;
+    P.desc.forEach(t => { tx.push(c4Text(cx, y + 11, fit(t, C4.d, max), C4.d, 400, 'var(--um-text)', 'c-desc')); y += C4.dlh; });
+    return `<g class="node c4${n.ext ? ' c4-ext' : ''}" data-id="${esc(n.id)}" data-shape="c4" data-c4="${n.sh}" tabindex="-1" role="img" aria-label="${esc(n.aria || `${c4Word(n)} ${n.label ?? ''}`)}">`
+      + `<path d="${S.out(n)}" class="n-mask"/><path d="${S.out(n)}" class="n-body" fill="${f}" stroke="${c}"/>${S.det ? S.det(n, c, n.k) : ''}<g class="c-head">${tx.join('')}</g></g>`;
+  },
+};
+C4_EL.ports = (n, side, k = 1) => portsOn(C4_EL, n, side, k);
+SHAPE.c4 = C4_EL;
+// a boundary (§7.5.1): a dashed box titled "<name> [Software System]", as C4 draws it
+SHAPE['c4-boundary'] = { frame: f => `<rect class="family-box" x="${f.x}" y="${f.y}" width="${f.w}" height="${f.h}" rx="6" fill="none" stroke="var(--um-muted)" stroke-dasharray="6 4"/>`
+  + `<text class="family-title" x="${r2(f.x + 12)}" y="${r2(f.y + 18)}" fill="var(--um-text)" style="font:600 12px var(--um-sans)" data-t="ft" data-o="${esc(f.id)}">${esc(fit(f.title ?? f.label ?? f.id, 12, f.w - 24))}</text>` };
+
+/* ---- the model read: elements by id, their owners, relationships ---- */
+function c4Index(model) {
+  const at = new Map(); C4_ARR(model && model.nodes).forEach(n => { if (C4_OBJ(n) && typeof n.id === 'string' && !at.has(n.id)) at.set(n.id, n); });
+  const E = C4_ARR(model && model.edges).filter(e => C4_OBJ(e) && typeof e.id === 'string'), rels = E.filter(e => e.type === 'c4.Relationship');
+  // the chain of owners, nearest first; a cycle (the core's error) stops it
+  const chain = id => { const out = [], seen = new Set([id]); for (let p = (at.get(id) || {}).parent; p != null && at.has(p) && !seen.has(p); p = at.get(p).parent) { seen.add(p); out.push(p); } return out; };
+  const kids = (id, type) => [...at.values()].filter(n => n.parent === id && n.type === type).map(n => n.id);
+  return { at, E, rels, chain, kids };
+}
+const C4_LOOK = { boxTypes: ['c4.SoftwareSystem', 'c4.Container'], qualify: false, shape: () => 'c4-boundary', word: c4Word };
+// the view's picture: its boxes, titled as C4 titles a boundary, each named by what it holds
+function c4Pic(model, view) {
+  const pic = ownersOn(model, view, C4_LOOK), I = c4Index(model);
+  const boxes = pic.boxes.map(b => { const x = pic.at.get(b.id), held = pic.holds(b.id).map(id => pic.at.get(id)), k = new Map();
+    held.forEach(y => { const w = c4Word(y).toLowerCase(); k.set(w, (k.get(w) || 0) + 1); });
+    return { ...b, title: `${c4Name(x)} [${C4_TAG[x.type]}]`, aria: `${c4Word(x)} ${c4Name(x)}, a boundary holding ${[...k].map(([w, c]) => c4Plural(c, w)).join(', ') || 'nothing'}` }; });
+  return { ...pic, I, boxes };
+}
+
+/* ---- the lines drawn (§5.2): the view's own relationships between shown elements, then one implied line a pair ---- */
+// a relationship's end lifted to what the view shows of it: itself, else its nearest shown owner; null when the first shown
+// thing up its chain is a boundary (a boundary is no end) or nothing is shown
+function c4Lift(pic, id) {
+  for (const x of [id, ...pic.I.chain(id)]) if (pic.ids.includes(x)) return pic.open.has(x) ? null : x;
+  return null;
+}
+function c4Lines(model, view, pic) {
+  const ends = new Set(pic.ids.filter(id => !pic.open.has(id))), byId = new Map(pic.I.E.map(e => [e.id, e]));
+  const listed = Array.isArray(view.edges) ? view.edges.map(x => (typeof x === 'string' ? byId.get(x) : x)).filter(C4_OBJ) : null;
+  const own = (listed || pic.I.E.filter(e => e.type === 'c4.Relationship' || e.type === 'uml.CommentLink')).filter(e => typeof e.id === 'string' && ends.has(e.from) && ends.has(e.to));
+  // a pair a relationship joins already, drawn or hidden by the view's list, takes no implied line
+  const joined = new Set([...own, ...pic.I.rels].filter(e => ends.has(e.from) && ends.has(e.to)).map(e => e.from + '\n' + e.to)), implied = new Map();
+  pic.I.rels.forEach(r => { if (ends.has(r.from) && ends.has(r.to)) return; // shown as itself, or hidden from the view: never lifted
+    const a = c4Lift(pic, r.from), b = c4Lift(pic, r.to), k = a + '\n' + b;
+    if (a == null || b == null || a === b || joined.has(k)) return;
+    if (!implied.has(k)) implied.set(k, { id: `${a}->${b}`, from: a, to: b, of: [] });
+    implied.get(k).of.push(r); });
+  return { own, implied: [...implied.values()] };
+}
+const c4LineLabel = e => [e.label, C4_HAS(C4_P(e).technology) ? `[${C4_P(e).technology}]` : ''].filter(C4_HAS).join(' ');
+// accessible names (A1): "Container Shop API, Python, FastAPI: Catalogue, basket, checkout and accounts as a JSON API"
+function c4NodeName(x) {
+  if (x.type === 'uml.Comment') return 'Comment: ' + c4Name(x);
+  const P = C4_P(x), tech = x.type === 'c4.Container' || x.type === 'c4.Component' ? P.technology : null;
+  return `${c4Ext(x) ? 'External ' + c4Word(x).toLowerCase() : c4Word(x)} ${c4Name(x)}${C4_HAS(tech) ? ', ' + tech : ''}${C4_HAS(P.description) ? ': ' + P.description : ''}`;
+}
+// "Relationship from Storefront to Shop API: Reads the catalogue and places orders through [JSON over HTTPS]"; an implied
+// line names what it stands for and where they are edited
+function c4LineName(e, pic) {
+  const nm = id => c4Name(pic.at.get(id) || { id });
+  if (e.of) { const said = e.of.map(r => `${c4Name(pic.at.get(r.from) || { id: r.from })} to ${c4Name(pic.at.get(r.to) || { id: r.to })}${C4_HAS(r.label) ? ', ' + r.label : ''}`);
+    return `Implied relationship from ${nm(e.from)} to ${nm(e.to)}, standing for ${c4Plural(e.of.length, 'relationship')}: ${said.join('; ')}. Edit them where their own ends are shown`; }
+  if (e.type === 'uml.CommentLink') return `Comment link from ${nm(e.from)} to ${nm(e.to)}`;
+  const said = c4LineLabel(e); return `Relationship from ${nm(e.from)} to ${nm(e.to)}${said ? ': ' + said : ''}`;
+}
+
+/* ---- the key (§7.5): each element type and shape drawn, external, the relationship and the implied line ---- */
+const C4_LINE_LOOK = { rel: { from: 'none', to: 'open' }, implied: { from: 'none', to: 'open', dashed: true }, note: { from: 'none', to: 'none', dashed: true } };
+function c4Legend(nodes, edges) {
+  const els = [...new Map(nodes.filter(n => n.shape === 'c4').map(n => [`${n.type} ${n.sh} ${n.ext}`, n])).values()];
+  const swatch = n => `<rect x="3" y="2" width="22" height="12" rx="3" fill="var(--um-${n.ext ? 'slate' : 'cyan'}-f)" stroke="var(--um-${n.ext ? 'slate' : 'cyan'})"/>`;
+  const item = (name, says, svg) => `<span class="lgi" title="${esc(name + ' — ' + says)}"><svg class="lgs" viewBox="0 0 28 16" aria-hidden="true">${svg}</svg><b>${esc(name)}</b><span>${esc(says)}</span></span>`;
+  const line = dashed => `<g stroke="var(--um-muted)" stroke-width="1.4" stroke-linejoin="round" fill="none"><path d="M2 8H25"${dashed ? ' stroke-dasharray="3 2"' : ''}/><path d="M17 4L26 8L17 12"/></g>`;
+  return [...els.map(n => item(`${n.ext ? 'External ' + c4Word(n).toLowerCase() : c4Word(n)}${n.sh !== 'box' && !(n.sh === 'person' && n.type === 'c4.Person') ? ', ' + n.sh : ''}`,
+    n.ext ? 'outside the system, drawn grey' : `a ${c4Word(n).toLowerCase()}`, swatch(n))),
+  ...(edges.some(e => e.type === 'c4.Relationship' && !e.implied) ? [item('Relationship', 'uses, with its technology in brackets', line(false))] : []),
+  ...(edges.some(e => e.implied) ? [item('Implied relationship', 'stands for relationships between what the two hold', line(true))] : [])];
+}
+
+/* ---- the view laid out (§7.5, §11) ---- */
+function c4Geo({ model, view, pos, memo }) {
+  const pic = c4Pic(model, view), { own, implied } = c4Lines(model, view, pic), P = id => (C4_OBJ(pos) && Object.hasOwn(pos, id) ? pos[id] : [0, 0]);
+  const nodes = pic.ids.filter(id => !pic.open.has(id)).map(id => { const x = pic.at.get(id);
+    if (x.type === 'uml.Comment') { const d = { id, label: c4Name(x), type: x.type, kind: 'file', shape: 'note', aria: c4NodeName(x), col: P(id)[0], row: P(id)[1] }; return { ...d, ...SHAPE.note.size(d) }; }
+    const ext = c4Ext(x), d = { id, label: c4Name(x), type: x.type || 'c4.SoftwareSystem', kind: ext ? 'external' : 'frontend', shape: 'c4', sh: c4Shape(x), ext, tag: c4TagOf(x), desc: C4_P(x).description,
+      aria: c4NodeName(x), col: P(id)[0], row: P(id)[1] };
+    return { ...d, ...C4_EL.size(d) }; });
+  const edges = [...own.map(e => { const note = e.type === 'uml.CommentLink', label = note ? '' : c4LineLabel(e);
+    return { id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, label: label || undefined, end: note ? C4_LINE_LOOK.note : C4_LINE_LOOK.rel, aria: c4LineName(e, pic), cut: 280 }; }),
+  ...implied.map(e => ({ id: e.id, _id: e.id, type: 'c4.Relationship', from: e.from, to: e.to, implied: e.of.map(r => r.id), end: C4_LINE_LOOK.implied, aria: c4LineName(e, pic), cut: 280,
+    label: [e.of[0].label, e.of.length > 1 ? `[+${e.of.length - 1}]` : ''].filter(C4_HAS).join(' ') || undefined }))];
+  const g = layoutTyped({ nodes, edges, ...(pic.boxes.length ? { containers: pic.boxes } : {}), direction: view.direction === 'down' ? 'down' : 'right',
+    gap: 48, rgap: 64, labelGaps: true, repair: false, reroute: false }, memo);
+  // on a copy (stage 4 §2.4): a person's or robot's body starts just above the highest line on its side, as a map card's
+  // does (sidePorts), so each such end lands on its outline
+  const sp = sidePorts(g), lift = new Map();
+  g.nodes.forEach(n => { const p = (n.sh === 'person' || n.sh === 'robot') && sp.get(n), t = p ? Math.min(p.L, p.R) : Infinity; if (t < n.y + 14) lift.set(n, { ...n, portTop: t }); });
+  const out = lift.size ? { nodes: g.nodes.map(n => lift.get(n) || n), byId: Object.fromEntries(g.nodes.map(n => [n.id, lift.get(n) || n])),
+    edges: g.edges.map(e => (lift.has(e.s) || lift.has(e.t) ? { ...e, s: lift.get(e.s) || e.s, t: lift.get(e.t) || e.t } : e)) } : {};
+  return { ...g, ...out, legend: c4Legend(nodes, edges), order: [...readingOrder(pic), ...edges.map(e => e.id)] }; // a new object: what layoutTyped returned is never edited
+}
+
+/* ---- validators (§5.1, §6.5). Each problem: { level, rule, path, message, ids } ---- */
+const C4_RULES = {
+  'c4-level': 'a view shows only what its level draws: a landscape or context view people and software systems; a container view containers too; a component view the components of its subject; an element is not listed with its owner unless that owner is the view\'s subject',
+  'c4-subject': 'a context or container view zooms into a software system, a component view into a container; a context view shows its subject',
+  'c4-owner': 'a container is owned by a software system, a component by a container, a container instance by a deployment node; a person or software system by nothing',
+  'c4-instance': 'a container instance names a container',
+  'c4-relationship': 'a relationship joins two static elements or two deployment elements, never an element and its own owner',
+  'c4-zoom': 'a software system opens a view whose subject is that system, a container one whose subject is that container',
+  'c4-description': 'every element has a description',
+  'c4-technology': 'every container and component has a technology',
+  'c4-label': 'every relationship has a description',
+  'c4-title': 'every view has a title',
+};
+const C4_KIND = { 'c4.landscape': 'landscape', 'c4.context': 'context', 'c4.container': 'container', 'c4.component': 'component' };
+// what each static view kind may show (§5.1), and the type its subject is
+const C4_SHOWS = { landscape: ['c4.Person', 'c4.SoftwareSystem'], context: ['c4.Person', 'c4.SoftwareSystem'], container: ['c4.Person', 'c4.SoftwareSystem', 'c4.Container'],
+  component: ['c4.Person', 'c4.SoftwareSystem', 'c4.Container', 'c4.Component'] };
+const C4_SUBJECT = { context: 'c4.SoftwareSystem', container: 'c4.SoftwareSystem', component: 'c4.Container' };
+const C4_OWNER = { 'c4.Container': 'c4.SoftwareSystem', 'c4.Component': 'c4.Container', 'c4.ContainerInstance': 'c4.DeploymentNode' };
+const c4A = w => (/^[aeiou]/i.test(w) ? 'an ' : 'a ') + w;
+function c4Problems(model, view) {
+  const out = [], I = c4Index(model), say = (level, rule, path, ids, msg) => out.push({ level, rule, path, ids: ids.filter(x => x != null), message: `${rule}: ${msg}` });
+  const q = id => JSON.stringify(I.at.has(id) ? c4Name(I.at.get(id)) : String(id)), kind = id => (I.at.has(id) ? c4Word(I.at.get(id)).toLowerCase() : 'nothing');
+  const views = C4_ARR(model && model.views), vi = views.indexOf(view), at = vi >= 0 ? `views[${vi}]` : 'view', K = C4_OBJ(view) ? C4_KIND[view.diagram] : null;
+  // the model's rules: said once, whichever view asks (validate() keeps one of each path and message)
+  C4_ARR(model && model.nodes).forEach((n, i) => { if (!C4_OBJ(n)) return;
+    if (Object.hasOwn(C4_OWNER, n.type) && (I.at.get(n.parent) || {}).type !== C4_OWNER[n.type])
+      say('error', 'c4-owner', `nodes[${i}].parent`, [n.id, n.parent], `${q(n.id)}, ${c4A(kind(n.id))}, is owned by ${n.parent != null && I.at.has(n.parent) ? `${q(n.parent)}, ${c4A(kind(n.parent))}` : 'nothing'}: its owner is ${c4A(C4_WORD[C4_OWNER[n.type]].toLowerCase())}`);
+    if ((n.type === 'c4.Person' || n.type === 'c4.SoftwareSystem') && n.parent != null)
+      say('error', 'c4-owner', `nodes[${i}].parent`, [n.id, n.parent], `${q(n.id)}, ${c4A(kind(n.id))}, is owned by ${q(n.parent)}${I.at.has(n.parent) ? `, ${c4A(kind(n.parent))}` : ''}: it is owned by nothing`);
+    if (n.type === 'c4.DeploymentNode' && n.parent != null && (I.at.get(n.parent) || {}).type !== 'c4.DeploymentNode')
+      say('error', 'c4-owner', `nodes[${i}].parent`, [n.id, n.parent], `${q(n.id)}, a deployment node, is owned by ${q(n.parent)}, ${c4A(kind(n.parent))}: its owner is a deployment node or none`);
+    if (n.type === 'c4.ContainerInstance' && (I.at.get(C4_P(n).container) || {}).type !== 'c4.Container')
+      say('error', 'c4-instance', `nodes[${i}].props.container`, [n.id, C4_P(n).container], `${q(n.id)} is an instance of ${!C4_HAS(C4_P(n).container) ? 'nothing' : I.at.has(C4_P(n).container) ? `${q(C4_P(n).container)}, ${c4A(kind(C4_P(n).container))}` : `${JSON.stringify(String(C4_P(n).container))}, which is no element`}: it names a container`);
+    // §6.5: a system's or container's opensView, when it names a C4 view, has that element as its subject
+    const ov = (n.type === 'c4.SoftwareSystem' || n.type === 'c4.Container') && n.opensView != null && views.find(v => C4_OBJ(v) && v.id === n.opensView);
+    if (ov && /^c4\./.test(String(ov.diagram)) && ov.subject !== n.id)
+      say('warning', 'c4-zoom', `nodes[${i}].opensView`, [n.id, ov.subject], `${q(n.id)} opens view ${JSON.stringify(ov.title || ov.id)}, whose subject is ${ov.subject != null ? q(ov.subject) : 'none'}: it zooms into ${q(n.id)}`); });
+  // a relationship by its path: the model's, else written inline in the view's edges (model.md)
+  const vEdges = C4_OBJ(view) ? C4_ARR(view.edges) : [], pathOf = e => { const i = C4_ARR(model && model.edges).indexOf(e); return i >= 0 ? `edges[${i}]` : `${at}.edges[${vEdges.indexOf(e)}]`; };
+  [...C4_ARR(model && model.edges), ...vEdges.filter(e => C4_OBJ(e) && !C4_ARR(model && model.edges).includes(e))].forEach(e => { if (!C4_OBJ(e) || e.type !== 'c4.Relationship') return;
+    const i = pathOf(e), a = I.at.get(e.from), b = I.at.get(e.to), st = x => x && C4_STATIC.includes(x.type), dp = x => x && C4_DEPLOY.includes(x.type);
+    if ((st(a) && dp(b)) || (dp(a) && st(b))) say('error', 'c4-relationship', i, [e.id, e.from, e.to], `${e.id} joins ${q(e.from)}, ${c4A(kind(e.from))}, and ${q(e.to)}, ${c4A(kind(e.to))}: a static element and a deployment one`);
+    else if (a && b && (I.chain(e.from).includes(e.to) || I.chain(e.to).includes(e.from))) say('error', 'c4-relationship', i, [e.id, e.from, e.to], `${e.id} joins ${q(e.from)} and its own owner or part ${q(e.to)}`); });
+  if (!K) return out;
+  // the view's rules (§5.1)
+  const ids = C4_ARR(view.nodeIds), S = C4_SUBJECT[K], subj = view.subject != null ? I.at.get(view.subject) : null;
+  if (K === 'context' && !(subj && subj.type === S && ids.includes(view.subject)))
+    say('warning', 'c4-subject', `${at}.subject`, [view.subject], view.subject == null ? 'a context view names the software system it is about as its subject' : `${q(view.subject)} is ${!subj || subj.type !== S ? 'not a software system' : 'not shown'}: a context view shows its software system`);
+  if ((K === 'container' || K === 'component') && !(subj && subj.type === S))
+    say('error', 'c4-subject', `${at}.subject`, [view.subject], `${view.subject == null ? 'the view has no subject' : `its subject ${q(view.subject)} is ${c4A(kind(view.subject))}`}: a ${K} view zooms into ${c4A(C4_WORD[S].toLowerCase())}`);
+  ids.forEach((id, k) => { const x = I.at.get(id); if (!x || x.type === 'uml.Comment') return;
+    const ok = C4_SHOWS[K].includes(x.type) && !(K === 'component' && x.type === 'c4.Component' && x.parent !== view.subject);
+    if (!ok) say('error', 'c4-level', `${at}.nodeIds[${k}]`, [id], `${q(id)}, ${c4A(kind(id))}${x.type === 'c4.Component' && K === 'component' ? ` of ${q(x.parent)}` : ''}, is not drawn in a ${K} view`);
+    // §7.5.1: only the subject is a boundary; any other listed owner would box this element and drop the lines lifted onto it
+    const o = I.chain(id).find(y => ids.includes(y));
+    if (ok && o != null && o !== view.subject) say('error', 'c4-level', `${at}.nodeIds[${k}]`, [id, o], `${q(id)} is listed with its owner ${q(o)}, which is not the view's subject: only the subject is drawn as a boundary`);
+    const P = C4_P(x), j = C4_ARR(model.nodes).indexOf(x);
+    if (C4_STATIC.includes(x.type) && !C4_HAS(P.description)) say('warning', 'c4-description', `nodes[${j}].props.description`, [id], `${q(id)} has no description`);
+    if ((x.type === 'c4.Container' || x.type === 'c4.Component') && !C4_HAS(P.technology)) say('warning', 'c4-technology', `nodes[${j}].props.technology`, [id], `${q(id)}, ${c4A(kind(id))}, has no technology`); });
+  const pic = c4Pic(model, view);
+  c4Lines(model, view, pic).own.forEach(e => {
+    if (e.type === 'c4.Relationship' && !C4_HAS(e.label)) say('warning', 'c4-label', `${pathOf(e)}.label`, [e.id, e.from, e.to], `${e.id}, from ${q(e.from)} to ${q(e.to)}, has no description`); });
+  if (!C4_HAS(view.title)) say('warning', 'c4-title', `${at}.title`, [], `view ${JSON.stringify(view.id)} has no title`);
+  return out;
+}
+
+/* ---- describe(): the view in sentences, each element in reading order, then each line by its accessible name ---- */
+function c4Describe(model, viewId) {
+  const v = C4_ARR(model && model.views).find(x => C4_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const pic = c4Pic(model, v), { own, implied } = c4Lines(model, v, pic), K = C4_KIND[v.diagram] || 'C4', box = new Map(pic.boxes.map(b => [b.id, b]));
+  return [`${v.title || v.id}: a C4 ${K === 'landscape' ? 'system landscape' : K === 'context' ? 'system context' : K} diagram of ${c4Plural(pic.ids.length, 'element')} and ${c4Plural(own.length + implied.length, 'relationship')}${implied.length ? `, ${implied.length} of them implied` : ''}.`,
+    ...readingOrder(pic).map(id => (box.has(id) ? box.get(id).aria : c4NodeName(pic.at.get(id)))), ...[...own, ...implied].map(e => c4LineName(e, pic))].map(t => t.replace(/\.?$/, '.')).join('\n');
+}
+
+/* ---- editing (§6.1, §7.5) ---- */
+const c4Used = model => { const used = new Set(C4_ARR(model.views).filter(C4_OBJ).map(v => v.id)); JSON.stringify(model, (k, v) => { if (k === 'id' && typeof v === 'string') used.add(v); return v; }); return used; };
+const c4Free = (used, base) => { if (!used.has(base)) return base; let k = 2; while (used.has(`${base}-${k}`)) k++; return `${base}-${k}`; };
+// D (§6.1): a software system's container view, or a container's component view, made: the element (its boundary), what it
+// owns a level down, and what their relationships reach, each lifted to that level; the element then opens it. One transaction
+function c4Zoom(model, view, ids) {
+  const I = c4Index(model), x = [...ids].reverse().map(id => I.at.get(id)).find(y => y && (y.type === 'c4.SoftwareSystem' || y.type === 'c4.Container') && y.opensView == null);
+  if (!x) return null;
+  const sys = x.type === 'c4.SoftwareSystem', kids = I.kids(x.id, sys ? 'c4.Container' : 'c4.Component'), inside = new Set(kids);
+  // the far end of a relationship, at the new view's level: a person or a software system as it is, a container as it is (a
+  // system's own are inside already), a component as its container, anything else not at all
+  const level = id => { for (const y of [id, ...I.chain(id)]) { const t = (I.at.get(y) || {}).type;
+    if (t === 'c4.Person' || t === 'c4.SoftwareSystem' || t === 'c4.Container') return y === x.id ? null : y; } return null; };
+  const reach = []; I.rels.forEach(r => [[r.from, r.to], [r.to, r.from]].forEach(([a, b]) => { const up = [a, ...I.chain(a)].find(y => inside.has(y));
+    const far = up && !inside.has(b) && !I.chain(b).some(y => inside.has(y)) ? level(b) : null; if (far && !reach.includes(far)) reach.push(far); }));
+  const used = c4Used(model), id = c4Free(used, `${x.id}-${sys ? 'containers' : 'components'}`);
+  const v = { id, diagram: sys ? 'c4.container' : 'c4.component', title: `${c4Name(x)}: ${sys ? 'containers' : 'components'}`, parent: view.id, subject: x.id, nodeIds: [x.id, ...kids, ...reach] };
+  return { commands: [{ op: 'addView', view: v }, { op: 'set', id: x.id, path: 'opensView', value: id }], say: `Made the view ${v.title}: Enter opens it` };
+}
+// T: an element's C4 type, picked among the four (c4-owner and c4-level then say what no longer fits)
+function c4Retype(model, ids) {
+  const I = c4Index(model), x = I.at.get(ids.at(-1)); if (!x || !C4_STATIC.includes(x.type)) return null;
+  return { pick: C4_STATIC.map(t => C4_WORD[t]), then: i => (C4_STATIC[i] === x.type ? [] : [{ op: 'set', id: x.id, path: 'type', value: C4_STATIC[i] }]) };
+}
+const c4Key = (model, view, ids, key) => (key === 'd' || key === 'D' ? c4Zoom(model, view, ids) : key === 't' || key === 'T' ? c4Retype(model, ids) : null);
+// add: a container added to a container view, or a component to a component view, is owned by the view's subject
+function c4Add(model, view, entry, label) {
+  const I = c4Index(model), s = I.at.get(view.subject), K = C4_KIND[view.diagram];
+  if (!s || !((K === 'container' && entry.type === 'c4.Container') || (K === 'component' && entry.type === 'c4.Component')) || s.type !== C4_OWNER[entry.type]) return null;
+  const base = entry.type.split('.').pop().toLowerCase(), used = c4Used(model); let k = 1; while (used.has(base + k)) k++;
+  return [{ op: 'add', element: { id: base + k, type: entry.type, ...(label ? { label } : {}), parent: s.id }, view: view.id }];
+}
+// the Owner field: a container's software systems, a component's containers
+function c4Owners(model, x) {
+  if (!C4_OBJ(x) || x.from != null || !Object.hasOwn(C4_OWNER, x.type) || x.type === 'c4.ContainerInstance') return null;
+  return C4_ARR(model.nodes).filter(n => C4_OBJ(n) && n.type === C4_OWNER[x.type]).map(n => ({ id: n.id, label: c4Name(n) }));
+}
+
+/* ---- the type, under its four static view names ---- */
+let c4People = new Set();
+const C4_ELEMENT_PROPS = [{ key: 'description', label: 'Description', kind: 'text' }, { key: 'technology', label: 'Technology', kind: 'text' },
+  { key: 'external', label: 'External', kind: 'bool' }, { key: 'shape', label: 'Shape', kind: 'enum', options: C4_SHAPES }];
+const C4_DEF = {
+  title: 'C4 diagram',
+  elements: [...C4_STATIC.map(t => ({ type: t, label: C4_WORD[t] })), { type: 'uml.Comment', label: 'Comment' }],
+  lines: [{ type: 'c4.Relationship', label: 'Relationship' }, { type: 'uml.CommentLink', label: 'Comment link' }],
+  props: { 'c4.Person': C4_ELEMENT_PROPS.filter(f => f.key !== 'technology'), 'c4.SoftwareSystem': C4_ELEMENT_PROPS.filter(f => f.key !== 'technology'),
+    'c4.Container': C4_ELEMENT_PROPS, 'c4.Component': C4_ELEMENT_PROPS, 'c4.Relationship': [{ key: 'technology', label: 'Technology', kind: 'text' }], 'uml.CommentLink': [] },
+  layout: c4Geo,
+  boxes: (model, view) => { c4People = new Set(C4_ARR(model && model.nodes).filter(n => C4_OBJ(n) && n.type === 'c4.Person').map(n => n.id)); return c4Pic(model, view).boxes; },
+  // a line into a person is ranked as if it came from them, so people come first (C4 draws them at the top or left). The host
+  // asks boxes() before it ranks a view, which leaves the model's people here. ponytail: module state read by rankFlip,
+  // which sees the line alone; a rankFlip(e, model) would lift it
+  rankFlip: e => c4People.has(e.to) && !c4People.has(e.from),
+  owners: c4Owners,
+  validate: c4Problems,
+  rules: C4_RULES,
+  describe: c4Describe,
+  // the PDF's tables (§9): an element's type; its technology and description; a relationship's text, with its technology
+  word: (model, id) => { const x = c4Index(model).at.get(id); return x && Object.hasOwn(C4_WORD, x.type) ? C4_WORD[x.type] : null; },
+  rows: (model, view, id) => { const x = c4Index(model).at.get(id); if (!x || !C4_STATIC.includes(x.type)) return null; const P = C4_P(x);
+    return [...(C4_HAS(P.technology) ? [P.technology] : []), ...(C4_HAS(P.description) ? [P.description] : []), ...(c4Ext(x) ? ['external'] : [])]; },
+  text: (model, view, id) => { const e = c4Index(model).rels.find(r => r.id === id) || (C4_OBJ(view) ? C4_ARR(view.edges) : []).find(r => C4_OBJ(r) && r.id === id && r.type === 'c4.Relationship'); return e ? c4LineLabel(e) || null : null; },
+  edits: { add: c4Add, key: c4Key },
+};
+const C4_TYPES = Object.keys(C4_KIND).map(name => registerDiagramType(name, C4_DEF));
+/* ---------- C4's dynamic and deployment views, c4.dynamic and c4.deployment (work package M2.7, notes/milestone-2.md §7.5.2,
+   §7.5.3, §5.1) ----------
+   The dynamic view: its `edges` are model relationships by id, each once, in time order (S13); each is drawn numbered by its
+   place, "k · description [technology]" (the layout's step: with no room for its text a label keeps its number), over the
+   layered layout of the elements it shows, laid out as src/c4/c4.js lays a static view out (its boundary, people first); only
+   steps are drawn, none implied. Alt + arrows on a
+   selected step move it one place (moveTo); a relationship drawn by L or the handle between two shown elements is a step,
+   the model's own when one joins them already. Its level is its subject's: a software system's as a container view, a
+   container's as a component view, none as a landscape. The deployment view: deployment nodes nest as solid boxes
+   (ownersOn) titled "<name> [Deployment Node: technology]", a node holding nothing shown drawn as the map's node shape;
+   a container instance is drawn as its container (shape, name, technology, description), "Instance of" in its name. Its
+   lines are the model's, lifted as §5.2 lifts them. Deleting a container deletes its instances (refs). Ships in
+   lib/umlimator-all.js only. */
+
+const V_OBJ = x => x !== null && typeof x === 'object' && !Array.isArray(x), V_ARR = x => (Array.isArray(x) ? x : []);
+const V_HAS = x => x != null && String(x).trim() !== '';
+const V_P = x => (V_OBJ(x.props) ? x.props : {});
+const vName = x => String(x.label ?? x.id);
+const vPlural = (k, w) => `${k} ${k === 1 ? w : w + 's'}`;
+const V_RULES = { ...C4_RULES,
+  'c4-level': C4_RULES['c4-level'] + '; a dynamic view what its subject\'s level draws; a deployment view deployment nodes and container instances, with a subject only instances of its containers',
+  'c4-subject': C4_RULES['c4-subject'] + '; a dynamic view zooms into a software system, a container or nothing; a deployment view into a software system or nothing',
+  'c4-steps': 'a dynamic view\'s steps are the model\'s relationships, each once, between elements it shows; it lists at least one' };
+const DEP_RULES = { ...V_RULES, 'c4-box-line': 'a deployment view draws no line onto a deployment node drawn as a box: a relationship with an end in or on one is not drawn' };
+// every id the model holds, views' too (src/c4/c4.js's c4Used, not exported; src/c4/c4.js is M2.6's)
+const vUsed = model => { const used = new Set(V_ARR(model.views).filter(V_OBJ).map(v => v.id)); JSON.stringify(model, (k, v) => { if (k === 'id' && typeof v === 'string') used.add(v); return v; }); return used; };
+
+/* ---- the dynamic view (§7.5.2) ---- */
+// its steps drawn: [{ e, k, i }], each model relationship listed (the first time) between two elements the view shows (not a
+// boundary), numbered 1, 2, 3 among those drawn (S13), i its place in view.edges
+function dynSteps(model, view) {
+  if (!V_OBJ(view)) return [];
+  const pic = c4Pic(model, view), ends = new Set(pic.ids.filter(id => !pic.open.has(id))), rel = new Map(pic.I.rels.map(r => [r.id, r])), seen = new Set(), out = [];
+  V_ARR(view.edges).forEach((x, i) => { const e = typeof x === 'string' ? rel.get(x) : null;
+    if (e && !seen.has(e.id) && ends.has(e.from) && ends.has(e.to)) out.push({ e, k: out.length + 1, i }); if (e) seen.add(e.id); });
+  return out;
+}
+// the level a dynamic view draws at: as the static view its subject's type zooms to
+const dynLevel = (model, view) => { const t = (c4Index(model).at.get(view.subject) || {}).type;
+  return view.subject == null ? 'c4.landscape' : t === 'c4.SoftwareSystem' ? 'c4.container' : t === 'c4.Container' ? 'c4.component' : null; };
+// what a dynamic view draws: its steps between two elements it shows (not a boundary), and the comment links it lists
+function dynDrawn(model, view) {
+  const pic = c4Pic(model, view), ends = new Set(pic.ids.filter(id => !pic.open.has(id))), steps = dynSteps(model, view);
+  const notes = V_ARR(view.edges).map(x => (typeof x === 'string' ? pic.I.E.find(e => e.id === x) : null)).filter(e => e && e.type === 'uml.CommentLink' && ends.has(e.from) && ends.has(e.to));
+  return { pic, steps, notes };
+}
+const dynName = (e, k, pic) => `Step ${k}: ${c4LineName(e, pic)}`;
+// the key's items: each element type, shape and tone drawn (as src/c4/c4.js keys them), the relationship and the implied line
+const vItem = (name, says, svg) => `<span class="lgi" title="${esc(name + ' — ' + says)}"><svg class="lgs" viewBox="0 0 28 16" aria-hidden="true">${svg}</svg><b>${esc(name)}</b><span>${esc(says)}</span></span>`;
+const vSwatch = ext => `<rect x="3" y="2" width="22" height="12" rx="3" fill="var(--um-${ext ? 'slate' : 'cyan'}-f)" stroke="var(--um-${ext ? 'slate' : 'cyan'})"/>`;
+const vLine = dashed => `<g stroke="var(--um-muted)" stroke-width="1.4" stroke-linejoin="round" fill="none"><path d="M2 8H25"${dashed ? ' stroke-dasharray="3 2"' : ''}/><path d="M17 4L26 8L17 12"/></g>`;
+const vLines = (edges, says = 'uses, with its technology in brackets') => [...(edges.some(e => e.type === 'c4.Relationship' && !e.implied) ? [vItem('Relationship', says, vLine(false))] : []),
+  ...(edges.some(e => e.implied) ? [vItem('Implied relationship', 'stands for relationships between what the two hold', vLine(true))] : [])];
+const V_LINE = { rel: { from: 'none', to: 'open' }, implied: { from: 'none', to: 'open', dashed: true }, note: { from: 'none', to: 'none', dashed: true } };
+// an element of a C4 view as src/c4/c4.js draws it (shape c4: its map shape and three lines), or a comment
+function vNode(id, x, P, more = {}) {
+  if (x.type === 'uml.Comment') { const d = { id, label: vName(x), type: x.type, kind: 'file', shape: 'note', aria: c4NodeName(x), col: P(id)[0], row: P(id)[1] }; return { ...d, ...SHAPE.note.size(d) }; }
+  const ext = c4Ext(x), d = { id, label: vName(x), type: x.type, kind: ext ? 'external' : 'frontend', shape: 'c4', sh: c4Shape(x), ext, tag: c4TagOf(x), desc: V_P(x).description, aria: c4NodeName(x), col: P(id)[0], row: P(id)[1], ...more };
+  return { ...d, ...SHAPE.c4.size(d) };
+}
+// laid out as src/c4/c4.js lays a static view out (§11): its boxes, people first, the small gaps, labelGaps, repair and reroute off;
+// each step carries its number as the layout's step, so a label with no room keeps its number ("3" for "3 · Charges cards with")
+function dynGeo({ model, view, pos, memo }) {
+  const { pic, steps, notes } = dynDrawn(model, view), P = id => (V_OBJ(pos) && Object.hasOwn(pos, id) ? pos[id] : [0, 0]);
+  const nodes = pic.ids.filter(id => !pic.open.has(id)).map(id => vNode(id, pic.at.get(id), P));
+  const edges = [...steps.map(({ e, k }) => ({ id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, step: k, label: c4LineLabel(e) || undefined, end: V_LINE.rel, aria: dynName(e, k, pic), cut: 280 })),
+    ...notes.map(e => ({ id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, end: V_LINE.note, aria: c4LineName(e, pic), cut: 280 }))];
+  const g = layoutTyped({ nodes, edges, ...(pic.boxes.length ? { containers: pic.boxes } : {}), direction: view.direction === 'down' ? 'down' : 'right',
+    gap: 48, rgap: 64, labelGaps: true, repair: false, reroute: false }, memo);
+  // on a copy (stage 4 §2.4): a person's or robot's body starts just above the highest line on its side, as src/c4/c4.js does
+  const sp = sidePorts(g), lift = new Map();
+  g.nodes.forEach(n => { const p = (n.sh === 'person' || n.sh === 'robot') && sp.get(n), t = p ? Math.min(p.L, p.R) : Infinity; if (t < n.y + 14) lift.set(n, { ...n, portTop: t }); });
+  const out = lift.size ? { nodes: g.nodes.map(n => lift.get(n) || n), byId: Object.fromEntries(g.nodes.map(n => [n.id, lift.get(n) || n])),
+    edges: g.edges.map(e => (lift.has(e.s) || lift.has(e.t) ? { ...e, s: lift.get(e.s) || e.s, t: lift.get(e.t) || e.t } : e)) } : {};
+  const els = [...new Map(nodes.filter(n => n.shape === 'c4').map(n => [`${n.type} ${n.sh} ${n.ext}`, n])).values()];
+  const legend = [...els.map(n => vItem(`${n.ext ? 'External ' + C4_WORD[n.type].toLowerCase() : C4_WORD[n.type]}${n.sh !== 'box' && !(n.sh === 'person' && n.type === 'c4.Person') ? ', ' + n.sh : ''}`,
+    n.ext ? 'outside the system, drawn grey' : `a ${C4_WORD[n.type].toLowerCase()}`, vSwatch(n.ext))), ...vLines(edges, 'a step, numbered in time order, with its technology in brackets')];
+  return { ...g, ...out, legend, order: [...readingOrder(pic), ...edges.map(e => e.id)] };
+}
+function dynProblems(model, view) {
+  if (!V_OBJ(view)) return c4Problems(model, view);
+  const views = V_ARR(model && model.views), vi = views.indexOf(view), at = vi >= 0 ? `views[${vi}]` : 'view', I = c4Index(model), lvl = dynLevel(model, view);
+  const say = (level, rule, path, ids, msg) => ({ level, rule, path, ids: ids.filter(x => x != null), message: `${rule}: ${msg}` }), q = id => JSON.stringify(I.at.has(id) ? vName(I.at.get(id)) : String(id));
+  // the subject's level checked as that static view would be, on a copy of the model whose view says it
+  const as = { ...view, diagram: lvl || 'c4.landscape' }, kind = { 'c4.landscape': 'landscape', 'c4.container': 'container', 'c4.component': 'component' }[as.diagram];
+  const w = (C4_WORD[(I.at.get(view.subject) || {}).type] || 'element').toLowerCase(), out = lvl ? [] : [say('error', 'c4-subject', `${at}.subject`, [view.subject],
+    `its subject ${q(view.subject)} is ${I.at.has(view.subject) ? (/^[aeiou]/.test(w) ? 'an ' : 'a ') + w : 'no element'}: a dynamic view zooms into a software system, a container or nothing`)];
+  out.push(...c4Problems({ ...model, views: views.map(v => (v === view ? as : v)) }, as).map(p => (p.rule === 'c4-level' ? { ...p, message: p.message.replace(`in a ${kind} view`, `in a dynamic view${lvl && view.subject != null ? ' of ' + q(view.subject) : ''}`) } : p)));
+  // its steps (§5.1): each a model relationship, each once, between elements the view shows
+  const pic = c4Pic(model, view), ends = new Set(pic.ids.filter(id => !pic.open.has(id))), rel = new Set(I.rels.map(r => r.id)), seen = new Set();
+  V_ARR(view.edges).forEach((x, k) => { const p = `${at}.edges[${k}]`;
+    if (V_OBJ(x) && x.type === 'c4.Relationship') return out.push(say('error', 'c4-steps', p, [x.id], `step ${x.id} is written in the view: a step names a relationship of the model`));
+    if (V_OBJ(x)) return out.push(say('error', 'c4-steps', p, [typeof x.id === 'string' ? x.id : null], `step ${JSON.stringify(typeof x.id === 'string' ? x.id : null)} is written in the view and is no relationship: a step names a relationship of the model`));
+    if (typeof x !== 'string' || !(rel.has(x) || I.E.some(e => e.id === x && e.type === 'uml.CommentLink'))) return out.push(say('error', 'c4-steps', p, [String(x)], `step ${JSON.stringify(String(x))} is no relationship of the model`));
+    if (!rel.has(x)) return null;
+    if (seen.has(x)) return out.push(say('error', 'c4-steps', p, [x], `${x} is a step twice: each relationship is one step`));
+    seen.add(x); const e = I.E.find(r => r.id === x), gone = [e.from, e.to].filter(id => !ends.has(id));
+    if (gone.length) out.push(say('warning', 'c4-steps', p, [x, ...gone], `${x}, from ${q(e.from)} to ${q(e.to)}, is not drawn: the view ${gone.map(id => (pic.open.has(id) ? `draws ${q(id)} as a boundary` : `does not show ${q(id)}`)).join(' or ')}`)); return null; });
+  if (!V_ARR(view.edges).some(x => typeof x === 'string' && rel.has(x))) out.push(say('warning', 'c4-steps', `${at}.edges`, [], `view ${JSON.stringify(String(view.id))} lists no step: a dynamic view draws its steps alone`));
+  return out;
+}
+function dynDescribe(model, viewId) {
+  const v = V_ARR(model && model.views).find(x => V_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const { steps, pic } = dynDrawn(model, v), box = new Map(c4Pic(model, v).boxes.map(b => [b.id, b]));
+  return [`${v.title || v.id}: a C4 dynamic diagram of ${vPlural(pic.ids.length, 'element')} and ${vPlural(steps.length, 'step')}.`,
+    ...readingOrder(pic).map(id => (box.has(id) ? box.get(id).aria : c4NodeName(pic.at.get(id)))), ...steps.map(({ e, k }) => dynName(e, k, pic))].map(t => t.replace(/\.?$/, '.')).join('\n');
+}
+/* moveTo(model, view, id, at): a step one place earlier or later (Alt + arrows, { by }), or to { index } in view.edges. A
+   card, or a line dropped where there is no slot: null, the canvas's own */
+function dynMoveTo(model, view, id, at) {
+  if (!V_OBJ(view) || !V_OBJ(at)) return null;
+  const steps = dynSteps(model, view), k = steps.findIndex(s => s.e.id === id);
+  if (k < 0) return null;
+  if (Number.isInteger(at.index)) return at.index === steps[k].i ? [] : [{ op: 'move', id, view: view.id, index: at.index }];
+  if (!Array.isArray(at.by)) return null;
+  const to = k + Math.sign((+at.by[0] || 0) + (+at.by[1] || 0));
+  return to < 0 || to >= steps.length || to === k ? [] : [{ op: 'move', id, view: view.id, index: steps[to].i }];
+}
+// connect: a relationship between two shown elements is a step: the model's own when one joins them and is not a step yet,
+// else a new one (the canvas's add, which lists it last)
+function dynConnect(model, view, from, to, at, line) {
+  if (!V_OBJ(view) || (V_OBJ(line) && line.type !== 'c4.Relationship')) return null;
+  const listed = V_ARR(view.edges), r = c4Index(model).rels.find(e => e.from === from && e.to === to && !listed.includes(e.id));
+  return r ? [{ op: 'set', view: view.id, path: 'edges', value: [...listed, r.id] }] : null;
+}
+// rename: F2 on a step holds its text, "description [technology]": the technology when unchanged, and a number typed before it
+// ("3." or "3 ·"), are not the description; what is left is set as its label. Anything else: null, the canvas's own
+function dynRename(model, view, id, text) {
+  const s = dynSteps(model, view).find(x => x.e.id === id); if (!s) return null;
+  const tech = V_P(s.e).technology, t = String(text).trim().replace(new RegExp(`^${s.k}\\s*[.·]\\s*`), '');
+  const label = V_HAS(tech) && t.endsWith(`[${tech}]`) ? t.slice(0, -tech.length - 2).trim() : t;
+  return label === (s.e.label ?? '') ? [] : [{ op: 'set', id, path: 'label', value: label || undefined }];
+}
+// add: a container or component added at the view's level (its subject's, §5.1) is owned by the subject, as on that static view
+const dynAdd = (model, view, entry, label) => (V_OBJ(view) ? C4_DEF.edits.add(model, { ...view, diagram: dynLevel(model, view) }, entry, label) : null);
+const DYN_DEF = { ...C4_DEF,
+  title: 'C4 dynamic diagram',
+  layout: dynGeo,
+  validate: dynProblems,
+  rules: V_RULES,
+  describe: dynDescribe,
+  // the PDF's lines table: a step's number before its text, as drawn
+  text: (model, view, id) => { const t = C4_DEF.text(model, view, id), s = dynSteps(model, view).find(x => x.e.id === id); return s ? [String(s.k), t].filter(V_HAS).join(' · ') : t; },
+  edits: { ...C4_DEF.edits, add: dynAdd, connect: dynConnect, moveTo: dynMoveTo, rename: dynRename },
+};
+
+/* ---- the deployment view (§7.5.3) ---- */
+const depTag = x => `[Deployment Node${V_HAS(V_P(x).technology) ? ': ' + V_P(x).technology : ''}]`;
+const depOf = (I, x) => { const c = I.at.get(V_P(x).container); return c && c.type === 'c4.Container' ? c : null; };
+// "Deployment node Web server, Ubuntu 24.04 LTS: The web tier's server"; "Instance of container Shop API, Python, FastAPI: …"
+function depNodeName(I, x) {
+  if (x.type === 'c4.DeploymentNode') { const P = V_P(x); return `Deployment node ${vName(x)}${V_HAS(P.technology) ? ', ' + P.technology : ''}${V_HAS(P.description) ? ': ' + P.description : ''}`; }
+  if (x.type === 'c4.ContainerInstance') { const c = depOf(I, x), s = c ? c4NodeName(c) : `container ${vName(x)}, of no container`; return 'Instance of ' + s[0].toLowerCase() + s.slice(1); }
+  return c4NodeName(x);
+}
+// a deployment node holding something: a solid box, its name over "[Deployment Node: technology]" in a header as tall as the
+// deployment type's (head 15 px more), so the layout measures the title at 12 px and the box is as wide as it
+const V_HEAD = 15;
+SHAPE['c4-node'] = { frame: f => { const line = (t, dy, wt, px, fill) => `<text class="family-title" x="${r2(f.x + 12)}" y="${r2(f.y + dy)}" fill="${fill}" style="font:${wt} ${px}px var(--um-sans)" data-t="ft" data-o="${esc(f.id)}">${esc(fit(t, px, f.w - 24))}</text>`;
+  return `<rect class="family-box" x="${f.x}" y="${f.y}" width="${f.w}" height="${f.h}" rx="6" fill="none" stroke="var(--um-muted)" stroke-width="1.4"/>`
+    + (f.kw ? line(f.name, 17, 600, 12, 'var(--um-text)') + line(f.kw, 17 + V_HEAD, 400, 11, 'var(--um-muted)') : line(f.title ?? f.label ?? f.id, 17, 600, 12, 'var(--um-text)')); } };
+const DEP_LOOK = { boxTypes: ['c4.DeploymentNode'], qualify: false, shape: () => 'c4-node', word: () => 'Deployment node' };
+function depPic(model, view) {
+  const pic = ownersOn(model, view, DEP_LOOK), I = c4Index(model);
+  const boxes = pic.boxes.map(b => { const x = pic.at.get(b.id), held = pic.holds(b.id).map(id => pic.at.get(id)), k = new Map();
+    held.forEach(y => { const w = (C4_WORD[y.type] || 'element').toLowerCase(); k.set(w, (k.get(w) || 0) + 1); });
+    return { ...b, title: `${vName(x)} ${depTag(x)}`, name: vName(x), kw: depTag(x), head: V_HEAD, aria: `Deployment node ${vName(x)}${V_HAS(V_P(x).technology) ? ', ' + V_P(x).technology : ''}, a box holding ${[...k].map(([w, c]) => vPlural(c, w)).join(', ')}` }; });
+  return { ...pic, I, boxes };
+}
+// the key: a deployment node, each instance's look (as its container's), the relationship and the implied line
+function depLegend(nodes, edges, boxes) {
+  const els = [...new Map(nodes.filter(n => n.type === 'c4.ContainerInstance').map(n => [`${n.sh} ${n.ext}`, n])).values()];
+  return [...(boxes.length || nodes.some(n => n.type === 'c4.DeploymentNode') ? [vItem('Deployment node', 'a host, runtime or device; it holds what runs on it', '<rect x="3" y="2" width="22" height="12" rx="3" fill="none" stroke="var(--um-muted)" stroke-width="1.4"/>')] : []),
+    ...els.map(n => vItem(`Container instance${n.sh !== 'box' ? ', ' + n.sh : ''}${n.ext ? ', external' : ''}`, 'a container deployed here, drawn as its container', vSwatch(n.ext))), ...vLines(edges)];
+}
+function depGeo({ model, view, pos, memo }) {
+  const pic = depPic(model, view), I = pic.I, { own, implied } = c4Lines(model, view, pic), P = id => (V_OBJ(pos) && Object.hasOwn(pos, id) ? pos[id] : [0, 0]);
+  const nodes = pic.ids.filter(id => !pic.open.has(id)).map(id => { const x = pic.at.get(id), base = { id, type: x.type, col: P(id)[0], row: P(id)[1], aria: depNodeName(I, x) };
+    if (x.type === 'uml.Comment') { const d = { ...base, label: vName(x), kind: 'file', shape: 'note' }; return { ...d, ...SHAPE.note.size(d) }; }
+    // an instance as its container; a deployment node holding nothing shown as the map's node; anything else (c4-level's error) as itself
+    const c = x.type === 'c4.ContainerInstance' ? depOf(I, x) || x : x, dn = x.type === 'c4.DeploymentNode', ext = !dn && c4Ext(c);
+    const d = { ...base, label: vName(c), kind: ext ? 'external' : 'frontend', shape: 'c4', sh: dn ? 'node' : c4Shape(c), ext, tag: dn ? depTag(x) : c === x && x.type === 'c4.ContainerInstance' ? '[Container]' : c4TagOf(c), desc: V_P(dn ? x : c).description };
+    return { ...d, ...SHAPE.c4.size(d) }; });
+  const edges = [...own.map(e => { const note = e.type === 'uml.CommentLink', label = note ? '' : c4LineLabel(e);
+    return { id: e.id, _id: e.id, type: e.type, from: e.from, to: e.to, label: label || undefined, end: note ? V_LINE.note : V_LINE.rel, aria: c4LineName(e, pic), cut: 280 }; }),
+  ...implied.map(e => ({ id: e.id, _id: e.id, type: 'c4.Relationship', from: e.from, to: e.to, implied: e.of.map(r => r.id), end: V_LINE.implied, aria: c4LineName(e, pic), cut: 280,
+    label: [e.of[0].label, e.of.length > 1 ? `[+${e.of.length - 1}]` : ''].filter(V_HAS).join(' ') || undefined }))];
+  const g = layoutTyped({ nodes, edges, ...(pic.boxes.length ? { containers: pic.boxes } : {}), direction: view.direction === 'down' ? 'down' : 'right',
+    gap: 48, rgap: 64, labelGaps: true, repair: false, reroute: false }, memo);
+  return { ...g, legend: depLegend(nodes, edges, pic.boxes), order: [...readingOrder(pic), ...edges.map(e => e.id)] };
+}
+function depProblems(model, view) {
+  const out = c4Problems(model, view); if (!V_OBJ(view)) return out;
+  const views = V_ARR(model && model.views), vi = views.indexOf(view), at = vi >= 0 ? `views[${vi}]` : 'view', I = c4Index(model);
+  const say = (level, rule, path, ids, msg) => out.push({ level, rule, path, ids: ids.filter(x => x != null), message: `${rule}: ${msg}` }), q = id => JSON.stringify(I.at.has(id) ? vName(I.at.get(id)) : String(id));
+  const kind = id => (C4_WORD[(I.at.get(id) || {}).type] || 'nothing').toLowerCase(), a = w => (/^[aeiou]/.test(w) ? 'an ' : 'a ') + w, subj = I.at.get(view.subject);
+  if (view.subject != null && (!subj || subj.type !== 'c4.SoftwareSystem')) say('error', 'c4-subject', `${at}.subject`, [view.subject], `its subject ${q(view.subject)} is ${a(kind(view.subject))}: a deployment view is of a software system or of all`);
+  V_ARR(view.nodeIds).forEach((id, k) => { const x = I.at.get(id); if (!x || x.type === 'uml.Comment') return;
+    if (x.type !== 'c4.DeploymentNode' && x.type !== 'c4.ContainerInstance') return say('error', 'c4-level', `${at}.nodeIds[${k}]`, [id], `${q(id)}, ${a(kind(id))}, is not drawn in a deployment view`);
+    const c = x.type === 'c4.ContainerInstance' && depOf(I, x);
+    if (c && subj && subj.type === 'c4.SoftwareSystem' && !I.chain(c.id).includes(subj.id))
+      say('error', 'c4-level', `${at}.nodeIds[${k}]`, [id, c.id], `${q(id)}, an instance of ${q(c.id)}, is not drawn in a deployment view of ${q(subj.id)}: ${q(c.id)} is not one of its containers`); });
+  c4Lines(model, view, depPic(model, view)).own.forEach(e => { if (e.type !== 'c4.Relationship' || V_HAS(e.label)) return;
+    const i = V_ARR(model.edges).indexOf(e); say('warning', 'c4-label', `${i >= 0 ? `edges[${i}]` : `${at}.edges[${V_ARR(view.edges).indexOf(e)}]`}.label`, [e.id, e.from, e.to], `${e.id}, from ${q(e.from)} to ${q(e.to)}, has no description`); });
+  // a relationship whose end is, or lies in, a node drawn as a box: a line ends on an element, so it is not drawn (§5.2 lifts onto
+  // a node holding nothing shown only)
+  const dp = depPic(model, view), near = id => { for (const x of [id, ...I.chain(id)]) if (dp.ids.includes(x)) return x; return null; };
+  I.rels.forEach(r => { const a = near(r.from), b = near(r.to); if (a == null || b == null || a === b || I.chain(a).includes(b) || I.chain(b).includes(a)) return;
+    const box = [a, b].filter(x => dp.open.has(x)); if (!box.length) return;
+    const i = V_ARR(model.edges).indexOf(r); say('warning', 'c4-box-line', i >= 0 ? `edges[${i}]` : `${at}.edges`, [r.id, ...box], `${r.id}, from ${q(r.from)} to ${q(r.to)}, is not drawn: the view draws ${box.map(q).join(' and ')} as a box, which no line ends on`); });
+  if (!V_HAS(view.title)) say('warning', 'c4-title', `${at}.title`, [], `view ${JSON.stringify(view.id)} has no title`);
+  return out;
+}
+function depDescribe(model, viewId) {
+  const v = V_ARR(model && model.views).find(x => V_OBJ(x) && x.id === viewId); if (!v) throw new Error(`umlimator: no view ${JSON.stringify(viewId)}`);
+  const pic = depPic(model, v), { own, implied } = c4Lines(model, v, pic), box = new Map(pic.boxes.map(b => [b.id, b]));
+  return [`${v.title || v.id}: a C4 deployment diagram of ${vPlural(pic.ids.length, 'element')} and ${vPlural(own.length + implied.length, 'relationship')}${implied.length ? `, ${implied.length} of them implied` : ''}.`,
+    ...readingOrder(pic).map(id => (box.has(id) ? box.get(id).aria : depNodeName(pic.I, pic.at.get(id)))), ...[...own, ...implied].map(e => c4LineName(e, pic))].map(t => t.replace(/\.?$/, '.')).join('\n');
+}
+// the palette's instance: its container picked, put in the view's first deployment node that holds no other (the Owner field
+// or a drop into a box moves it). ponytail: the add hook hears no selection on a layered view (no slots), so not "the node selected"
+function depAdd(model, view, entry, label) {
+  if (!V_OBJ(entry) || entry.type !== 'c4.ContainerInstance') return null;
+  const I = c4Index(model), cs = [...I.at.values()].filter(n => n.type === 'c4.Container'), ids = V_ARR(view.nodeIds).filter(id => (I.at.get(id) || {}).type === 'c4.DeploymentNode');
+  const into = ids.find(id => !ids.some(o => (I.at.get(o) || {}).parent === id));
+  if (into == null) return { error: 'Add a deployment node first: an instance runs on one' };
+  if (!cs.length) return { error: 'The model has no container to deploy' };
+  const used = vUsed(model);
+  return { pick: cs.map(vName), then: i => { const c = cs[i], b = `${c.id}-instance`; let id = b, k = 2; while (used.has(id)) id = `${b}-${k++}`;
+    return [{ op: 'add', element: { id, type: 'c4.ContainerInstance', label: V_HAS(label) ? label : vName(c), parent: into, props: { container: c.id } }, view: view.id }]; } };
+}
+// T on an instance: its container, picked among the model's; else as on a static view (T, D)
+function depKey(model, view, ids, key) {
+  const I = c4Index(model), x = I.at.get(ids.at(-1));
+  if (!(key === 't' || key === 'T') || !x || x.type !== 'c4.ContainerInstance') return c4Key(model, view, ids, key);
+  const cs = [...I.at.values()].filter(n => n.type === 'c4.Container');
+  return { pick: cs.map(vName), then: i => (cs[i].id === V_P(x).container ? [] : [{ op: 'set', id: x.id, path: 'props.container', value: cs[i].id }]) };
+}
+// the Owner field: an instance's and a deployment node's deployment nodes
+function depOwners(model, x) {
+  if (!V_OBJ(x) || x.from != null || (x.type !== 'c4.ContainerInstance' && x.type !== 'c4.DeploymentNode')) return c4Owners(model, x);
+  const I = c4Index(model); // not the node itself nor a node inside it (the core refuses a cycle)
+  return V_ARR(model.nodes).filter(n => V_OBJ(n) && n.type === 'c4.DeploymentNode' && n.id !== x.id && !I.chain(n.id).includes(x.id)).map(n => ({ id: n.id, label: vName(n) }));
+}
+const DEP_DEF = {
+  title: 'C4 deployment diagram',
+  elements: [{ type: 'c4.DeploymentNode', label: 'Deployment node' }, { type: 'c4.ContainerInstance', label: 'Container instance', name: false }, { type: 'uml.Comment', label: 'Comment' }],
+  lines: C4_DEF.lines,
+  props: { 'c4.DeploymentNode': [{ key: 'description', label: 'Description', kind: 'text' }, { key: 'technology', label: 'Technology', kind: 'text' }],
+    'c4.ContainerInstance': [{ key: 'container', label: 'Container (id; T picks it)', kind: 'text' }], 'c4.Relationship': C4_DEF.props['c4.Relationship'], 'uml.CommentLink': [] },
+  layout: depGeo,
+  boxes: (model, view) => depPic(model, view).boxes,
+  owners: depOwners,
+  validate: depProblems,
+  rules: DEP_RULES,
+  describe: depDescribe,
+  // a deleted container takes its instances (§3, Q7); read for every view, whichever type declares it
+  refs: { 'c4.ContainerInstance': { 'props.container': 'cascade' } },
+  word: C4_DEF.word,
+  rows: (model, view, id) => { const I = c4Index(model), x = I.at.get(id); if (!x) return null; const P = V_P(x);
+    if (x.type === 'c4.DeploymentNode') return [...(V_HAS(P.technology) ? [P.technology] : []), ...(V_HAS(P.description) ? [P.description] : [])];
+    if (x.type !== 'c4.ContainerInstance') return C4_DEF.rows(model, view, id);
+    const c = depOf(I, x); return [`Instance of ${c ? vName(c) : 'no container'}`, ...(c ? C4_DEF.rows(model, view, c.id) : [])]; },
+  text: C4_DEF.text,
+  edits: { add: depAdd, key: depKey },
+};
+
+const C4_VIEW_TYPES = [registerDiagramType('c4.dynamic', DYN_DEF), registerDiagramType('c4.deployment', DEP_DEF)];
+/* ---------- Mermaid erDiagram: a reader and a writer (notes/milestone-2.md §8.1, M2.8; risks.md R1 to R4, R7) ----------
+   Written against Mermaid 12.3.0's entity relationship page (docs/syntax/entityRelationshipDiagram.md, read 14 Nov 2026)
+   and its lexer (packages/mermaid/src/diagrams/er/parser/erDiagram.jison), as the other readers are against theirs.
+   Internal: the CLI (`umlimator.py import`) imports this file through Node (M2.12); a host gets it once the registry is
+   public. Its helpers are its own (me...), since the readers share one scope in lib/umlimator-all.js.
+
+   readMermaidEr(text) -> { model, report }: a version-2 model with one `er` view, in model.md row 20'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 ME_LIMIT characters (R2). Ids come from the source's
+   names (R3): an entity's name is its id, a column is <entity>.<name>, a relationship <from>-<to>, each the next free of
+   base, base-2, base-3 ... (an id holds no "->": a name with one has it as "-"). `%% id: <id>` above a statement or a
+   column gives that element its id instead, and above `erDiagram` the view's; `%% references: <column id>` above a
+   column sets its `references`, which Mermaid's text has no place for. Every lookup table is keyed by Map or has no
+   prototype, so `__proto__` and `constructor` are ordinary names. It never throws.
+
+   writeMermaidEr(model, viewId?) -> text: one er view as Mermaid. What Mermaid cannot carry is kept in its comments, as
+   the other writers do: an id the reader would not derive, as `%% id:` (an entity whose id Mermaid cannot write as a
+   name is written as `entity`, `entity-2` ... under its `%% id:`), a column's `references` as `%% references:`; an element
+   the subset leaves out as `%% not written: <id> (<type>)`, and a property Mermaid has no place for as
+   `%% not written: <id>: <what>` (a multiplicity other than the four, written as the nearest; the notation idef1x, as
+   Mermaid draws crow's foot). A column is written only when the reader reads its row back as it is.
+
+   How ER maps onto Mermaid's text, both ways:
+   - `NAME`, `"a name"`, `NAME[Alias]`, `NAME["An alias"]` an entity, its label the alias, else its name; `NAME { ... }`
+     its columns, each `type name [PK, FK, UK] ["comment"]`: a type ending `?` is nullable (v11.16.0+), a name starting
+     `*` a primary key, either in backticks taken as written; the comment kept under ext.mermaid.comment (reported once);
+   - `A ||--o{ B : label` a relationship from A to B, each end's marker its multiplicity there, on either side: `||` 1,
+     `|o` `o|` 0..1, `}|` `|{` 1..*, `}o` `o{` 0..*, and the word forms (`only one`, `one or more`, `many(0)`, `1+`, ...);
+     `--` and `to` identifying, `..` `.-` `-.` and `optionally to` not; Mermaid's `u` (a parent marker its page does not
+     show) approximated as 1. Mermaid says nothing of which column a foreign key references: `references` is left out,
+     reported once (the ER type's fk-flag warns of each);
+   - `direction TB` (Mermaid's default) is down, `LR` right (left unset: core's default, so a view's `right` reads back
+     unset, drawn the same); BT and RL approximated; subgraphs are not read, the entities in them are, and a
+     relationship with a subgraph is skipped; styles, classes and accessibility text are skipped. */
+const ME_LIMIT = 1 << 20; // characters; an ER diagram a person writes is a few kilobytes
+const ME_VIEW = 'er-diagram'; // the view's id when the source does not name it
+const meTable = o => Object.assign(Object.create(null), o); // a lookup table: "constructor" or "__proto__" finds nothing in it
+// each end's marker, both sides' forms, and the word forms (Mermaid's lexer reads any of them on either side)
+const ME_MULT = meTable({ '|o': '0..1', 'o|': '0..1', '||': '1', '}o': '0..*', 'o{': '0..*', '}|': '1..*', '|{': '1..*', 'zero or more': '0..*',
+  'zero or many': '0..*', 'zero or one': '0..1', 'one or zero': '0..1', 'one or more': '1..*', 'one or many': '1..*', 'only one': '1',
+  'many(0)': '0..*', 'many(1)': '1..*', many: '0..*', one: '1', '0+': '0..*', '1+': '1..*', 1: '1', u: '1' });
+const ME_CARD = /(\|o|o\||\|\||\}o|o\{|\}\||\|\{)|(zero or (?:more|many|one)|one or (?:zero|more|many)|only one|many\([01]\)|many|one)(?!\w)|([01]\+)|(1)(?![\w.])|(u)(?=[.|-])/iy;
+const ME_REL = /(--|\.\.|\.-|-\.)|(optionally to|to)(?!\w)/iy;
+const ME_SYM = meTable({ 1: ['||', '||'], '0..1': ['|o', 'o|'], '0..*': ['}o', 'o{'], '1..*': ['}|', '|{'] }); // the writer's marker, left and right
+const ME_NAME = /(?:[^\x00-\x7F]|[\w.*-])+/y; // a name not in quotes (the lexer's UNICODE_TEXT)
+const ME_WORD = /[*A-Za-z_\u00C0-\uFFFF][A-Za-z0-9\-_[\]().,\u00C0-\uFFFF*]*/y; // a column's type or name (ATTRIBUTE_WORD)
+const ME_KEY = /(?:PK|FK|UK)\b/iy;
+// a statement's first word that Mermaid's lexer takes as a keyword: the writer writes no name that starts with one
+const ME_KEYWORDS = new Set(['one', 'many', 'to', 'end', 'class', 'classdef', 'style', 'subgraph', 'erdiagram']);
+const ME_DIRECTION = /direction\s+(TB|BT|RL|LR)/gi; // the lexer takes any line holding this as a direction statement
+const meId = name => String(name).replace(/->+/g, '-'); // an id never holds "->" (model.md rule 5)
+const meSkip = (s, k) => { while (k < s.length && (s[k] === ' ' || s[k] === '\t')) k++; return k; };
+const meAt = (re, s, k) => { re.lastIndex = k; const m = re.exec(s); return m; };
+const meShort = s => (s.length > 60 ? s.slice(0, 57) + '...' : s);
+
+// the first of base, base-2, base-3 ... not in used, resuming where the last ask for base stopped (R2)
+function meFree(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;
+}
+
+// text: Mermaid's line breaks and entity codes (#quot; #lt; #35;)
+function meDecode(s) {
+  return s.replace(/<br\s?\/?>/gi, '\n').replace(/#(quot|lt|gt|amp|\d{1,6});/g, (_, e) =>
+    ({ quot: '"', lt: '<', gt: '>', amp: '&' })[e] ?? String.fromCodePoint(Math.min(Number(e), 0x10ffff)));
+}
+// the writer's text in quotes: what would end the quotes, start a comment or an entity code, or make the line a direction
+// statement, as entity codes, which Mermaid draws as the characters and the reader decodes
+function meEncode(s) {
+  return String(s).replace(/[#"%\\<>~]|[\x00-\x09\x0b-\x1f]/g, c => (c === '"' ? '#quot;' : c === '<' ? '#lt;' : c === '>' ? '#gt;' : `#${c.codePointAt(0)};`))
+    .replace(/\n/g, '<br>').replace(/(direction)(\s+)(?=TB|BT|RL|LR)/gi, (_, d, w) => d + [...w].map(c => `#${c.codePointAt(0)};`).join(''));
+}
+// a name the writer writes as it is, or in quotes; else it needs an %% id:
+const meBare = id => /^[A-Za-z_\u0080-\uFFFF](?:[^\x00-\x7F]|[\w.*-])*$/.test(id) && !ME_KEYWORDS.has(/^\w*/.exec(id)[0].toLowerCase()) && !/^u[.-]/i.test(id);
+const meQuoted = id => /^[^"%\r\n\v\x08\\]+$/.test(id) && !/direction\s+(TB|BT|RL|LR)/i.test(id);
+
+// a name at k: "in quotes" (not empty), or the lexer's UNICODE_TEXT: { text, end }
+function meName(s, k) {
+  if (s[k] === '"') { const e = s.indexOf('"', k + 1); return e > k + 1 ? { text: s.slice(k + 1, e), end: e + 1 } : null; }
+  const m = meAt(ME_NAME, s, k);
+  return m ? { text: m[0], end: k + m[0].length } : null;
+}
+
+// a column block's attributes from k, as Mermaid's lexer reads them in its block state: { cols, end, closed, bad }, each
+// col { type, nullable, name, keys, comment, at }; bad is where an attribute that is not one starts
+function meRow(s, k, tilde = s.lastIndexOf('~')) {
+  const cols = [];
+  let nt = -2, nw = -2; // the next ~ and the next whitespace at or after k, found once each as k moves on (linear)
+  const nextTilde = () => { if (nt < k && nt !== -1) nt = s.indexOf('~', k); return nt; };
+  const nextWs = () => { if (nw < k) { nw = k; while (nw < s.length && !/\s/.test(s[nw])) nw++; } return nw; };
+  const ws = () => { while (k < s.length && /\s/.test(s[k])) k++; };
+  const isKey = () => (k === 0 || !/\w/.test(s[k - 1])) && !!meAt(ME_KEY, s, k);
+  const word = () => {
+    if (isKey()) return null;
+    const t = tilde > k ? nextTilde() : -1; // ([^\s]*)~.*~([^\s]*): a ~ in this run and another after it on the line
+    if (t >= 0 && t < nextWs() && tilde > t) { let e = tilde + 1; while (e < s.length && !/\s/.test(s[e])) e++; const w = s.slice(k, e); k = e; return { text: w }; }
+    if (s[k] === '`') { const e = s.indexOf('`', k + 1); if (e <= k + 1) return null; const w = s.slice(k + 1, e); k = e + 1; return { text: w, quoted: true }; }
+    const m = meAt(ME_WORD, s, k); if (!m) return null;
+    k += m[0].length;
+    return { text: m[0] };
+  };
+  for (;;) {
+    ws();
+    if (k >= s.length) return { cols, end: k, closed: false };
+    if (s[k] === '}') return { cols, end: k + 1, closed: true };
+    const at = k, type = word();
+    if (!type) return { cols, end: k, closed: false, bad: at };
+    ws();
+    let nullable = false;
+    if (s[k] === '?') { nullable = true; k++; ws(); }
+    const name = word();
+    if (!name) return { cols, end: k, closed: false, bad: at };
+    const keys = [];
+    for (ws(); isKey(); ws()) {
+      keys.push(s.slice(k, k + 2).toUpperCase()); k += 2; ws();
+      if (s[k] !== ',') break;
+      k++; ws();
+      if (!isKey()) return { cols, end: k, closed: false, bad: at };
+    }
+    let comment;
+    if (s[k] === '"') { const e = s.indexOf('"', k + 1); if (e < 0) return { cols, end: k, closed: false, bad: at }; comment = s.slice(k + 1, e); k = e + 1; }
+    cols.push({ type, nullable, name, keys, comment, at });
+  }
+}
+
+// a row as the model has it: its label, its props, its comment
+function meColumn(c) {
+  const star = !c.name.quoted && c.name.text.length > 1 && c.name.text[0] === '*', props = { dataType: c.type.text };
+  if (star || c.keys.includes('PK')) props.primaryKey = true;
+  if (c.keys.includes('FK')) props.foreignKey = true;
+  if (c.keys.includes('UK')) props.unique = true;
+  if (c.nullable) props.nullable = true;
+  return { label: star ? c.name.text.slice(1) : c.name.text, props, ...(c.comment !== undefined ? { comment: meDecode(c.comment) } : {}) };
+}
+
+function readMermaidEr(text) {
+  const report = [], say = (line, status, message) => report.push({ line, status, message });
+  const empty = () => ({ model: { schemaVersion: 2, root: ME_VIEW, nodes: [], edges: [], views: [{ id: ME_VIEW, diagram: 'er', nodeIds: [] }] }, report });
+  if (typeof text !== 'string') { say(1, 'skipped', 'the input is not text: nothing read'); return empty(); }
+  if (text.length > ME_LIMIT) { say(1, 'skipped', `the input is ${text.length} characters, over the limit of ${ME_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().replace(/^\uFEFF/, '') === '---') {
+    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 ents = new Map(), seen = [], rels = [], groups = new Set(), once = new Set();
+  let viewId, viewNo, direction = 'down', started = false, hint = {}, acc = false, depth = 0, block = null;
+  const ent = (name, no) => { let r = ents.get(name); if (!r) { r = { name, no, cols: [], names: new Set() }; ents.set(name, r); seen.push(r); } return r; };
+  const column = (rec, c, no) => {
+    const col = meColumn(c), h = hint;
+    hint = {};
+    if (rec.names.has(col.label)) { say(no, 'skipped', `${rec.name}.${col.label}: ${rec.name} has a column ${col.label} already`); return; }
+    rec.names.add(col.label);
+    if (h.references !== undefined) col.props.references = h.references;
+    rec.cols.push({ ...col, hint: h.id, no });
+    if (col.comment !== undefined && !once.has('comment')) { once.add('comment'); say(no, 'approximated', `${rec.name}.${col.label}: a column's comment is kept under ext.mermaid.comment and not drawn, as every other column's`); }
+    if (col.props.foreignKey && h.references === undefined && !once.has('fk')) { once.add('fk'); say(no, 'approximated', `${rec.name}.${col.label}: Mermaid does not say which column a foreign key references, so references is left out, as for every other (fk-flag warns of each)`); }
+  };
+  // :::a,b after a name: styling, skipped
+  const styled = (s, k, name, no) => {
+    if (!s.startsWith(':::', k)) return k;
+    let e = k + 3; while (e < s.length && !/[\s{[:]/.test(s[e])) e++;
+    say(no, 'skipped', `${s.slice(k, e)} on ${name}: styling is not read`);
+    return meSkip(s, e);
+  };
+
+  // one statement from k on line s (dir: where the line's last direction statement starts, or -1): where reading goes on
+  const statement = (s, k, no, dir) => {
+    const st = meSkip(s, k);
+    if (st >= s.length) return s.length;
+    const notRead = () => { say(no, 'skipped', `"${meShort(s.slice(st).trim())}" is not understood`); return s.length; };
+    if (dir >= st) {
+      const d = meAt(/direction\s+(TB|BT|RL|LR)/iy, s, dir)[1].toUpperCase();
+      if (depth) say(no, 'skipped', `direction ${d} inside a subgraph is not kept: the view has one direction`);
+      else if (d === 'TB') direction = 'down';
+      else if (d === 'LR') direction = 'right';
+      else { direction = d === 'BT' ? 'down' : 'right'; say(no, 'approximated', `direction ${d} is drawn ${direction === 'down' ? 'top to bottom' : 'left to right'}`); }
+      return s.length;
+    }
+    const kw = meAt(/(classDef|class|style|subgraph|end)\b|(accTitle)\s*:|(accDescr)\s*([:{])/iy, s, st);
+    if (kw) {
+      const w = (kw[1] || kw[2] || kw[3]).toLowerCase();
+      if (w === 'subgraph') {
+        const n = meName(s, meSkip(s, st + 8));
+        if (!n) return notRead();
+        groups.add(n.text); depth++;
+        say(no, 'skipped', `subgraph ${n.text}: a group is not read; the entities in it are`);
+      } else if (w === 'end') { if (depth) depth--; else say(no, 'skipped', 'an end that closes no subgraph'); }
+      else if (w === 'acctitle' || w === 'accdescr') {
+        say(no, 'skipped', `${kw[2] || kw[3]}: accessibility text is not read`);
+        if (kw[4] === '{' && !s.includes('}', st)) acc = true;
+      } else say(no, 'skipped', `${kw[1]}: styling is not read`);
+      return s.length;
+    }
+    const a = meName(s, st);
+    if (!a) return notRead();
+    let k2 = styled(s, meSkip(s, a.end), a.text, no);
+    const card = meAt(ME_CARD, s, k2);
+    if (!card) { // an entity: its alias, its classes, its block
+      const rec = ent(a.text, no);
+      rec.declared = true;
+      if (hint.id !== undefined && rec.hint === undefined) { rec.hint = hint.id; rec.hintNo = no; }
+      hint = {};
+      if (s[k2] === '[') {
+        const q = meSkip(s, k2 + 1), n = s[q] === '"' ? meName(s, q) : null, e = n ? meSkip(s, n.end) : s.indexOf(']', q);
+        if (e < 0 || s[e] !== ']' || (!n && !s.slice(q, e).trim())) return notRead();
+        const alias = meDecode(n ? n.text : s.slice(q, e).trim());
+        if (rec.label === undefined) rec.label = alias;
+        else if (rec.label !== alias) say(no, 'skipped', `${a.text}[${alias}]: ${a.text} has an alias already`);
+        k2 = styled(s, meSkip(s, e + 1), a.text, no);
+      }
+      if (s[k2] === '{') { block = rec; return k2 + 1; }
+      return k2 < s.length ? notRead() : s.length;
+    }
+    // a relationship: A card rel card B [: label]
+    const end = m => k2 + m[0].length, mult = m => ME_MULT[m[0].toLowerCase()];
+    k2 = meSkip(s, end(card));
+    const rel = meAt(ME_REL, s, k2);
+    if (!rel) return notRead();
+    k2 = meSkip(s, end(rel));
+    const card2 = meAt(ME_CARD, s, k2);
+    if (!card2) return notRead();
+    k2 = meSkip(s, end(card2));
+    const b = meName(s, k2);
+    if (!b) return notRead();
+    k2 = styled(s, meSkip(s, b.end), b.text, no);
+    let label;
+    if (s[k2] === ':') { const t = s.slice(k2 + 1).trim(), q = /^"([^"]*)"$/.exec(t); label = meDecode(q ? q[1] : t); }
+    else if (k2 < s.length) return notRead();
+    else say(no, 'approximated', `${a.text} ${card[0]}${rel[0]}${card2[0]} ${b.text}: no : label, which Mermaid asks for, so it has none`);
+    if (card[5] || card2[5]) say(no, 'approximated', `${a.text} ${card[0]}${rel[0]}${card2[0]} ${b.text}: u, a parent marker Mermaid's page does not show, is read as 1`);
+    ent(a.text, no); ent(b.text, no);
+    rels.push({ a: a.text, b: b.text, from: mult(card), to: mult(card2), identifying: rel[1] ? rel[1] === '--' : /^to$/i.test(rel[2]), label, no, hint: hint.id });
+    hint = {};
+    return s.length;
+  };
+
+  for (; i < lines.length; i++) {
+    const no = i + 1, s = lines[i], t = s.trim();
+    if (!t) continue;
+    if (acc) { if (t.includes('}')) acc = false; continue; }
+    if (t.startsWith('%%')) {
+      const c = t.slice(2).trim();
+      if (c.startsWith('{')) {
+        say(no, 'skipped', 'a %%{init}%% directive: Mermaid\'s configuration is not read');
+        if (!t.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(); hint.no = no; }
+      else if (c.startsWith('references:')) hint.references = c.slice(11).trim();
+      continue;
+    }
+    if (!started) {
+      if (!/^\uFEFF?erDiagram$/i.test(t)) { say(no, 'skipped', 'not a Mermaid erDiagram: nothing read'); return empty(); }
+      started = true; viewId = hint.id; viewNo = hint.no; hint = {}; continue;
+    }
+    const tilde = s.lastIndexOf('~');
+    let dir = -1;
+    if (!block) for (const m of s.matchAll(ME_DIRECTION)) dir = m.index;
+    for (let k = 0; k < s.length;) {
+      if (!block) { k = statement(s, k, no, dir); continue; }
+      const r = meRow(s, k, tilde);
+      for (const c of r.cols) column(block, c, no);
+      if (r.bad !== undefined) {
+        const e = s.indexOf('}', r.end);
+        say(no, 'skipped', `"${meShort(s.slice(r.bad, e < 0 ? s.length : e).trim())}" in ${block.name}'s block is not a column`);
+        if (e >= 0) block = null;
+        k = e < 0 ? s.length : e + 1;
+      } else { k = r.end; if (r.closed) block = null; }
+    }
+    hint = {};
+  }
+  if (!started) { say(1, 'skipped', 'not a Mermaid erDiagram: nothing read'); return empty(); }
+  if (block) say(lines.length, 'approximated', `${block.name}'s { is never closed: read to the end`);
+  if (depth) say(lines.length, 'approximated', `${depth} subgraph${depth > 1 ? 's are' : ' is'} never closed with end: read to the end`);
+
+  // ids: an entity's hint or name, then the next free of it, each reported; then columns and relationships in the order
+  // they come, made unique, a hint that is taken or holds -> reported
+  const used = new Set(), next = new Map(), list = seen.filter(r => r.declared || !groups.has(r.name));
+  for (const r of list) { const want = r.hint ?? r.name; if (meId(want) === want && !used.has(want)) { r.id = want; used.add(want); } }
+  for (const r of list) if (r.id === undefined) {
+    const want = r.hint ?? r.name;
+    r.id = meFree(used, next, meId(want)); used.add(r.id);
+    say(r.hintNo ?? r.no, 'approximated', r.hint !== undefined ? `%% id: ${want}${meId(want) !== want ? ': an id holds no "->"' : ' is taken'}, so entity ${r.name} is ${r.id}`
+      : `entity ${r.name}${meId(want) !== want ? ': an id holds no "->"' : "'s name is another's id"}, so it is ${r.id}`);
+  }
+  const take = (h, base, no, what) => {
+    const id = meFree(used, next, meId(h ?? base));
+    used.add(id);
+    if (h !== undefined && id !== h) say(no, 'approximated', `%% id: ${h}${meId(h) !== h ? ': an id holds no "->"' : ' is taken'}, so ${what} is ${id}`);
+    return id;
+  };
+  const nodes = list.map(r => {
+    const members = r.cols.map(c => ({ id: take(c.hint, `${r.id}.${c.label}`, c.no, `${r.name}.${c.label}`), type: 'er.Column', label: c.label, props: c.props,
+      ...(c.comment !== undefined ? { ext: { mermaid: { comment: c.comment } } } : {}) }));
+    return { id: r.id, type: 'er.Entity', label: r.label ?? r.name, ...(members.length ? { members } : {}) };
+  });
+  const byName = new Map(list.map(r => [r.name, r.id])), edges = [];
+  for (const r of rels) {
+    const g = [r.a, r.b].find(x => !byName.has(x));
+    if (g !== undefined) { say(r.no, 'skipped', `${r.a} -- ${r.b}: ${g} is a subgraph, and a relationship with a group is not read`); continue; }
+    const from = byName.get(r.a), to = byName.get(r.b);
+    edges.push({ id: take(r.hint, `${from}-${to}`, r.no, `${r.a} -- ${r.b}`), type: 'er.Relationship', from, to, ...(r.label ? { label: r.label } : {}),
+      props: { identifying: r.identifying, ends: { from: { multiplicity: r.from }, to: { multiplicity: r.to } } } });
+  }
+  let vid = viewId || ME_VIEW;
+  if (meId(vid) !== vid) { say(viewNo, 'approximated', `%% id: ${vid}: an id holds no "->", so the view is ${meId(vid)}`); vid = meId(vid); }
+  const view = { id: vid, diagram: 'er', ...(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, views: [view] }, report };
+}
+
+function writeMermaidEr(model, viewId) {
+  const m = model && typeof model === 'object' ? model : {}, arr = x => (Array.isArray(x) ? x : []), isObj = x => !!x && typeof x === 'object';
+  const has = x => x != null && x !== '', 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 === 'er');
+  // a model with views is written through its er 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 er view\n';
+  if (view && view.diagram !== 'er') return `%% not written: view ${flat(view.id)}, a ${flat(view.diagram)} view, not an er one\n`;
+  const byId = new Map(arr(m.nodes).filter(isObj).map(n => [n.id, n]));
+  const out = [], notWritten = [], skip = x => notWritten.push(`${flat(x.id)} (${flat(x.type)})`), lose = (id, what) => notWritten.push(`${flat(id)}: ${flat(what)}`);
+  const once = (seen, id) => { if (!seen.has(id)) return seen.add(id); lose(id, 'listed twice in the view, written once'); return false; };
+  const shownSet = new Set(), shown = (view ? arr(view.nodeIds) : [...byId.keys()]).filter(id => byId.has(id) && once(shownSet, id));
+  // an id the reader keeps as it is: a string of one line, trimmed (as a hint is read), with no ->
+  const keeps = id => typeof id === 'string' && id !== '' && !nl(id) && id.trim() === id && meId(id) === id;
+  const derives = id => typeof id === 'string' && id !== '' && !nl(id) && meId(id) === id; // an id the reader may derive, needing no hint
+  // the keys and props Mermaid has a place for; any other is named
+  const extra = (x, keys, props = []) => {
+    for (const k of Object.keys(x)) if (!keys.includes(k)) {
+      if (k === 'props' && isObj(x.props)) { for (const p of Object.keys(x.props)) if (!props.includes(p)) lose(x.id, `property ${p}`); }
+      else lose(x.id, k);
+    }
+  };
+  const title = view && has(view.title) ? view.title : m.title;
+  // as it is only when YAML reads it as text: a letter first, and not one of YAML's null or boolean words
+  const plain = t => /^\p{L}[\p{L}\p{N} _.,()-]*$/u.test(t) && !t.endsWith(' ') && !/^(null|true|false|yes|no|on|off|y|n)$/i.test(t);
+  if (has(title)) out.push('---', `title: ${plain(title) ? title : JSON.stringify(String(title))}`, '---');
+  if (view && view.id !== ME_VIEW) { if (keeps(view.id)) out.push(`%% id: ${view.id}`); else lose(view.id, "the view's id, which the reader would not keep"); }
+  out.push('erDiagram', view && view.direction === 'down' ? '  direction TB' : '  direction LR');
+  if (view && has(view.notation) && view.notation !== 'crowsfoot') lose(view.id, `notation ${view.notation}: Mermaid draws crow's foot`);
+
+  // entities: a name Mermaid writes as it is or in quotes is the id; another id is an %% id: over a name the writer makes
+  const ents = shown.map(id => byId.get(id)).filter(n => {
+    const ok = n.type === 'er.Entity' && typeof n.id === 'string' && n.id !== '' && !nl(n.id) && meId(n.id) === n.id && (meBare(n.id) || meQuoted(n.id) || n.id.trim() === n.id);
+    if (!ok) skip(n);
+    return ok;
+  });
+  const names = new Map(), taken = new Set(ents.filter(n => meBare(n.id) || meQuoted(n.id)).map(n => n.id)), made = new Map();
+  for (const n of ents) {
+    if (meBare(n.id)) names.set(n.id, [n.id, false]);
+    else if (meQuoted(n.id)) names.set(n.id, [`"${n.id}"`, false]);
+    else { const w = meFree(taken, made, 'entity'); taken.add(w); names.set(n.id, [w, true]); }
+  }
+  const used = new Set(ents.map(n => n.id)), next = new Map();
+  // the hint, if one is needed: null when the reader derives the id, undefined when it would need one it cannot keep
+  const idOf = (id, base) => { const d = meFree(used, next, meId(base)); if (d !== id && !keeps(id)) return undefined; used.add(id); return d === id ? null : id; };
+  for (const n of ents) {
+    const [name, hinted] = names.get(n.id);
+    extra(n, ['id', 'type', 'label', 'members']);
+    let alias = '';
+    if (typeof n.label === 'string' && n.label !== '') { if (hinted || n.label !== n.id) alias = `["${meEncode(n.label)}"]`; }
+    else lose(n.id, n.label === '' ? 'an empty label, read as its name' : n.label == null ? 'no label, read as its name' : `label ${n.label}, which is not text`);
+    const rows = [], labels = new Set();
+    for (const x of arr(n.members).filter(isObj)) {
+      const p = isObj(x.props) ? x.props : {}, ext = isObj(x.ext) ? x.ext : {}, me = isObj(ext.mermaid) ? ext.mermaid : {};
+      if (x.type !== 'er.Column' || !derives(x.id) || typeof x.label !== 'string' || !x.label || typeof p.dataType !== 'string' || !p.dataType || labels.has(x.label)) { skip(x); continue; }
+      const comment = typeof me.comment === 'string' ? me.comment : undefined;
+      const keys = [p.primaryKey === true && 'PK', p.foreignKey === true && 'FK', p.unique === true && 'UK'].filter(Boolean);
+      const want = JSON.stringify(Object.entries({ dataType: p.dataType, ...Object.fromEntries(['primaryKey', 'foreignKey', 'unique', 'nullable'].filter(f => p[f] === true).map(f => [f, true])) }).sort());
+      // the type and the name as they are, else in backticks (and a ? apart, which a generic type's word would take in):
+      // the first row the reader reads back as the column is written
+      // (a row is one line: a type or name in backticks holding a line break would be read as two)
+      const row = [[0, 0, ''], [1, 0, ''], [0, 1, ''], [1, 1, ''], [0, 0, ' '], [0, 1, ' ']].map(([q, r, sp]) => `${q ? '`' + p.dataType + '`' : p.dataType}${p.nullable === true ? sp + '?' : ''} ${r ? '`' + x.label + '`' : x.label}${keys.length ? ' ' + keys.join(', ') : ''}${comment !== undefined ? ` "${meEncode(comment)}"` : ''}`).find(row => {
+        if (nl(row)) return false;
+        const r = meRow(row, 0), c = r.cols.length === 1 && r.bad === undefined && r.end === row.length ? meColumn(r.cols[0]) : null;
+        return c && c.label === x.label && c.comment === comment && JSON.stringify(Object.entries(c.props).sort()) === want;
+      });
+      const hint = row ? idOf(x.id, `${n.id}.${x.label}`) : undefined;
+      if (hint === undefined) { skip(x); continue; }
+      labels.add(x.label);
+      extra(x, ['id', 'type', 'label', 'ext'], ['dataType', 'primaryKey', 'foreignKey', 'unique', 'nullable', 'references']);
+      for (const f of ['primaryKey', 'foreignKey', 'unique', 'nullable']) if (p[f] !== undefined && p[f] !== true) lose(x.id, `${f} ${p[f]}, read as absent`);
+      if (Object.keys(ext).some(k => k !== 'mermaid') || Object.keys(me).some(k => k !== 'comment') || (me.comment !== undefined && comment === undefined)) lose(x.id, 'ext, but for ext.mermaid.comment');
+      let ref = null;
+      if (p.references !== undefined) { if (keeps(p.references)) ref = p.references; else lose(x.id, `references ${p.references}, which the reader would not keep`); }
+      rows.push([hint, ref, row]);
+    }
+    if (hinted) out.push(`  %% id: ${n.id}`);
+    if (!rows.length) { out.push(`  ${name}${alias}`); continue; }
+    out.push(`  ${name}${alias} {`);
+    for (const [hint, ref, row] of rows) out.push(...(hint ? [`    %% id: ${hint}`] : []), ...(ref ? [`    %% references: ${ref}`] : []), `    ${row}`);
+    out.push('  }');
+  }
+
+  const edgeOf = e => (typeof e === 'string' ? arr(m.edges).find(x => isObj(x) && x.id === e) : e);
+  const lines = (view && Array.isArray(view.edges) ? view.edges.map(edgeOf) : arr(m.edges).filter(e => isObj(e) && shownSet.has(e.from) && shownSet.has(e.to))).filter(isObj);
+  const seenEdges = new Set();
+  for (const e of lines) {
+    if (view && Array.isArray(view.edges) && !once(seenEdges, e.id)) continue;
+    const hint = e.type === 'er.Relationship' && derives(e.id) && names.has(e.from) && names.has(e.to) ? idOf(e.id, `${e.from}-${e.to}`) : undefined;
+    if (hint === undefined) { skip(e); continue; }
+    const p = isObj(e.props) ? e.props : {}, ends = isObj(p.ends) ? p.ends : {};
+    extra(e, ['id', 'type', 'from', 'to', 'label'], ['identifying', 'ends']);
+    // each end's marker: one of the four, else the nearest by its bounds (0 or 1 below; 1 or many above), named
+    const mark = (w, side) => {
+      const end = isObj(ends[w]) ? ends[w] : {}, mult = end.multiplicity;
+      for (const k of Object.keys(end)) if (k !== 'multiplicity') lose(e.id, `${k} at its ${w} end`);
+      if (typeof mult === 'string' && ME_SYM[mult]) return ME_SYM[mult][side];
+      const b = /^\s*(\d+|\*)\s*(?:\.\.\s*(\d+|\*)\s*)?$/.exec(typeof mult === 'string' ? mult : ''), lo = b && (b[1] === '*' ? 0 : +b[1]), hi = b && (b[2] ?? b[1]);
+      const near = !b ? '1' : (lo === 0 ? '0' : '1') + (hi === '*' || +hi > 1 ? '..*' : lo === 0 ? '..1' : '');
+      lose(e.id, `multiplicity ${mult ?? 'none'} at its ${w} end, written as ${near}`);
+      return ME_SYM[near][side];
+    };
+    const left = mark('from', 0), right = mark('to', 1);
+    if (typeof p.identifying !== 'boolean') lose(e.id, `identifying ${p.identifying ?? 'unset'}, written as non-identifying`);
+    if (e.label === '' || (e.label != null && typeof e.label !== 'string')) lose(e.id, e.label === '' ? 'an empty label, read as none' : `label ${e.label}, which is not text`);
+    const label = typeof e.label === 'string' ? meEncode(e.label) : '';
+    out.push(...(hint ? [`  %% id: ${hint}`] : []), `  ${names.get(e.from)[0]} ${left}${p.identifying === true ? '--' : '..'}${right} ${names.get(e.to)[0]} : "${label}"`);
+  }
+  for (const x of notWritten) out.push(`  %% not written: ${x}`);
+  return out.join('\n') + '\n';
+}
+/* ---------- Mermaid flowchart: a reader and a writer (notes/milestone-2.md §8, §8.2, M2.9; risks.md R1 to R4, R7) ----------
+   Written against Mermaid 12.3.0's flowchart page (docs/syntax/flowchart.md) and its shapes' names and aliases
+   (rendering-elements/shapes.ts), both read on Mermaid's repository 14 Nov 2026, and ported from the map
+   importer's grammar (`flowchart()` in umlimator_import.py): node groups with &, links with their text in pipes or inline,
+   subgraphs, statements split by ; outside quotes. On the file of every construct (tests/import/flowchart.mmd) it reads
+   every node and link the importer reads, with the same ids; it reads more (Mermaid's @{ shape: ... } form and edge ids),
+   and keeps each node's shape as its flowchart type. Internal: the CLI imports it through Node (M2.12); its helpers are
+   its own (mf...), since the readers share one scope in lib/umlimator-all.js.
+
+   readMermaidFlowchart(text) -> { model, report }: a version-2 model with one `flowchart` view, in model.md row 21's
+   vocabulary, and a report of what was not read as written, each item { line, status, message }, status `skipped` or
+   `approximated` (R1). Hand-written and linear; text over MF_LIMIT characters is refused, and links past MF_FLOWS are not
+   read (R2). Ids come from the source's names (R3): a node is its Mermaid id, a link its edge id (`A e1@--> B`), else
+   <from>-<to>, the next free of base, base-2, base-3 ... `%% id: <id>` above a statement gives its first link that id, or,
+   when it has no link, its first node; above the header, the view. It never throws.
+
+   writeMermaidFlowchart(model, viewId?) -> text: one flowchart view as Mermaid: each node declared on its own line, then
+   each flow, its label quoted in pipes. An id Mermaid cannot carry as a name is written as a name made of it with
+   `%% id:` above, as is a flow's id the reader would not derive; an element or property the subset leaves out is named in
+   `%% not written:` lines (a comment: Mermaid's flowchart has no note).
+
+   How the flowchart's symbols map onto Mermaid's shapes, both ways (§8.2): ([ ]) a terminator, [ ] a process, { } a
+   decision, [/ /] and [\ \] input/output, [[ ]] a predefined process, [( )] a database, (( )) a connector; doc,
+   manual-input and delay by @{ shape: ... } only, with the aliases Mermaid's page lists. Mermaid's other shapes are read
+   as processes, approximated. A link is a flow; one with no arrowhead, dotted, thick, or with a circle or cross end is
+   approximated, <-->, o--o and x--x are two flows, ~~~ is not read. A subgraph's nodes are read, the group is not (row 21 has none). */
+const MF_LIMIT = 1 << 20; // characters; a flowchart a person writes is a few kilobytes
+const MF_FLOWS = 100000; // the most links read: a & b & ... --> c & d & ... makes the product of its groups (R2)
+const MF_VIEW = 'flowchart'; // the view's id when the source does not name it, as the importer's
+const mfTable = o => Object.assign(Object.create(null), o); // a lookup table: "constructor" or "__proto__" finds nothing in it
+// the bracket forms, longest first, as the importer's SHAPES: open, close, type (null: a process, approximated) and what Mermaid calls it
+const MF_BRACKETS = [['(((', ')))', null, 'a double circle'], ['([', '])', 'flow.Terminator'], ['[[', ']]', 'flow.PredefinedProcess'], ['[(', ')]', 'flow.Database'],
+  ['((', '))', 'flow.Connector'], ['{{', '}}', null, 'a hexagon'], ['[/', '/]', 'flow.InputOutput'], ['[/', '\\]', null, 'a trapezoid'], ['[\\', '\\]', 'flow.InputOutput'],
+  ['[\\', '/]', null, 'an upside-down trapezoid'], ['[', ']', 'flow.Process'], ['(', ')', null, 'a rounded box'], ['{', '}', 'flow.Decision'], ['>', ']', null, 'an asymmetric shape']];
+// @{ shape: ... }: the names and aliases in Mermaid's shapes.ts of the shapes a flowchart symbol has; any other is a process, approximated
+const MF_SHAPES = mfTable({
+  stadium: 'flow.Terminator', terminal: 'flow.Terminator', pill: 'flow.Terminator',
+  rect: 'flow.Process', rectangle: 'flow.Process', proc: 'flow.Process', process: 'flow.Process',
+  diam: 'flow.Decision', diamond: 'flow.Decision', decision: 'flow.Decision', question: 'flow.Decision',
+  'lean-r': 'flow.InputOutput', 'lean-right': 'flow.InputOutput', 'in-out': 'flow.InputOutput', 'lean-l': 'flow.InputOutput', 'lean-left': 'flow.InputOutput', 'out-in': 'flow.InputOutput',
+  subproc: 'flow.PredefinedProcess', subprocess: 'flow.PredefinedProcess', subroutine: 'flow.PredefinedProcess', 'fr-rect': 'flow.PredefinedProcess', 'framed-rectangle': 'flow.PredefinedProcess',
+  doc: 'flow.Document', document: 'flow.Document',
+  cyl: 'flow.Database', cylinder: 'flow.Database', database: 'flow.Database', db: 'flow.Database',
+  'manual-input': 'flow.ManualInput', 'sl-rect': 'flow.ManualInput', 'sloped-rectangle': 'flow.ManualInput',
+  delay: 'flow.Delay', 'half-rounded-rectangle': 'flow.Delay',
+  circle: 'flow.Connector', circ: 'flow.Connector' });
+// what the writer writes for each type: a bracket form, or a shape name for the three the brackets lack
+const MF_WRITE = mfTable({ 'flow.Terminator': ['([', '])'], 'flow.Process': ['[', ']'], 'flow.Decision': ['{', '}'], 'flow.InputOutput': ['[/', '/]'], 'flow.PredefinedProcess': ['[[', ']]'],
+  'flow.Database': ['[(', ')]'], 'flow.Connector': ['((', '))'], 'flow.Document': 'doc', 'flow.ManualInput': 'manual-input', 'flow.Delay': 'delay' });
+const MF_NODE = /\s*([\p{L}\p{N}_$]+(?:[.-][\p{L}\p{N}_$]+)*)/uy; // a node's id, as the importer's NODE (Python's \w)
+const MF_NAME = /^[\p{L}\p{N}_$]+(?:[.-][\p{L}\p{N}_$]+)*$/u;
+const MF_PLAIN = /\s*([<ox]?(?:-{2,}[->ox]|={2,}[=>ox]|-?\.+-[>ox]?|~{3,}))/y; // a link with no text in it
+const MF_OPEN = /\s*([<ox]?(?:--|==|-\.))\s*/y; // a link's start, its text after it (-- text -->)
+const MF_PIPE = /\s*(?:\|("[^"]*"|[^|]*)\|)?/y; // a quoted text may hold |
+const MF_EDGE_ID = /\s*([^\s"@&|]+)@(?=[^{"])/y; // A e1@--> B
+// statements Mermaid reads and this reader does not; the importer passes over the same words (FLOW_QUIET)
+const MF_QUIET = /^(classDef|class|style|linkStyle|click|direction|accTitle|accDescr)(?![\p{L}\p{N}_])/u;
+const MF_WORDS = /^(end|subgraph|graph|flowchart|classDef|class|style|linkStyle|click|direction|accTitle|accDescr|default|call|href)(?![\p{L}\p{N}_])/u; // no name the writer gives starts so
+const mfId = s => String(s).replace(/->+/g, '-'); // an id never holds "->" (model.md rule 5)
+const mfClip = s => (s.length > 60 ? s.slice(0, 57) + '...' : s);
+
+function mfFree(used, next, base) { // the first of base, base-2, ... not in used, resuming where the last ask stopped (R2)
+  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;
+}
+
+// text: quotes and a Markdown string's backticks taken off (as the importer's text()), Mermaid's <br> and entity codes read
+function mfText(raw, md) {
+  let s = raw.trim();
+  if (s.length > 1 && s[0] === '"' && s.at(-1) === '"') {
+    s = s.slice(1, -1);
+    if (s.length > 1 && s[0] === '`' && s.at(-1) === '`') { s = s.slice(1, -1); md?.(); }
+  }
+  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 a link's close (-->, ==>, .->, ---) ends when it starts at p, else -1: -{2,}[->ox], ={2,}[=>ox] or \.+-[>ox]?, greedy
+function mfCloseAt(s, p) {
+  const c = s[p];
+  let q = p;
+  while (s[q] === c) q++;
+  if (c === '.') return s[q] !== '-' ? -1 : q + 1 + (q + 1 < s.length && '>ox'.includes(s[q + 1]) ? 1 : 0);
+  if (c !== '-' && c !== '=') return -1;
+  if (q - p >= 2 && q < s.length && '>ox'.includes(s[q])) return q + 1;
+  return q - p >= 3 ? q : -1;
+}
+// a link at i: { arrow, text, pipe, end }, or null. The importer's LINK, with its text's close found by one scan: the
+// first close after the text, and no | before it ([^|]+? then \s* then the close)
+function mfLink(s, i) {
+  MF_PLAIN.lastIndex = i;
+  let m = MF_PLAIN.exec(s), arrow, text, j;
+  if (m) { arrow = m[1]; j = MF_PLAIN.lastIndex; } else {
+    MF_OPEN.lastIndex = i;
+    if (!(m = MF_OPEN.exec(s))) return null;
+    const a = MF_OPEN.lastIndex, from = m.index + m[0].trimEnd().length; // the text starts at a; it may start in the spaces before
+    let at = -1, end = -1;
+    for (let p = a + 1; p < s.length && s[p] !== '|';) {
+      end = mfCloseAt(s, p);
+      if (end >= 0) { at = p; break; }
+      const c = s[p];
+      if (c === '-' || c === '=' || c === '.') while (s[p] === c) p++; else p++; // no close starts inside a run that fails
+    }
+    if (at < 0 && a > from && s[a] !== '|' && (end = mfCloseAt(s, a)) >= 0) at = a; // text of spaces only
+    if (at < 0) return null;
+    text = s.slice(a, at); arrow = m[1] + s.slice(at, end); j = end;
+  }
+  MF_PIPE.lastIndex = j;
+  const p = MF_PIPE.exec(s);
+  return { arrow, text, pipe: p[1], end: MF_PIPE.lastIndex, raw: s.slice(i, MF_PIPE.lastIndex).trim() };
+}
+
+// @{ key: value, ... } at i (the @ itself): its fields and where it ends, or null when it is not closed
+function mfFields(s, i) {
+  const out = new Map();
+  let k = i + 2, key = '', val = '', inKey = true, q = null, quoted = false;
+  const put = () => { if (key.trim()) out.set(key.trim(), quoted ? val : val.trim()); key = ''; val = ''; inKey = true; quoted = false; };
+  for (; k < s.length; k++) {
+    const c = s[k];
+    if (q) { if (c === '\\' && k + 1 < s.length) val += s[++k]; else if (c === q) q = null; else val += c; continue; }
+    if (c === '}') { put(); return { fields: out, end: k + 1 }; }
+    if (inKey) { if (c === ':') inKey = false; else if (c === ',') put(); else key += c; continue; }
+    if (c === ',') put();
+    else if ((c === '"' || c === "'") && !val.trim()) { q = c; quoted = true; val = ''; } else val += c;
+  }
+  return null;
+}
+
+// a node at i: { id, label, type, odd, fields, cls, end }, or null (the importer's fnode, with @{ } read too). find is
+// the statement's indexOf, which remembers where each string was not found, so unclosed brackets cost one scan (R2)
+function mfNode(s, i, find) {
+  MF_NODE.lastIndex = i;
+  const n = MF_NODE.exec(s);
+  if (!n) return null;
+  const out = { id: n[1], end: MF_NODE.lastIndex };
+  i = out.end;
+  for (const [o, c, type, odd] of MF_BRACKETS) {
+    if (!s.startsWith(o, i)) continue;
+    const q = s[i + o.length] === '"' ? find('"', i + o.length + 1) : -1;
+    const k = find(c, q >= 0 ? q + 1 : i + o.length);
+    if (k > 0) { out.label = s.slice(i + o.length, k); out.type = type || 'flow.Process'; out.odd = type ? null : odd; i = k + c.length; break; }
+  }
+  if (out.label === undefined && s.startsWith('@{', i)) {
+    const f = mfFields(s, i);
+    if (f) { out.fields = f.fields; i = f.end; }
+  }
+  if (s.startsWith(':::', i)) {
+    let k = i + 3;
+    while (k < s.length && /[\p{L}\p{N}_-]/u.test(s[k])) k++;
+    if (k > i + 3) { out.cls = s.slice(i + 3, k); i = k; }
+  }
+  out.end = i;
+  return out;
+}
+
+// node groups (a & b) joined by links, or null: the importer's statement()
+function mfStatement(s) {
+  const groups = [], links = [], miss = new Map();
+  const find = (c, from) => {
+    if (from >= (miss.get(c) ?? Infinity)) return -1;
+    const k = s.indexOf(c, from);
+    if (k < 0) miss.set(c, from);
+    return k;
+  };
+  let i = 0;
+  for (;;) {
+    const grp = [];
+    for (let n; (n = mfNode(s, i, find));) {
+      grp.push(n); i = n.end;
+      const amp = /\s*&/y; amp.lastIndex = i;
+      if (!amp.exec(s)) break;
+      i = amp.lastIndex;
+    }
+    if (!grp.length) return null;
+    groups.push(grp);
+    if (!s.slice(i).trim()) return { groups, links };
+    MF_EDGE_ID.lastIndex = i;
+    const eid = MF_EDGE_ID.exec(s), lk = mfLink(s, eid ? MF_EDGE_ID.lastIndex : i);
+    if (!lk) return null;
+    if (eid) lk.id = eid[1];
+    links.push(lk); i = lk.end;
+  }
+}
 
+// ; outside quotes ends a statement, as the importer splits a line
+function mfSplit(line) {
+  const out = [];
+  let from = 0, q = false;
+  for (let k = 0; k < line.length; k++) {
+    if (line[k] === '"') q = !q;
+    else if (line[k] === ';' && !q) { out.push(line.slice(from, k)); from = k + 1; }
+  }
+  out.push(line.slice(from));
+  return out.map(x => x.trim());
+}
 
+function readMermaidFlowchart(text) {
+  const report = [], say = (line, status, message) => report.push({ line, status, message });
+  const empty = () => ({ model: { schemaVersion: 2, root: MF_VIEW, nodes: [], edges: [], views: [{ id: MF_VIEW, diagram: 'flowchart', direction: 'down', nodeIds: [] }] }, report });
+  if (typeof text !== 'string') { say(1, 'skipped', 'the input is not text: nothing read'); return empty(); }
+  if (text.length > MF_LIMIT) { say(1, 'skipped', `the input is ${text.length} characters, over the limit of ${MF_LIMIT}: nothing read`); return empty(); }
+  const lines = text.replace(/^/, '').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 nodes = new Map(), links = [], subs = [], closed = new Set(), edgeIds = new Set();
+  let viewId, direction = 'down', started = false, hint = null, hintNo = 0, block = false, flows = 0, over = false;
+  const statement = (s, no) => {
+    if (!s) return;
+    const sg = /^subgraph\s+(?:([^\s["]+)\s*\[([^\]]*)\]|"(.+)"|(\S+)$|(.+))/.exec(s);
+    if (sg) { // its id as the importer's ident(): the name when it is plain, else a slug of its title
+      const label = mfText(sg[2] ?? sg[3] ?? sg[4] ?? sg[5]), raw = (sg[1] ?? sg[4] ?? label).trim();
+      subs.push({ id: /^[\p{L}\p{N}_.-]+$/u.test(raw) ? raw : raw.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'x', no });
+      say(no, 'skipped', `subgraph ${subs.at(-1).id}: the group is not read, the nodes in it are`);
+      return;
+    }
+    if (s === 'end') { if (subs.length) closed.add(subs.pop().id); else say(no, 'skipped', 'an end that closes no subgraph'); return; }
+    const quiet = MF_QUIET.exec(s);
+    if (quiet) {
+      const w = quiet[1];
+      if (w === 'direction') {
+        const d = s.slice(9).trim().toUpperCase();
+        if (subs.length) say(no, 'approximated', `direction ${d} inside a subgraph is not kept: the view has one direction`);
+        else say(no, 'skipped', `direction ${d} outside a subgraph is not read: the header gives the view's direction`);
+      } else if (w === 'accTitle' || w === 'accDescr') {
+        say(no, 'skipped', `${w}: accessibility text is not read`);
+        if (w === 'accDescr' && /^accDescr\s*\{/.test(s) && !s.includes('}')) block = true;
+      } else say(no, 'skipped', `${mfClip(s)}: styles and interaction are not read`);
+      return;
+    }
+    const p = mfStatement(s);
+    if (!p) { say(no, 'skipped', `not read: ${mfClip(s)}`); return; }
+    if (p.groups.length === 1 && p.groups[0].length === 1 && edgeIds.has(p.groups[0][0].id) && p.groups[0][0].fields) { // e1@{ animate: true }
+      say(no, 'skipped', `${p.groups[0][0].id}@{ ... }: a link's animation is not read`);
+      return;
+    }
+    for (const n of p.groups.flat()) {
+      let rec = nodes.get(n.id);
+      if (!rec) { rec = { name: n.id, no, label: n.id, type: 'flow.Process' }; nodes.set(n.id, rec); }
+      if (hint != null && !p.links.length && rec.hint === undefined) { rec.hint = hint; rec.hintNo = no; hint = null; }
+      if (n.cls) say(no, 'skipped', `${n.id}:::${n.cls}: a style class is not read`);
+      if (n.label !== undefined) {
+        rec.label = mfText(n.label, () => say(no, 'approximated', `${n.id}: a Markdown string is read as plain text`)); rec.type = n.type;
+        if (n.odd) say(no, 'approximated', `${n.id}: ${n.odd} is read as a process`);
+      } else if (n.fields) {
+        for (const [k, v] of n.fields) {
+          if (k === 'label') rec.label = mfText(v, () => say(no, 'approximated', `${n.id}: a Markdown string is read as plain text`));
+          else if (k === 'shape') {
+            const t = MF_SHAPES[v];
+            rec.type = t || 'flow.Process';
+            if (!t) say(no, 'approximated', `${n.id}: shape ${v} is read as a process`);
+          } else say(no, 'skipped', `${n.id}: ${k} is not read`);
+        }
+      }
+    }
+    p.links.forEach((lk, k) => {
+      const arrow = lk.arrow;
+      if (arrow.startsWith('~')) { say(no, 'skipped', `${p.groups[k].map(n => n.id).join(' & ')} ~~~ ${p.groups[k + 1].map(n => n.id).join(' & ')}: an invisible link is not read`); return; }
+      if (lk.id) edgeIds.add(lk.id);
+      const label = lk.pipe !== undefined ? mfText(lk.pipe) : lk.text !== undefined ? mfText(lk.text) : undefined, head = arrow.at(-1), tail = arrow[0];
+      const two = '<ox'.includes(tail), how = [...(arrow.includes('.') ? ['dotted'] : []), ...(arrow.includes('=') ? ['thick'] : []), ...('>ox'.includes(head) ? [] : ['no arrowhead']),
+        ...(head === 'o' || tail === 'o' ? ['a circle end'] : []), ...(head === 'x' || tail === 'x' ? ['a cross end'] : []), ...(two ? ['an arrowhead at each end'] : [])];
+      for (const a of p.groups[k]) for (const b of p.groups[k + 1]) {
+        if (flows >= MF_FLOWS) { if (!over) { over = true; say(no, 'skipped', `over ${MF_FLOWS} links: the rest are not read`); } return; }
+        flows++;
+        if (how.length) say(no, 'approximated', `${a.id} ${lk.raw} ${b.id}: ${how.join(', ')}: read as ${two ? 'two flows' : 'a flow'}`);
+        links.push({ from: a.id, to: b.id, label, no, hint: hint ?? lk.id, eid: hint == null && lk.id != null }); hint = null;
+        if (two) links.push({ from: b.id, to: a.id, label, no });
+      }
+    });
+  };
+  // a hint applies to the statement directly below it; one that statement does not take is reported, not carried on
+  const unused = () => { if (hint != null) say(hintNo, 'skipped', `%% id: ${hint}: the statement below it takes no id from it`); hint = null; };
 
+  for (; i < lines.length; i++) {
+    const no = i + 1, s = lines[i].trim();
+    if (!s) continue;
+    if (block) { if (s.includes('}')) block = false; 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:')) { unused(); hint = c.slice(3).trim(); hintNo = no; }
+      continue;
+    }
+    if (!started) {
+      const h = /^(flowchart-elk|flowchart|graph)(?![\w-])\s*(TB|TD|BT|RL|LR)?\s*;?/.exec(s);
+      if (!h) { say(no, 'skipped', 'not a Mermaid flowchart: nothing read'); return empty(); }
+      started = true; viewId = hint; hint = null;
+      if (viewId != null && mfId(viewId) !== viewId) { say(no, 'approximated', `%% id: ${viewId}: an id holds no "->", so the view is ${mfId(viewId)}`); viewId = mfId(viewId); }
+      const d = h[2];
+      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'}`); }
+      for (const x of mfSplit(s.slice(h[0].length))) { statement(x, no); unused(); }
+      continue;
+    }
+    for (const x of mfSplit(s)) { statement(x, no); unused(); }
+  }
+  unused();
+  if (!started) { say(1, 'skipped', 'not a Mermaid flowchart: nothing read'); return empty(); }
+  for (const sg of subs) say(sg.no, 'approximated', `subgraph ${sg.id} is never closed: read to the end`);
 
+  // ids: nodes by their names first, a subgraph's id naming none (the importer's box); then the links in order
+  const used = new Set(), next = new Map();
+  const take = (h, base, no, what, how = '%% id:') => {
+    if (h != null && h !== '') {
+      const t = mfId(h);
+      if (t !== h) say(no, 'approximated', `${how} ${h}: an id holds no "->", so it is ${t}`);
+      if (!used.has(t)) { used.add(t); return t; }
+      const id = mfFree(used, next, base); used.add(id);
+      say(no, 'approximated', `${how} ${t} is taken, so ${what} is ${id}`);
+      return id;
+    }
+    const id = mfFree(used, next, base); used.add(id);
+    return id;
+  };
+  const out = [], idOf = new Map();
+  for (const rec of nodes.values()) {
+    if (closed.has(rec.name)) continue;
+    const id = take(rec.hint, rec.name, rec.hintNo ?? rec.no, `node ${rec.name}`);
+    if (rec.hint == null && id !== rec.name) say(rec.no, 'approximated', `node ${rec.name}: its name is another's id, so it is ${id}`);
+    idOf.set(rec.name, id);
+    out.push({ id, type: rec.type, label: rec.label });
+  }
+  const edges = [];
+  for (const l of links) {
+    const bad = [l.from, l.to].find(x => !idOf.has(x));
+    if (bad) { say(l.no, 'skipped', `${l.from} --> ${l.to}: ${bad} is a subgraph, which is not read`); continue; }
+    const from = idOf.get(l.from), to = idOf.get(l.to);
+    const e = { id: take(l.hint, mfId(`${from}-${to}`), l.no, `${l.from} --> ${l.to}`, l.eid ? 'the edge id' : undefined), type: 'flow.Flow', from, to };
+    if (l.label !== undefined) e.label = l.label;
+    edges.push(e);
+  }
+  const view = { id: viewId || MF_VIEW, diagram: 'flowchart', ...(title ? { title } : {}), direction, nodeIds: out.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: out, edges, views: [view] }, report };
+}
 
+function writeMermaidFlowchart(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'), has = x => x != null && x !== '', str = x => typeof x === 'string';
+  const views = arr(m.views).filter(isObj);
+  const view = viewId != null ? views.find(v => v.id === viewId) : views.find(v => v.diagram === 'flowchart');
+  if (viewId != null && !view) return `%% not written: view ${flat(viewId)}, which the model does not have\n`;
+  if (!view) return '%% not written: the model, which has no flowchart view\n';
+  if (view.diagram !== 'flowchart') return `%% not written: view ${flat(view.id)}, a ${flat(view.diagram)} view, not a flowchart one\n`;
+  // text, always quoted: Mermaid's own characters as entity codes, a line break as <br>, a space at either end as an
+  // entity, which the reader's trim keeps; # first, so no other text reads as a code
+  const ent = c => `#${c.codePointAt(0)};`;
+  const enc = s => `"${String(s).replace(/[#"|;<>\\`]/g, ent).replace(/\r\n|\r|\n/g, '<br>').replace(/^\s|\s$/g, ent)}"`;
+  const okId = id => str(id) && id !== '' && id.trim() === id && !/[\r\n]/.test(id); // a hint keeps it
+  const out = [], notWritten = [], skip = x => notWritten.push(`${flat(x.id)} (${flat(x.type)})`), lose = (id, what) => notWritten.push(`${flat(id)}: ${flat(what)}`);
+  const title = String(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(title)}`, '---');
+  if (has(view.id) && view.id !== MF_VIEW) { if (/[\r\n]/.test(view.id)) lose(view.id, "the view's id, which has a line break"); else out.push(`%% id: ${view.id}`); }
+  out.push(`flowchart ${view.direction === 'right' ? 'LR' : 'TD'}`);
 
+  const byId = new Map();
+  for (const n of arr(m.nodes)) if (isObj(n) && !byId.has(n.id)) byId.set(n.id, n);
+  const nodes = [], shown = new Set();
+  for (const id of arr(view.nodeIds)) {
+    const n = byId.get(id);
+    if (!n || shown.has(id)) continue;
+    shown.add(id);
+    if (okId(n.id) && MF_WRITE[n.type]) nodes.push(n); else skip(n);
+  }
+  // names: an id Mermaid and the reader read as one name, else one made of it (and its id as a hint)
+  const safe = id => MF_NAME.test(id) && !MF_WORDS.test(id);
+  const names = new Map(), taken = new Set(nodes.map(n => n.id).filter(safe));
+  for (const n of nodes) {
+    if (safe(n.id)) { names.set(n.id, n.id); continue; }
+    let base = n.id.replace(/[^\p{L}\p{N}_$]+/gu, '_').replace(/^_+|_+$/g, ''), name, k = 1;
+    if (!safe(base)) base = 'N_' + base;
+    for (name = base; taken.has(name); name = `${base}_${++k}`);
+    taken.add(name); names.set(n.id, name);
+  }
+  for (const n of nodes) {
+    const w = MF_WRITE[n.type], name = names.get(n.id);
+    if (!str(n.label)) lose(n.id, has(n.label) ? 'its label, which is not text' : 'no label, read as an empty one');
+    const label = enc(str(n.label) ? n.label : '');
+    out.push(...(name !== n.id ? [`  %% id: ${n.id}`] : []), `  ${name}${typeof w === 'string' ? `@{ shape: ${w}, label: ${label} }` : w[0] + label + w[1]}`);
+    for (const k of Object.keys(n)) if (!['id', 'type', 'label'].includes(k)) lose(n.id, k === 'props' || k === 'ext' ? `its ${k}` : `property ${k}`);
+  }
+  // the flows, each with its id when the reader would derive another (it derives them in this order, after the nodes)
+  const isNode = new Set(nodes.map(n => n.id)), used = new Set(isNode), next = new Map(), seen = new Set();
+  for (const e of arr(m.edges)) {
+    if (!isObj(e) || seen.has(e.id) || !(shown.has(e.from) || shown.has(e.to))) continue;
+    seen.add(e.id);
+    if (e.type !== 'flow.Flow' || !isNode.has(e.from) || !isNode.has(e.to) || !okId(e.id) || used.has(e.id)) { skip(e); continue; }
+    const d = mfFree(used, next, mfId(`${e.from}-${e.to}`));
+    used.add(e.id);
+    if (has(e.label) && !str(e.label)) lose(e.id, 'its label, which is not text');
+    out.push(...(d !== e.id ? [`  %% id: ${e.id}`] : []), `  ${names.get(e.from)} -->${str(e.label) ? `|${enc(e.label)}|` : ''} ${names.get(e.to)}`);
+    for (const k of Object.keys(e)) if (!['id', 'type', 'from', 'to', 'label'].includes(k)) lose(e.id, k === 'props' || k === 'ext' ? `its ${k}` : `property ${k}`);
+  }
+  for (const x of notWritten) out.push(`  %% not written: ${x}`);
+  return out.join('\n') + '\n';
+}
+/* ---------- Structurizr JSON: a reader (notes/milestone-2.md §8.3, M2.10; risks.md R1 to R3) ----------
+   Written against Structurizr's workspace JSON (the workspace's published schema, structurizr/json), as the Structurizr
+   CLI's `export -f json` writes it. Internal: the CLI (`umlimator.py import`) imports this file through Node; a host gets
+   it once the registry is public. Its helpers are its own (sz...), since the readers share one scope in
+   lib/umlimator-all.js. There is no writer (§13).
+
+   readStructurizr(workspace) -> { model, report }: a version-2 model in model.md row 23's vocabulary, typed C4, and a
+   report of what was not read as written, each item { path, status, message }: `path` where in the workspace it is
+   (`model.softwareSystems[0].containers[2]`), status `skipped` or `approximated` (R1). `workspace` is the parsed JSON, or
+   its text (refused over SZ_LIMIT characters). It never throws, and reads at most SZ_MAX elements and SZ_MAX
+   relationships, deployment nodes SZ_DEEP deep (deeper read flat from there), whatever the input (R2). A parsed object
+   may hold one list or string in many places, so every list entry and every character of text read is also counted, each
+   time it is reached, against SZ_WORK and SZ_CHARS: the counts alone would not bound the work. Every table keyed
+   by a name or an id is a Map, so `__proto__` and `constructor` are ordinary names, and the input's fields are read as
+   own properties only.
+
+   - People, software systems, their containers and those containers' components are c4.Person, c4.SoftwareSystem,
+     c4.Container and c4.Component, owned by `parent`; deployment nodes c4.DeploymentNode, nested by `parent`; container
+     instances c4.ContainerInstance, labelled as their container, `props.container` naming it. `description` and
+     `technology` go to props; `location: "External"` or the tag External sets `external`.
+   - Ids (R3): an element's `properties["structurizr.dsl.identifier"]` when the DSL wrote one (and it is not a UUID the DSL
+     made up for an unnamed element), else its name slugged; an instance's `<container>-<instanceId>`; a relationship's
+     identifier, else `<from>-<to>`; each the next free of base, base-2, base-3 ..., identifiers first. Never Structurizr's
+     numeric ids, which change when the workspace is regenerated, so two exports of one DSL file read to one model.
+   - Shapes: as Structurizr finds an element's style, its tags in order, each tag's styles in the order written, a later
+     shape winning over an earlier (views.configuration.styles.elements); the map's shape it names goes to `props.shape`
+     when it is not the type's own (a person's person, the rest's box). A shape the map lacks is a box, approximated.
+   - Views: each kind as its c4 view, its key slugged as id, its `subject` the software system or container it is scoped
+     to, `nodeIds` its elements; a container, component or dynamic view lists its subject, as Structurizr draws it as a
+     boundary;
+     a dynamic view's steps, ordered by `order`, are its `edges`, each relationship once (S13); a deployment view's
+     environment is in its title; a view's automatic layout gives its direction.
+   - Skipped, each reported: implied relationships (`linkedRelationshipId`: the C4 type works them out, §5.2), software
+     system instances, infrastructure nodes and custom elements and their relationships, groups, filtered, custom and
+     image views, perspectives, element properties but the identifier, urls, documentation and decisions, themes,
+     animations, element positions, style fields but an element's shape, relationship styles, a deployment node's shape,
+     an instance's own tags; an asynchronous relationship is drawn as any other (approximated). A static view's own list
+     of relationships is not read: the type draws a view's lines from the model. */
+const SZ_LIMIT = 1 << 20; // characters of JSON text; a parsed object is held to counts instead
+const SZ_MAX = 10000; // the most elements, and the most relationships, read (R2)
+const SZ_DEEP = 64; // deployment nodes nested deeper are read flat from there (R2)
+const SZ_WORK = 500000; // the most list entries walked in all, a shared list counted each time it is reached (R2)
+const SZ_CHARS = 16 * SZ_LIMIT; // the most characters of text read in all, counted the same way (R2)
+const SZ_SHAPE = new Map(Object.entries({ person: 'person', robot: 'robot', webbrowser: 'browser', window: 'window', terminal: 'terminal', shell: 'terminal',
+  mobiledevicelandscape: 'mobile', mobiledeviceportrait: 'mobile', cylinder: 'cylinder', pipe: 'pipe', folder: 'folder', hexagon: 'hexagon', box: 'box', roundedbox: 'box' }));
+// [the workspace's list, the view's diagram, its field naming the subject, the word in a title made for it]
+const SZ_VIEWS = [['systemLandscapeViews', 'c4.landscape', null, 'system landscape'], ['systemContextViews', 'c4.context', 'softwareSystemId', 'system context'],
+  ['containerViews', 'c4.container', 'softwareSystemId', 'containers'], ['componentViews', 'c4.component', 'containerId', 'components'],
+  ['dynamicViews', 'c4.dynamic', 'elementId', 'dynamic'], ['deploymentViews', 'c4.deployment', 'softwareSystemId', 'deployment']];
+const SZ_SUBJECT = { 'c4.context': ['c4.SoftwareSystem'], 'c4.container': ['c4.SoftwareSystem'], 'c4.component': ['c4.Container'], 'c4.dynamic': ['c4.SoftwareSystem', 'c4.Container'], 'c4.deployment': ['c4.SoftwareSystem'] };
+const SZ_ID = 'structurizr.dsl.identifier';
+const szOrder = new Intl.Collator('en', { numeric: true }).compare; // a dynamic view's steps: 2 before 10
+const SZ_UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+const szOwn = (o, k) => (o !== null && typeof o === 'object' && Object.hasOwn(o, k) ? o[k] : undefined);
+const szSlug = s => s.normalize('NFKC').toLowerCase().replace(/[^\p{L}\p{N}_.]+/gu, '-').replace(/^[-.]+|[-.]+$/g, '');
+const szDocumented = x => ['sections', 'decisions'].some(k => { const v = szOwn(szOwn(x, 'documentation'), k); return Array.isArray(v) && v.length > 0; });
+const szKey = x => (typeof x === 'string' || typeof x === 'number' ? String(x) : undefined); // Structurizr's ids are text; a number is read as its text
+
+// the first of base, base-2, base-3 ... not in used, resuming where the last ask for base stopped (R2)
+function szFree(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); used.add(id);
+  return id;
+}
+
+function readStructurizr(workspace) {
+  const report = [], recs = [], rels = [], views = [];
+  try { return szRead(workspace, report, recs, rels, views); } catch { // a getter that throws, a revoked proxy: what a host built
+    report.length = recs.length = rels.length = views.length = 0;
+    report.push({ path: '', status: 'skipped', message: 'the input threw when it was read: nothing read' });
+    return { model: { schemaVersion: 2, root: 'landscape', nodes: [], edges: [], views: [{ id: 'landscape', diagram: 'c4.landscape', nodeIds: [] }] }, report };
+  }
+}
+
+function szRead(workspace, report, recs, rels, views) {
+  const say = (path, status, message) => report.push({ path, status, message });
+  const pending = [], bySid = new Map(), relBySid = new Map(), implied = new Map(), groups = new Set();
+  let title;
+  const done = () => {
+    const nodes = recs.map(r => r.node), edges = rels.map(r => r.edge);
+    if (!views.length) {
+      if (nodes.length) say('views', 'approximated', 'the workspace has no view that is read: a landscape view shows its people and software systems');
+      views.push({ id: 'landscape', diagram: 'c4.landscape', ...(title ? { title: `${title}: system landscape` } : {}),
+        nodeIds: nodes.filter(n => n.type === 'c4.Person' || n.type === 'c4.SoftwareSystem').map(n => n.id) });
+    }
+    return { model: { schemaVersion: 2, ...(title ? { title } : {}), root: views[0].id, nodes, edges, views }, report };
+  };
+  // what is walked, counted against SZ_WORK and SZ_CHARS; past either, nothing more is read (reported once)
+  let work = SZ_WORK, chars = SZ_CHARS, spent = false;
+  const over = path => { if (!spent) { spent = true; say(path, 'skipped', `over ${SZ_WORK} list entries or ${SZ_CHARS} characters read in all, a shared one counted each time: this and the rest are not read`); } };
+  const str = (v, path) => { // text within the budget, else undefined
+    if (typeof v !== 'string') return;
+    if (v.length > chars) { chars = 0; over(path); return; }
+    chars -= v.length;
+    return v;
+  };
+  // a field of the wrong kind is reported and read as absent
+  const list = (o, k, path) => {
+    const v = szOwn(o, k), at = path ? `${path}.${k}` : k;
+    if (Array.isArray(v)) {
+      if (v.length <= work) { work -= v.length; return v; }
+      const some = v.slice(0, work);
+      work = 0; over(`${at}[${some.length}]`);
+      return some;
+    }
+    if (v != null) say(at, 'skipped', `${k} is not a list: not read`);
+    return [];
+  };
+  const text = (o, k, path) => {
+    const v = szOwn(o, k);
+    if (typeof v === 'string') return str(v, path ? `${path}.${k}` : k) || undefined;
+    if (v != null) say(path ? `${path}.${k}` : k, 'skipped', `${k} is not text: not read`);
+  };
 
+  if (typeof workspace === 'string') {
+    if (workspace.length > SZ_LIMIT) { say('', 'skipped', `the input is ${workspace.length} characters, over the limit of ${SZ_LIMIT}: nothing read`); return done(); }
+    try { workspace = JSON.parse(workspace); } catch (e) { say('', 'skipped', `the input is not JSON (${e.message}): nothing read`); return done(); }
+  }
+  const model = szOwn(workspace, 'model');
+  if (Array.isArray(workspace) || model === null || typeof model !== 'object' || Array.isArray(model)) { say('', 'skipped', 'not a Structurizr workspace (no model): nothing read'); return done(); }
+  title = text(workspace, 'name', '');
+
+  // ---- elements ----
+  let fullE = false;
+  const add = (path, node, base, ident) => {
+    if (recs.length >= SZ_MAX) { if (!fullE) { fullE = true; say(path, 'skipped', `over ${SZ_MAX} elements: this and the rest are not read`); } return null; }
+    const rec = { node, base, ident };
+    recs.push(rec);
+    return rec;
+  };
+  const unread = (x, path, what) => { // what an element holds that the model has no place for
+    const props = szOwn(x, 'properties'), other = props && typeof props === 'object' ? Object.keys(props).filter(k => k !== SZ_ID) : [];
+    if (other.length) say(`${path}.properties`, 'skipped', `${what}: properties ${other.join(', ')} are not read`);
+    if (list(x, 'perspectives', path).length) say(`${path}.perspectives`, 'skipped', `${what}: perspectives are not read`);
+    const g = szOwn(x, 'group');
+    if (typeof g === 'string' && !groups.has(g)) { groups.add(g); say(`${path}.group`, 'skipped', `group ${g}: groups are not read`); }
+    if (szDocumented(x)) say(`${path}.documentation`, 'skipped', `${what}: documentation and decisions are not read`);
+    if (str(szOwn(x, 'url'), `${path}.url`)) say(`${path}.url`, 'skipped', `${what}: its url is not read`);
+  };
+  const ident = x => { const v = str(szOwn(szOwn(x, 'properties'), SZ_ID), 'properties'); return v && !SZ_UUID.test(v) ? v : undefined; };
+  const sid = (x, rec, path) => { // Structurizr's id, by which relationships and views name the element
+    const k = szKey(szOwn(x, 'id'));
+    if (k === undefined) return;
+    if (bySid.has(k)) say(`${path}.id`, 'approximated', `id ${k} is used twice: relationships and views find the first`);
+    else bySid.set(k, rec);
+  };
+  const relsOf = (x, path, from) => list(x, 'relationships', path).forEach((r, k) => pending.push({ x: r, path: `${path}.relationships[${k}]`, from }));
+  const element = (x, path, type, parent) => {
+    if (x === null || typeof x !== 'object' || Array.isArray(x)) { say(path, 'skipped', 'not an element: not read'); return null; }
+    const name = text(x, 'name', path);
+    if (name === undefined) { say(path, 'skipped', 'an element with no name: it and what it holds are not read'); return null; }
+    const tags = (text(x, 'tags', path) || '').split(',').map(t => t.trim()).filter(Boolean), props = {};
+    const description = text(x, 'description', path), technology = text(x, 'technology', path);
+    if (description) props.description = description;
+    if (technology) props.technology = technology;
+    if (szOwn(x, 'location') === 'External' || tags.includes('External')) props.external = true;
+    const rec = add(path, { type, label: name, props }, name, ident(x));
+    if (!rec) return null;
+    rec.parent = parent; rec.tags = tags; rec.path = path;
+    sid(x, rec, path); unread(x, path, name); relsOf(x, path, rec);
+    return rec;
+  };
+
+  list(model, 'people', 'model').forEach((x, k) => element(x, `model.people[${k}]`, 'c4.Person'));
+  list(model, 'softwareSystems', 'model').forEach((x, k) => {
+    const p = `model.softwareSystems[${k}]`, s = element(x, p, 'c4.SoftwareSystem');
+    if (s) list(x, 'containers', p).forEach((y, j) => {
+      const q = `${p}.containers[${j}]`, c = element(y, q, 'c4.Container', s);
+      if (c) list(y, 'components', q).forEach((z, i) => element(z, `${q}.components[${i}]`, 'c4.Component', c));
+    });
+  });
+  // deployment nodes, by a stack (never recursion): `holder` owns a node; past SZ_DEEP a node's children take its holder
+  const stack = list(model, 'deploymentNodes', 'model').map((x, k) => ({ x, path: `model.deploymentNodes[${k}]`, holder: null, depth: 1 })).reverse();
+  let flat = false;
+  while (stack.length && !fullE) {
+    const { x, path, holder, depth } = stack.pop(), d = element(x, path, 'c4.DeploymentNode', holder);
+    if (!d) continue;
+    const deep = depth >= SZ_DEEP, kids = list(x, 'children', path);
+    if (deep && !flat && kids.length) { flat = true; say(path, 'approximated', `deployment node ${d.node.label} is nested ${SZ_DEEP} deep: the nodes it holds are read flat from there`); }
+    const instances = szKey(szOwn(x, 'instances'));
+    if (instances !== undefined && instances !== '1') say(`${path}.instances`, 'approximated', `deployment node ${d.node.label} stands for ${instances} instances: it is drawn once`);
+    for (const [k, what] of [['infrastructureNodes', 'an infrastructure node'], ['softwareSystemInstances', 'a software system instance']])
+      list(x, k, path).forEach((y, j) => say(`${path}.${k}[${j}]`, 'skipped', `${what} ${typeof szOwn(y, 'name') === 'string' ? szOwn(y, 'name') + ' ' : ''}is not read, nor its relationships`));
+    list(x, 'containerInstances', path).forEach((y, j) => {
+      const q = `${path}.containerInstances[${j}]`, c = bySid.get(szKey(szOwn(y, 'containerId')));
+      if (y === null || typeof y !== 'object' || !c || c.node.type !== 'c4.Container') { say(q, 'skipped', 'a container instance whose container is not read: not read'); return; }
+      const n = szKey(szOwn(y, 'instanceId')) || '1', i = add(q, { type: 'c4.ContainerInstance', label: c.node.label, props: {} }, null, ident(y));
+      if (!i) return;
+      i.parent = d; i.container = c; i.instance = n;
+      if (str(szOwn(y, 'tags'), q)?.split(',').some(t => t.trim() && t.trim() !== 'Container Instance')) say(`${q}.tags`, 'skipped', `instance ${n} of ${c.node.label}: its own tags are not read (its container's are)`);
+      sid(y, i, q); unread(y, q, `instance ${n} of ${c.node.label}`); relsOf(y, q, i);
+    });
+    for (let k = kids.length - 1; k >= 0; k--) stack.push({ x: kids[k], path: `${path}.children[${k}]`, holder: deep ? holder : d, depth: deep ? depth : depth + 1 });
+  }
+  for (const [k, what] of [['softwareSystemInstances', 'a software system instance'], ['infrastructureNodes', 'an infrastructure node'], ['customElements', 'a custom element']])
+    if (list(model, k, 'model').length) say(`model.${k}`, 'skipped', `${what} is not read`);
+
+  // ---- relationships ----
+  let fullR = false, impliedCount = 0;
+  for (const { x, path, from } of pending) {
+    if (x === null || typeof x !== 'object' || Array.isArray(x)) { say(path, 'skipped', 'not a relationship: not read'); continue; }
+    // a static element's linked relationship is implied; an instance's is replicated from its container's, and read (§7.5.3)
+    const k = szKey(szOwn(x, 'id')), linked = szKey(szOwn(x, 'linkedRelationshipId'));
+    if (linked !== undefined && from.node.type !== 'c4.ContainerInstance' && from.node.type !== 'c4.DeploymentNode') { if (k !== undefined) implied.set(k, linked); impliedCount++; continue; }
+    if (rels.length === SZ_MAX) { if (!fullR) { fullR = true; say(path, 'skipped', `over ${SZ_MAX} relationships: this and the rest are not read`); } continue; }
+    const to = bySid.get(szKey(szOwn(x, 'destinationId')));
+    if (!to) { say(path, 'skipped', `a relationship from ${from.node.label} whose destination is not read: not read`); continue; }
+    const description = text(x, 'description', path), technology = text(x, 'technology', path);
+    const edge = { type: 'c4.Relationship', from, to, ...(description ? { label: description } : {}), ...(technology ? { props: { technology } } : {}) };
+    const r = { edge, ident: ident(x) };
+    if (k !== undefined) { if (relBySid.has(k)) say(`${path}.id`, 'approximated', `relationship id ${k} is used twice: views find the first`); else relBySid.set(k, r); }
+    rels.push(r);
+    unread(x, path, `relationship ${from.node.label} → ${to.node.label}`);
+    if (szOwn(x, 'interactionStyle') === 'Asynchronous') say(`${path}.interactionStyle`, 'approximated', `relationship ${from.node.label} → ${to.node.label} is asynchronous: it is drawn as any other`);
+  }
+  if (impliedCount) say('model', 'skipped', `${impliedCount} implied relationship${impliedCount > 1 ? 's are' : ' is'} not read: the C4 type works them out when it draws`);
+
+  // ---- ids (R3): identifiers first, so a name never takes one; then the rest in order ----
+  const used = new Set(), next = new Map(), plain = /^[A-Za-z0-9_.-]+$/;
+  const fallback = { 'c4.Person': 'person', 'c4.SoftwareSystem': 'system', 'c4.Container': 'container', 'c4.Component': 'component', 'c4.DeploymentNode': 'node' };
+  const baseOf = r => (r.node.type === 'c4.ContainerInstance' ? `${r.container.node.id}-${szSlug(r.instance) || '1'}` : szSlug(r.base) || fallback[r.node.type]);
+  for (const r of recs) if (r.ident && plain.test(r.ident) && !used.has(r.ident)) { r.node.id = r.ident; used.add(r.ident); }
+  for (const r of rels) if (r.ident && plain.test(r.ident) && !used.has(r.ident)) { r.edge.id = r.ident; used.add(r.ident); }
+  for (const r of recs) if (r.node.id === undefined) r.node.id = szFree(used, next, baseOf(r));
+  for (const r of rels) if (r.edge.id === undefined) r.edge.id = szFree(used, next, `${r.edge.from.node.id}-${r.edge.to.node.id}`);
+  // ends, owners and references by id, now that every element has one; a shape from the styles
+  const styles = new Map(), vs = szOwn(workspace, 'views'), conf = szOwn(vs, 'configuration'); // a tag's shape: its last style's, mapped once
+  const looks = new Set();
+  list(szOwn(conf, 'styles'), 'elements', 'views.configuration.styles').forEach(s => {
+    const tag = str(szOwn(s, 'tag'), 'views.configuration.styles.elements'), shape = str(szOwn(s, 'shape'), 'views.configuration.styles.elements');
+    if (tag !== undefined && shape !== undefined) styles.set(tag, { shape, mapped: SZ_SHAPE.get(shape.toLowerCase()) });
+    if (s !== null && typeof s === 'object') for (const k of Object.keys(s)) if (k !== 'tag' && k !== 'shape') looks.add(k);
+  });
+  if (looks.size) say('views.configuration.styles.elements', 'skipped', `element styles: only shape is read, not ${[...looks].slice(0, 20).join(', ')}`);
+  if (list(szOwn(conf, 'styles'), 'relationships', 'views.configuration.styles').length) say('views.configuration.styles.relationships', 'skipped', 'relationship styles are not read');
+  if (list(conf, 'themes', 'views.configuration').length) say('views.configuration.themes', 'skipped', 'themes are not read: shapes come from the workspace\'s own styles');
+  for (const r of recs) {
+    const n = r.node;
+    if (r.parent) n.parent = r.parent.node.id;
+    if (r.container) n.props.container = r.container.node.id;
+    if (r.tags) {
+      let style;
+      for (const t of r.tags) style = styles.get(t) ?? style;
+      if (style && n.type === 'c4.DeploymentNode') { say(r.path, 'skipped', `${n.label}: a deployment node's shape ${style.shape} is not read`); style = undefined; }
+      const own = n.type === 'c4.Person' ? 'person' : 'box', { shape, mapped } = style || {};
+      if (shape && !mapped) say(r.path, 'approximated', `${n.label}: shape ${shape} is drawn as a box`);
+      if (shape && (mapped || 'box') !== own) n.props.shape = mapped || 'box';
+    }
+    if (!Object.keys(n.props).length) delete n.props;
+  }
+  for (const r of rels) { r.edge.from = r.edge.from.node.id; r.edge.to = r.edge.to.node.id; }
+
+  // ---- views ----
+  const vused = new Set(), vnext = new Map();
+  for (const [key, diagram, field, word] of SZ_VIEWS) list(vs, key, 'views').forEach((x, k) => {
+    const path = `views.${key}[${k}]`;
+    if (x === null || typeof x !== 'object' || Array.isArray(x)) { say(path, 'skipped', 'not a view: not read'); return; }
+    const vkey = text(x, 'key', path), id = szFree(vused, vnext, (vkey && szSlug(vkey)) || szSlug(word));
+    const v = { id, diagram };
+    let subject = field && bySid.get(szKey(szOwn(x, field)));
+    if (subject && !SZ_SUBJECT[diagram].includes(subject.node.type)) { say(`${path}.${field}`, 'skipped', `view ${id}: ${subject.node.label} is not what a ${word} view is scoped to`); subject = null; }
+    else if (!subject && field && szOwn(x, field) != null) say(`${path}.${field}`, 'skipped', `view ${id}: its scope is not read`);
+    const env = text(x, 'environment', path), named = subject ? subject.node.label : title;
+    v.title = text(x, 'title', path) || `${named ? named + ': ' : ''}${word}${env ? ', ' + env : ''}`;
+    if (subject) v.subject = subject.node.id;
+    const dir = szOwn(szOwn(x, 'automaticLayout'), 'rankDirection');
+    if (dir != null && (typeof dir !== 'string' || !/^(TopBottom|BottomTop|LeftRight|RightLeft)$/.test(dir))) say(`${path}.automaticLayout.rankDirection`, 'skipped', `view ${id}: rank direction ${szKey(dir) ?? ''} is not one Structurizr has: not read`);
+    else if (dir != null) {
+      v.direction = /^(TopBottom|BottomTop)$/.test(dir) ? 'down' : 'right';
+      if (dir === 'BottomTop' || dir === 'RightLeft') say(`${path}.automaticLayout`, 'approximated', `view ${id}: ${dir} is drawn ${v.direction === 'down' ? 'top to bottom' : 'left to right'}`);
+    }
+    const shown = new Set(subject && diagram !== 'c4.context' && diagram !== 'c4.deployment' ? [subject.node.id] : []);
+    let lost = 0, placed = 0;
+    for (const e of list(x, 'elements', path)) {
+      const r = bySid.get(szKey(szOwn(e, 'id')));
+      if (r) shown.add(r.node.id); else lost++;
+      if (szOwn(e, 'x') != null || szOwn(e, 'y') != null) placed++;
+    }
+    if (lost) say(`${path}.elements`, 'skipped', `view ${id}: ${lost} element${lost > 1 ? 's' : ''} not read ${lost > 1 ? 'are' : 'is'} not shown`);
+    if (placed) say(`${path}.elements`, 'skipped', `view ${id}: element positions are not read; the view is laid out`);
+    v.nodeIds = [...shown];
+    if (diagram === 'c4.dynamic') {
+      const steps = list(x, 'relationships', path).map((s, j) => ({ s, j, order: szKey(szOwn(s, 'order')) ?? '' }));
+      steps.sort((a, b) => szOrder(a.order, b.order) || a.j - b.j);
+      const seen = new Set();
+      v.edges = [];
+      for (const { s, j, order } of steps) {
+        const q = `${path}.relationships[${j}]`, k = szKey(szOwn(s, 'id'));
+        let r = relBySid.get(k);
+        if (!r && implied.has(k) && (r = relBySid.get(implied.get(k)))) say(q, 'approximated', `view ${id}: step ${order || j + 1} is an implied relationship: the relationship it is implied by, ${r.edge.id}, is the step`);
+        if (!r) { say(q, 'skipped', `view ${id}: a step whose relationship is not read`); continue; }
+        if (seen.has(r)) { say(q, 'approximated', `view ${id}: ${r.edge.id} is a step twice: the first is kept (each relationship is one step)`); continue; }
+        seen.add(r); v.edges.push(r.edge.id);
+        const d = szOwn(s, 'description');
+        if (typeof d === 'string' && d && d !== (r.edge.label || '')) say(q, 'approximated', `view ${id}: step ${r.edge.id} says "${d}": the relationship's own description is drawn`);
+        if (szOwn(s, 'response') === true) say(q, 'approximated', `view ${id}: step ${r.edge.id} is a response: it is drawn the relationship's way`);
+      }
+    }
+    if (list(x, 'animations', path).length) say(`${path}.animations`, 'skipped', `view ${id}: animations are not read`);
+    views.push(v);
+  });
+  for (const [key, word] of [['filteredViews', 'a filtered view'], ['customViews', 'a custom view'], ['imageViews', 'an image view']])
+    list(vs, key, 'views').forEach((x, k) => say(`views.${key}[${k}]`, 'skipped', `${word}${typeof szOwn(x, 'key') === 'string' ? ' ' + szOwn(x, 'key') : ''} is not read`));
+  if (szDocumented(workspace)) say('documentation', 'skipped', 'documentation and decisions are not read');
+  return done();
+}
+/* ---------- DBML: an adapter over @dbml/core's parsed Database (notes/milestone-2.md §8.4, M2.11; risks.md R1 to R3) ---
+   It imports nothing: a host parses DBML with @dbml/core, which it installs (`Parser.parse(text, 'dbmlv2')`), and hands
+   this the Database or what `database.export()` gives (plain JSON, which drops the project, its note and database type,
+   diagram views and a table's `checks {}`). Tested against a Database captured from @dbml/core 11.0.0
+   (tests/import/dbml.json). Internal: the CLI (`umlimator.py import x.dbml`) runs it through Node; its helpers are its
+   own (db...), since the readers share one scope in lib/umlimator-all.js.
+
+   readDbml(database) -> { model, report }: a version-2 model with one `er` view of every table, in model.md row 20's
+   vocabulary, and a report of what was not read as written, each item { line, status, message }, status `skipped` or
+   `approximated` (R1). A parsed object keeps no line numbers, so `line` is the item's path in the Database
+   (`schemas[0].tables[2].fields[1]`), as the CLI names a JSON source's items. Ids come from the source's names (R3): a
+   table's name, a column `<table>.<column>`, a relationship `<from>-<to>`, each the next free of base, base-2, ...
+
+   - a table is an `er.Entity`; every schema's tables are read, a table of a schema other than `public` under its own
+     name, reported;
+   - a field is an `er.Column`: `dataType` its type's name, `primaryKey` from `pk` or the table's `[pk]` index (a
+     composite key), `unique`, and `nullable` when it is neither `not null` nor a key, as SQL has it; a partial's fields
+     are the table's own (@dbml/core injects them), reported;
+   - a ref is an `er.Relationship` from its `1` end (the referenced columns) to its `*` end (the referring ones), `1` to
+     `0..*`. In a one-to-one (`-`, both ends `1`), `1` to `0..1`, the referring end is the first of a standalone ref
+     (`Ref: b.a_id - a.id`) and the second of an inline one (`a_id int [ref: - a.id]`, which @dbml/core writes
+     referenced end first and with no `name` key). The referring columns take `foreignKey` and `references`, pair by
+     pair; it is identifying when they lie in the child's key, and its parent end is `0..1` when one of them is nullable
+     (an optional parent). A many-to-many (`<>`) is one relationship `0..*` to `0..*` with no foreign key, approximated
+     (DBML builds a junction table for it);
+   - enums, notes, the project's note and database type, table groups, other indexes, defaults, increments, checks, a
+     ref's name, note and actions, colours, records, sticky notes and diagram views are reported, not read.
+
+   Hostile input (§8, R2): at most DB_MAX tables, DB_MAX columns and DB_MAX refs are read, and DB_NAMES column names in
+   ref ends and key indexes, the rest reported once each; the report lists DB_MAX items, then counts the rest in one; no
+   nesting is followed (the walk is a fixed depth: schemas, tables, fields), so a deep object costs nothing; anything
+   that is not an object, or a field of the wrong kind, is skipped and reported; names are looked up in Maps, so
+   `__proto__` and `constructor` are ordinary names. It never throws. */
+const DB_MAX = 10000; // tables, columns, refs and report items each (§8)
+const DB_NAMES = 10 * DB_MAX; // column names in ref ends and [pk] indexes, all together
+const DB_VIEW = 'schema'; // the view's id (views keep their own ids, model.md rule 5)
+const DB_SCHEMA = 'public'; // @dbml/core's default schema
+const dbObj = x => x !== null && typeof x === 'object' && !Array.isArray(x);
+const dbName = x => (typeof x === 'string' && x ? x : null);
+
+function readDbml(database) {
+  const report = [], nodes = [], edges = [], used = new Set(), next = new Map();
+  let title = null, more = 0;
+  const say = (line, status, message) => {
+    if (report.length < DB_MAX) report.push({ line, status, message }); else more++;
+  };
+  const model = () => ({ schemaVersion: 2, ...(title ? { title } : {}), root: DB_VIEW, nodes, edges,
+    views: [{ id: DB_VIEW, diagram: 'er', nodeIds: nodes.map(n => n.id) }] });
+  const free = base => { // the first of base, base-2, ... not taken; an id never holds "->" (model.md rule 5)
+    base = base.replace(/->+/g, '-');
+    let k = next.get(base) || 1, id = k > 1 ? `${base}-${k}` : base;
+    while (used.has(id)) id = `${base}-${++k}`;
+    next.set(base, k); used.add(id);
+    return id;
+  };
+  const named = () => { // columns after every table (names first, R3)
+    for (const n of nodes) for (const c of n.members) if (!c.id) c.id = free(`${n.id}.${c.label}`);
+  };
+  try {
+    if (!dbObj(database) || !Array.isArray(database.schemas)) {
+      say('', 'skipped', 'not a parsed DBML Database (parse the text with @dbml/core first): nothing read');
+      return { model: model(), report };
+    }
+    title = dbName(database.name); // a project's name: a Database has it, its export() does not
+    // `schema.table` and an alias -> { node, cols: Map name -> column }
+    const tables = new Map(), aliases = new Map(), refs = [], notNull = new Set();
+    const count = { tables: 0, columns: 0, refs: 0, names: 0 };
+    const full = (what, at) => {
+      const n = count[what]++;
+      if (n === DB_MAX) say(at, 'skipped', `over ${DB_MAX} ${what}: the rest are not read`);
+      return n >= DB_MAX;
+    };
+    const names = (n, at) => { // n more column names in a ref or a key index: over DB_NAMES, it and the rest not read
+      if (count.names + n <= DB_NAMES) { count.names += n; return false; }
+      if (count.names <= DB_NAMES) {
+        say(at, 'skipped', `over ${DB_NAMES} column names in refs and keys: the rest are not read`);
+      }
+      count.names = DB_NAMES + 1;
+      return true;
+    };
+    const extra = (x, at, what, keys) => {
+      for (const [k, word] of keys) {
+        const v = x[k];
+        if (v == null || v === false || (Array.isArray(v) && !v.length)) continue;
+        say(at, 'skipped', `${what}: ${word} not read`);
+      }
+    };
+    extra(database, '', 'the database', [['notes', 'its sticky notes are'], ['records', 'its records are'],
+      ['note', 'its note is'], ['databaseType', 'its database type is'], ['diagramViews', 'its diagram views are']]);
+    database.schemas.forEach((s, si) => {
+      const sat = `schemas[${si}]`;
+      if (!dbObj(s)) return say(sat, 'skipped', 'a schema that is not an object');
+      const sname = dbName(s.name) || DB_SCHEMA;
+      for (const [k, word] of [['enums', 'enum'], ['tableGroups', 'table group']]) {
+        if (s[k] == null) continue;
+        if (!Array.isArray(s[k])) { say(`${sat}.${k}`, 'skipped', `${k} is not a list`); continue; }
+        s[k].forEach((x, i) =>
+          say(`${sat}.${k}[${i}]`, 'skipped', `${word} ${dbName(x && x.name) || '(unnamed)'}: not read`));
+      }
+      if (Array.isArray(s.deps) && s.deps.length) {
+        say(`${sat}.deps`, 'skipped', `schema ${sname}: its dependencies are not read`);
+      }
+      if (s.refs != null && !Array.isArray(s.refs)) say(`${sat}.refs`, 'skipped', 'refs is not a list');
+      else (s.refs || []).forEach((r, i) => refs.push([r, `${sat}.refs[${i}]`]));
+      if (s.tables == null) return;
+      if (!Array.isArray(s.tables)) return say(`${sat}.tables`, 'skipped', 'tables is not a list');
+      s.tables.forEach((t, ti) => {
+        const at = `${sat}.tables[${ti}]`, name = dbObj(t) && dbName(t.name);
+        if (!name) return say(at, 'skipped', 'a table with no name');
+        if (full('tables', at)) return;
+        const key = `${sname}.${name}`;
+        if (tables.has(key)) return say(at, 'skipped', `table ${key} is named twice: the second is not read`);
+        if (sname !== DB_SCHEMA) {
+          say(at, 'approximated', `table ${key}: its schema is not kept, so it is read as ${name}`);
+        }
+        extra(t, at, `table ${name}`,
+          [['note', 'its note is'], ['headerColor', 'its header colour is'], ['checks', 'its checks are']]);
+        if (Array.isArray(t.partials) && t.partials.length) {
+          say(at, 'approximated', `table ${name}: its partials' fields are read as its own`);
+        }
+        const node = { id: free(name), type: 'er.Entity', label: name, members: [] };
+        const cols = new Map(), rec = { node, cols };
+        tables.set(key, rec);
+        if (dbName(t.alias) && !aliases.has(t.alias)) aliases.set(t.alias, rec);
+        nodes.push(node);
+        if (!Array.isArray(t.fields)) {
+          if (t.fields != null) say(`${at}.fields`, 'skipped', `table ${name}: fields is not a list`);
+        }
+        else t.fields.forEach((f, fi) => {
+          const fat = `${at}.fields[${fi}]`, fname = dbObj(f) && dbName(f.name);
+          if (!fname) return say(fat, 'skipped', `table ${name}: a field with no name`);
+          if (full('columns', fat)) return;
+          if (cols.has(fname)) {
+            return say(fat, 'skipped', `${name}.${fname} is named twice: the second is not read`);
+          }
+          const type = dbObj(f.type) ? dbName(f.type.type_name) : null, props = {};
+          if (type) props.dataType = type;
+          else say(fat, 'approximated', `${name}.${fname}: its type is not text, so it has none`);
+          if (f.pk === true) props.primaryKey = true;
+          if (f.unique === true) props.unique = true;
+          extra(f, fat, `${name}.${fname}`, [['note', 'its note is'], ['dbdefault', 'its default is'],
+            ['increment', 'its increment is'], ['checks', 'its checks are'], ['checkIds', 'its checks are']]);
+          const col = { id: '', type: 'er.Column', label: fname, props }; // its id by named()
+          if (f.not_null === true) notNull.add(col);
+          cols.set(fname, col); node.members.push(col);
+        });
+        if (t.indexes != null && !Array.isArray(t.indexes)) {
+          say(`${at}.indexes`, 'skipped', `table ${name}: indexes is not a list`);
+        }
+        else (t.indexes || []).forEach((x, xi) => { // a [pk] index is the table's key; any other index is not read
+          const xat = `${at}.indexes[${xi}]`, pk = dbObj(x) && x.pk === true;
+          const list = pk && Array.isArray(x.columns) && !names(x.columns.length, xat) ? x.columns : null;
+          const picked = list && list.map(c => (dbObj(c) && c.type === 'column' ? cols.get(c.value) : undefined));
+          if (!picked || !picked.length || picked.includes(undefined)) {
+            const what = pk ? 'a primary key index not of its columns' : 'an index';
+            return say(xat, 'skipped', `table ${name}: ${what} is not read`);
+          }
+          picked.forEach(c => { c.props.primaryKey = true; });
+        });
+        for (const c of cols.values()) if (!notNull.has(c) && !c.props.primaryKey) c.props.nullable = true;
+      });
+    });
+    named();
+    const end = e => { // a ref's end: { rec, cols, one, name } or null
+      if (!dbObj(e) || !dbName(e.tableName) || !Array.isArray(e.fieldNames) || !e.fieldNames.length) return null;
+      if ((e.relation !== '1' && e.relation !== '*') || (e.schemaName != null && !dbName(e.schemaName))) return null;
+      const rec = tables.get(`${dbName(e.schemaName) || DB_SCHEMA}.${e.tableName}`)
+        || (e.schemaName == null ? aliases.get(e.tableName) : undefined);
+      const cols = rec && e.fieldNames.map(n => rec.cols.get(n));
+      if (!cols || cols.includes(undefined)) return null;
+      return { rec, cols, one: e.relation === '1', name: `${e.tableName}.(${e.fieldNames.join(', ')})` };
+    };
+    const width = e => (dbObj(e) && Array.isArray(e.fieldNames) ? e.fieldNames.length : 0);
+    for (const [r, at] of refs) {
+      if (full('refs', at)) continue;
+      const eps = dbObj(r) && Array.isArray(r.endpoints) && r.endpoints.length === 2 ? r.endpoints : null;
+      if (eps && names(width(eps[0]) + width(eps[1]), at)) continue;
+      const ends = eps ? eps.map(end) : [null];
+      if (ends.includes(null)) {
+        say(at, 'skipped', 'a ref whose ends are not two columns of tables read: not read');
+        continue;
+      }
+      if (r.inactive === true) {
+        say(at, 'skipped', `ref ${ends[0].name} - ${ends[1].name}: inactive, so not read`);
+        continue;
+      }
+      // a standalone ref writes its referring end first (`>`, `-`); an inline one, with no name key, its referenced end
+      let [child, parent] = r.name === undefined ? [ends[1], ends[0]] : ends;
+      if (child.one && !parent.one) [child, parent] = [parent, child];
+      const what = `ref ${child.name} -> ${parent.name}`;
+      extra(r, at, what, [['name', 'its name is'], ['note', 'its note is'], ['onDelete', 'its delete action is'],
+        ['onUpdate', 'its update action is'], ['color', 'its colour is']]);
+      if (!child.one && !parent.one) { // many-to-many: no column refers; drawn first end to second
+        say(at, 'approximated', `${what}: a many-to-many is one relationship with no foreign key`);
+        edges.push({ id: free(`${child.rec.node.id}-${parent.rec.node.id}`), type: 'er.Relationship',
+          from: child.rec.node.id, to: parent.rec.node.id,
+          props: { identifying: false, ends: { from: { multiplicity: '0..*' }, to: { multiplicity: '0..*' } } } });
+        continue;
+      }
+      if (child.cols.length !== parent.cols.length) {
+        say(at, 'skipped', `${what}: its two ends name different numbers of columns: not read`);
+        continue;
+      }
+      child.cols.forEach((c, i) => {
+        const to = parent.cols[i].id;
+        if (c.props.references && c.props.references !== to) {
+          return say(at, 'approximated', `${what}: ${c.label} refers to ${c.props.references} already, which it keeps`);
+        }
+        c.props.foreignKey = true; c.props.references = to;
+      });
+      const optional = child.cols.some(c => c.props.nullable);
+      edges.push({ id: free(`${parent.rec.node.id}-${child.rec.node.id}`), type: 'er.Relationship',
+        from: parent.rec.node.id, to: child.rec.node.id,
+        props: { identifying: child.cols.every(c => c.props.primaryKey === true),
+          ends: { from: { multiplicity: optional ? '0..1' : '1' },
+            to: { multiplicity: parent.one && child.one ? '0..1' : '0..*' } } } });
+    }
+  } catch (e) { // a host's object whose getter throws: what was read is kept
+    let why = 'an error';
+    try { if (e && typeof e.message === 'string') why = e.message; } catch { /* a getter that throws again */ }
+    say('', 'skipped', `the Database could not be read to its end (${why}): the rest is not read`);
+  }
+  named();
+  for (const n of nodes) if (!n.members.length) delete n.members;
+  if (more) report.push({ line: '', status: 'skipped', message: `${more} more items like these: not listed` });
+  return { model: model(), report };
+}
+
+
+
+
+
+
+
+
+/* ---------- BPMN XML: a reader and a writer through bpmn-moddle (notes/milestone-4b.md §12, 4b.4; risks.md R1 to R5) ---
+   It imports nothing: the caller makes a `bpmn-moddle` instance (`BpmnModdle()` from bpmn-moddle 10.3.1, which it
+   installs) and passes it in, as the markdown-it plugin takes the host's markdown-it. Internal: the CLI
+   (`umlimator.py import x.bpmn`, `umlimator.py export`) imports this file through Node; its helpers are its own (bx...),
+   since the readers share one scope in lib/umlimator-all.js. The vocabulary is model.md row 24's, as the note's §3.1
+   maps it onto BPMN 2.0.2's Table 2.1, with the extras S1 and decision 21 name.
+
+   readBpmnXml(xml, moddle) -> promise of { model, report }: a version-2 model with one `bpmn` view per BPMNDiagram, its
+   `nodeIds` the plane's shapes (a sub-process's own plane is a view with it as `subject`, which the sub-process
+   `opensView`; an element with no shape goes to the first view; a file with no diagram interchange is one view), and a
+   report of what was not read as written, each item { line, status, message }: `line` the element's id, status
+   `skipped` or `weakened`. Ids are the file's, or its `umlimator:id` (R3). Read as written: participants (a lane of
+   theirs a member, nested by `parent`), tasks (user, service), sub-processes, call activities, start, end, intermediate
+   and boundary events with the definitions their kind may take, exclusive and parallel gateways, data object references
+   (with their data object) and data store references, text annotations, groups (a category value names its group in
+   `categoryValueRef`), documentation, sequence and message flows, associations and data associations. Weakened, kept
+   under the element's `ext.bpmn`: a sequence flow's condition, a gateway's default, a send or receive task's kind, a
+   timer's time. Anything else (an element, an event definition or a marker outside the subset, an extension) is
+   reported `skipped` and kept under the model's `ext.bpmn.skipped` as moddle's JSON with its parent's id; a line to it
+   is reported too. Positions and sizes are not kept (R5): the report says so once per file.
+
+   writeBpmnXml(model, viewId, geo, moddle) -> promise of { xml, report }: every `bpmn.*` element of the model in one
+   definitions, a collaboration when it has a participant, a process per participant (its `processRef`, else
+   <participant>-process) that holds anything and one for what is in no pool, and one BPMNDiagram per `bpmn` view. Its
+   shapes and edges take their bounds and points from `geo` ({ nodes: [{ id, x, y, w, h }], edges: [{ id, pts }] }, the
+   layout of `viewId`), any other on a plain grid. An id that is not an XML name is written escaped (`_` and its code
+   points), the model's id in `umlimator:id`. Not written, and reported: what `ext.bpmn` holds, other diagrams' elements
+   and views, a property or field outside row 24 or on a type it is not for, a data association against BPMN's direction
+   (§4's data-ends), and whatever a reader would read back otherwise (note §12.5: a cycle of lanes, a lane as the parent
+   of data or an artifact, a process id taken, a view's subject or parent, an opensView, a node in no view). The root's
+   diagram is written first. The reader fills in the defaults: taskType none, definition none, cancelActivity true.
+
+   Hostile input (§12.2; a departure from R2, which asks for hand-written linear readers): text over BX_LIMIT characters
+   is refused; moddle's parser and handlers and this file's walk run inside one `try`, so a throw (a RangeError at depth
+   among them) is a report item, never a throw; the walk over moddle's tree is iterative, a skipped element's JSON is cut
+   at BX_DEEP levels, lookups are by Set and Map (no scan per element), and either report lists BX_MAX items, then counts
+   the rest in one. Neither function ever throws. A tab
+   or carriage return in a name or id reads back as a space (XML's attribute rule). */
+const BX_LIMIT = 1 << 20; // characters of XML read (R2)
+const BX_MAX = 1000; // report items listed; the rest counted in one
+const BX_DEEP = 32; // levels of a skipped element kept under ext.bpmn
+const BX_NS = 'https://zintaen.github.io/umlimator/bpmn'; // the umlimator: attributes' namespace
+const BX_VIEW = 'process'; // the view of a file with no diagram interchange
+const BX_TASK = { 'bpmn:Task': 'none', 'bpmn:UserTask': 'user', 'bpmn:ServiceTask': 'service', 'bpmn:SendTask': 'send', 'bpmn:ReceiveTask': 'receive' };
+const BX_TASK_OUT = { none: 'bpmn:Task', user: 'bpmn:UserTask', service: 'bpmn:ServiceTask' };
+const BX_DEFS = { // the definitions each kind of event may take (§3.2)
+  StartEvent: ['none', 'message', 'timer'], EndEvent: ['none', 'message', 'terminate'], IntermediateCatchEvent: ['message', 'timer'],
+  IntermediateThrowEvent: ['none', 'message'], BoundaryEvent: ['message', 'timer'] };
+const BX_DEF = { 'bpmn:MessageEventDefinition': 'message', 'bpmn:TimerEventDefinition': 'timer', 'bpmn:TerminateEventDefinition': 'terminate' };
+const BX_DEF_OUT = { message: 'bpmn:MessageEventDefinition', timer: 'bpmn:TimerEventDefinition', terminate: 'bpmn:TerminateEventDefinition' };
+const BX_SAME = new Set(['Participant', 'SubProcess', 'CallActivity', 'ExclusiveGateway', 'ParallelGateway', 'DataStoreReference',
+  'TextAnnotation', 'Group', ...Object.keys(BX_DEFS)]); // bpmn.X is bpmn:X
+const BX_ACTIVITY = new Set(['bpmn.Task', 'bpmn.SubProcess', 'bpmn.CallActivity']);
+const BX_PROPS = { 'bpmn.Participant': ['processRef'], 'bpmn.Task': ['taskType'], 'bpmn.CallActivity': ['calledElement'], 'bpmn.Association': ['direction'],
+  'bpmn.BoundaryEvent': ['definition', 'attachedTo', 'cancelActivity'], 'bpmn.DataStoreReference': ['dataStoreRef'] }; // and documentation on any
+const bxProp = (t, k) => k === 'documentation' || (BX_PROPS[t] || (t.slice(5) in BX_DEFS ? ['definition'] : [])).includes(k)
+  || k === 'categoryValueRef' && !['bpmn.Group', 'bpmn.Lane'].includes(t) && !/(Flow|Association)$/.test(t); // a node's groups (row 24)
+const BX_LOOSE = new Set(['bpmn.DataObject', 'bpmn.DataStoreReference', 'bpmn.TextAnnotation', 'bpmn.Group']); // in a pool, never a lane
+const BX_FIELDS = new Set(['id', 'type', 'label', 'parent', 'props', 'members', 'opensView', 'ext', 'from', 'to']);
+const BX_SIZE = { 'bpmn.Participant': [600, 200], 'bpmn.Lane': [570, 100], 'bpmn.Group': [200, 120], 'bpmn.TextAnnotation': [120, 40],
+  'bpmn.DataObject': [36, 50], 'bpmn.DataStoreReference': [50, 50], 'bpmn.ExclusiveGateway': [50, 50], 'bpmn.ParallelGateway': [50, 50] };
+const bxEvent = t => (t || '').endsWith('Event');
+const bxStr = x => (typeof x === 'string' && x ? x : null);
+const bxMsg = e => { try { return String(e && e.message || e).split('\n')[0]; } catch { return 'an error'; } };
+
+// a moddle element as JSON: its own properties, a reference by its id, cut at BX_DEEP levels
+function bxJson(el, depth = 0) {
+  if (!el || typeof el !== 'object') return el;
+  if (Array.isArray(el)) return el.map(x => bxJson(x, depth));
+  if (depth >= BX_DEEP) return { $type: el.$type, id: el.id, cut: true };
+  const out = { $type: el.$type }, refs = new Set(((el.$descriptor && el.$descriptor.properties) || []).filter(p => p.isReference).map(p => p.name));
+  for (const k of Object.keys(el)) {
+    const v = el[k];
+    if (k.startsWith('$') && k !== '$attrs' && k !== '$body') continue;
+    if (v == null || k === '$attrs' && !Object.keys(v).length) continue;
+    out[k] = refs.has(k) ? (Array.isArray(v) ? v.map(x => x && x.id) : v.id) : k === '$attrs' ? { ...v } : bxJson(v, depth + 1);
+  }
+  return out;
+}
+
+async function readBpmnXml(xml, moddle) {
+  const report = [], nodes = [], edges = [], views = [], skipped = [], byId = new Map();
+  let title = null, more = 0;
+  const say = (line, status, message) => { if (report.length < BX_MAX) report.push({ line, status, message }); else more++; };
+  const result = () => {
+    if (more) report.push({ line: '', status: 'skipped', message: `${more} more items like these: not listed` });
+    return { model: { schemaVersion: 2, ...(title ? { title } : {}), ...(views.length ? { root: views[0].id } : {}), nodes, edges, views,
+      ...(skipped.length ? { ext: { bpmn: { skipped } } } : {}) }, report };
+  };
+  if (typeof xml !== 'string') { say('', 'skipped', 'not text: nothing read'); return result(); }
+  if (xml.length > BX_LIMIT) { say('', 'skipped', `over ${BX_LIMIT} characters: nothing read (R2)`); return result(); }
+  if (!moddle || typeof moddle.fromXML !== 'function') {
+    say('', 'skipped', 'no bpmn-moddle instance given (npm install bpmn-moddle@10.3.1): nothing read');
+    return result();
+  }
+  try {
+    const { rootElement: defs, warnings, elementsById } = await moddle.fromXML(xml);
+    for (const w of warnings || []) say((w.element && w.element.id) || '', 'skipped', `${bxMsg(w)}: not read`);
+    if (!defs || defs.$type !== 'bpmn:Definitions') { say('', 'skipped', 'no BPMN definitions: nothing read'); return result(); }
+    title = bxStr(defs.name);
+    const ns = Object.keys(defs.$attrs || {}).find(k => k.startsWith('xmlns:') && defs.$attrs[k] === BX_NS), pre = ns ? ns.slice(6) + ':' : null;
+    const attr = (el, k) => (pre && el.$attrs && typeof el.$attrs[pre + k] === 'string' ? el.$attrs[pre + k] : null);
+    const idOf = el => attr(el, 'id') ?? el.id;
+    const foreign = (el, id) => { for (const k of Object.keys(el.$attrs || {})) if (!k.startsWith('xmlns') && !(pre && k.startsWith(pre))) say(id, 'skipped', `the attribute ${k}: not read`); };
+    foreign(defs, '');
+    const elOf = new Map(); // a moddle element -> its node or lane
+    const skip = (el, parent, why = 'outside the subset') => {
+      const id = el.id || '';
+      say(id || parent || '', 'skipped', `${(el.$type || 'an element').replace('bpmn:', '')} ${why}: kept under ext.bpmn, not read`);
+      skipped.push({ ...(parent ? { parent } : {}), element: bxJson(el) });
+    };
+    const add = (el, type, parent, props = {}, label = el.name) => {
+      const id = idOf(el);
+      if (!bxStr(id) || byId.has(id)) { skip(el, parent, id ? `has the id ${id}, taken` : 'has no id'); return null; }
+      const doc = (el.documentation || []).map(d => d.text).filter(bxStr).join('\n');
+      if (doc) props.documentation = doc;
+      const n = { id, type, ...(bxStr(label) ? { label } : {}), ...(parent ? { parent } : {}), ...(Object.keys(props).length ? { props } : {}) };
+      nodes.push(n); byId.set(id, n); elOf.set(el, n); foreign(el, id);
+      if (el.extensionElements) skip(el.extensionElements, id, '(an extension)');
+      return n;
+    };
+    const weak = (n, what, key, value) => { (n.ext ??= { bpmn: {} }).bpmn[key] = value; say(n.id, 'weakened', `${what}: kept under ext.bpmn, read as plain`); };
+    const pending = []; // [moddle element, model type, from element, to element, parent]
+    const groups = [], tagged = [], hosts = []; // groups by their category value; elements naming category values; boundary events' hosts
+
+    // participants, their message flows and artifacts
+    const owner = new Map(), queue = [];
+    for (const r of defs.rootElements || []) {
+      if (r.$type === 'bpmn:Collaboration') {
+        for (const p of r.participants || []) {
+          const n = add(p, 'bpmn.Participant', null); if (!n) continue;
+          tagged.push([p, n]);
+          if (p.processRef) {
+            owner.set(p.processRef, n);
+            const base = p.id + '-process', ref = p.processRef.id;
+            if (ref !== base && !(ref.startsWith(base + '-') && /^\d+$/.test(ref.slice(base.length + 1)))) n.props = { ...n.props, processRef: ref };
+          }
+        }
+        for (const f of r.messageFlows || []) pending.push([f, 'bpmn.MessageFlow', f.sourceRef, f.targetRef, null]);
+        queue.push([{ artifacts: r.artifacts }, null]);
+        for (const x of [...(r.conversations || []), ...(r.conversationLinks || [])]) skip(x, null);
+      } else if (r.$type === 'bpmn:Process') queue.push([r, null]);
+      else if (r.$type !== 'bpmn:DataStore' && r.$type !== 'bpmn:Category') skip(r, null);
+    }
+    // a process's lanes are its participant's members, nested by parent; a flow node is in the deepest lane naming it
+    const laneOf = new Map(), depth = new Map();
+    for (const [proc] of queue) {
+      if (proc.$type !== 'bpmn:Process') continue;
+      const pool = owner.get(proc), stack = (proc.laneSets || []).flatMap(s => (s.lanes || []).map(l => [l, null, 0])).reverse();
+      while (stack.length) {
+        const [l, up, d] = stack.pop();
+        if (!pool) { skip(l, null, 'of a process with no pool'); continue; }
+        const id = idOf(l);
+        if (!bxStr(id) || byId.has(id)) { skip(l, pool.id, id ? `has the id ${id}, taken` : 'has no id'); continue; }
+        const doc = (l.documentation || []).map(x => x.text).filter(bxStr).join('\n');
+        const m = { id, type: 'bpmn.Lane', ...(bxStr(l.name) ? { label: l.name } : {}), ...(up ? { parent: up } : {}), ...(doc ? { props: { documentation: doc } } : {}) };
+        (pool.members ??= []).push(m); byId.set(id, m); foreign(l, id);
+        for (const f of l.flowNodeRef || []) if (!(depth.get(f) >= d)) { laneOf.set(f, id); depth.set(f, d); }
+        if (l.childLaneSet) stack.push(...(l.childLaneSet.lanes || []).map(c => [c, id, d + 1]).reverse());
+      }
+    }
+    // flow elements and artifacts, container by container (iterative: a sub-process queues its own)
+    const objects = new Set(), refd = new Set();
+    for (let q = 0; q < queue.length; q++) {
+      const [c, inner] = queue[q], pool = c.$type === 'bpmn:Process' ? owner.get(c) : null, parent = inner || (pool && pool.id) || null;
+      if (c.$type === 'bpmn:Process') foreign(c, c.id || '');
+      else for (const s of c.laneSets || []) skip(s, inner, 'of a sub-process');
+      for (const el of c.flowElements || []) {
+        const t = el.$type, kind = t.replace('bpmn:', ''), at = (pool && laneOf.get(el)) || parent;
+        let n = null;
+        if (t in BX_TASK) {
+          n = add(el, 'bpmn.Task', at, { taskType: BX_TASK[t] in BX_TASK_OUT ? BX_TASK[t] : 'none' });
+          if (n && !(BX_TASK[t] in BX_TASK_OUT)) weak(n, `a ${BX_TASK[t]} task`, 'task', BX_TASK[t]);
+        } else if (t === 'bpmn:SubProcess' && !el.triggeredByEvent) {
+          n = add(el, 'bpmn.SubProcess', at);
+          if (n) queue.push([el, n.id]);
+        } else if (t === 'bpmn:CallActivity') n = add(el, 'bpmn.CallActivity', at, bxStr(el.calledElement) ? { calledElement: el.calledElement } : {});
+        else if (kind in BX_DEFS) {
+          const ds = el.eventDefinitions || [], def = ds.length ? BX_DEF[ds[0].$type] : 'none';
+          if (ds.length > 1 || !BX_DEFS[kind].includes(def)) { skip(el, at, `with ${ds.map(d => d.$type.replace('bpmn:', '')).join(', ') || 'no definition'}`); continue; }
+          const props = { definition: def };
+          if (t === 'bpmn:BoundaryEvent') props.cancelActivity = el.cancelActivity !== false;
+          n = add(el, `bpmn.${kind}`, at, props);
+          if (n && el.attachedToRef) hosts.push([n, el.attachedToRef]);
+          const time = ds[0] && ['timeDate', 'timeDuration', 'timeCycle'].filter(k => ds[0][k]).map(k => [k, ds[0][k].body ?? '']);
+          if (n && time && time.length) weak(n, `a timer's ${time.map(x => x[0]).join(', ')}`, 'timer', Object.fromEntries(time));
+        } else if (t === 'bpmn:ExclusiveGateway' || t === 'bpmn:ParallelGateway') {
+          n = add(el, `bpmn.${kind}`, at);
+          if (n && el.default) weak(n, 'a gateway\'s default flow', 'default', idOf(el.default));
+        } else if (t === 'bpmn:DataObjectReference') {
+          n = add(el, 'bpmn.DataObject', parent, {}, bxStr(el.name) || (el.dataObjectRef && el.dataObjectRef.name));
+          if (el.dataObjectRef) refd.add(el.dataObjectRef);
+        } else if (t === 'bpmn:DataObject') { objects.add([el, parent]); continue; }
+        else if (t === 'bpmn:DataStoreReference') {
+          const s = el.dataStoreRef, ref = s && (bxStr(s.name) || s.id);
+          n = add(el, 'bpmn.DataStoreReference', parent, ref ? { dataStoreRef: ref } : {});
+        } else if (t === 'bpmn:SequenceFlow') {
+          pending.push([el, 'bpmn.SequenceFlow', el.sourceRef, el.targetRef, parent]);
+          if (el.conditionExpression) pending.at(-1).push(['a condition', 'condition', el.conditionExpression.body ?? '']);
+          continue;
+        } else { skip(el, at); continue; }
+        if (!n) continue;
+        tagged.push([el, n]);
+        if (el.loopCharacteristics) skip(el.loopCharacteristics, n.id, '(a marker outside the subset)');
+        const ends = new Set((el.dataInputAssociations || []).map(a => a.targetRef)); // the writer's placeholder ends
+        for (const x of [el.ioSpecification, el.inputSet, el.outputSet, ...(el.properties || []), ...(el.dataInputs || []), ...(el.dataOutputs || [])]) if (x && !ends.has(x)) skip(x, n.id);
+        for (const a of el.dataInputAssociations || []) pending.push([a, 'bpmn.DataAssociation', (a.sourceRef || [])[0], el, null]);
+        for (const a of el.dataOutputAssociations || []) pending.push([a, 'bpmn.DataAssociation', el, a.targetRef, null]);
+      }
+      for (const a of c.artifacts || []) {
+        if (a.$type === 'bpmn:TextAnnotation') { const n = add(a, 'bpmn.TextAnnotation', parent, {}, a.text); if (n) tagged.push([a, n]); }
+        else if (a.$type === 'bpmn:Group') {
+          const n = add(a, 'bpmn.Group', parent, {}, a.categoryValueRef && a.categoryValueRef.value);
+          if (n && a.categoryValueRef) groups.push([a.categoryValueRef, n.id]);
+        } else if (a.$type === 'bpmn:Association') pending.push([a, 'bpmn.Association', a.sourceRef, a.targetRef, null]);
+        else skip(a, parent);
+      }
+    }
+    for (const [o, parent] of objects) if (!refd.has(o)) add(o, 'bpmn.DataObject', parent);
+    for (const [n, h] of hosts) { // a boundary event's host is an activity read, else it is said
+      const a = elOf.get(h);
+      if (a && BX_ACTIVITY.has(a.type)) n.props.attachedTo = a.id;
+      else say(n.id, 'skipped', `its host ${idOf(h) || '(no id)'} is not read: attachedTo not read`);
+    }
+    // the groups an element is in: its category values', or for an artifact its umlimator:groups
+    const groupOf = new Map(groups);
+    for (const [el, n] of tagged) {
+      const vals = el.categoryValueRef || (attr(el, 'groups') || '').split(' ').map(v => elementsById && elementsById[v]).filter(Boolean);
+      const ids = [...new Set(vals.map(v => groupOf.get(v)).filter(Boolean))];
+      if (ids.length) n.props = { ...n.props, categoryValueRef: ids };
+    }
+    // lines, once every node is known: an end that is not read is said
+    for (const [el, type, a, b, , w] of pending) {
+      const id = idOf(el), from = a && elOf.get(a), to = b && elOf.get(b);
+      if (!from || !to) { skip(el, null, `whose ${!from ? 'source' : 'target'} is not read`); continue; }
+      if (!bxStr(id) || byId.has(id)) { skip(el, null, id ? `has the id ${id}, taken` : 'has no id'); continue; }
+      const doc = (el.documentation || []).map(x => x.text).filter(bxStr).join('\n'), props = {};
+      if (doc) props.documentation = doc;
+      if (type === 'bpmn.Association' && el.associationDirection && el.associationDirection !== 'None') props.direction = el.associationDirection.toLowerCase();
+      const e = { id, type, from: from.id, to: to.id, ...(bxStr(el.name) && type.endsWith('Flow') ? { label: el.name } : {}), ...(Object.keys(props).length ? { props } : {}) };
+      edges.push(e); byId.set(id, e); foreign(el, id);
+      if (w) weak(e, w[0], w[1], w[2]);
+      if ((el.categoryValueRef || []).length) {
+        (e.ext ??= { bpmn: {} }).bpmn.categoryValueRef = el.categoryValueRef.map(v => v.id);
+        say(id, 'skipped', 'its groups (categoryValueRef, which row 24 gives no line): kept under ext.bpmn, not read');
+      }
+    }
+    // views: one per diagram, its shapes in order; what no plane shows goes to the first
+    const shown = new Set(), seen = new Set(), first = new Map(); // nodes in a plane; view ids; a node -> the first two views showing it
+    let placed = false;
+    for (const d of defs.diagrams || []) {
+      const plane = d.plane || {}, id = idOf(d);
+      if (!bxStr(id) || seen.has(id)) { skip(d, null, id ? `has the id ${id}, taken` : 'has no id'); continue; }
+      const subject = plane.bpmnElement && elOf.get(plane.bpmnElement), v = { id, diagram: 'bpmn', ...(bxStr(d.name) ? { title: d.name } : {}), parent: null, nodeIds: [] };
+      if (subject && subject.type === 'bpmn.SubProcess') { v.subject = subject.id; subject.opensView ??= id; }
+      const ids = new Set();
+      for (const s of plane.planeElement || []) {
+        placed = true;
+        const n = s.bpmnElement && elOf.get(s.bpmnElement);
+        if (s.$type === 'bpmndi:BPMNShape' && n && !ids.has(n.id)) { ids.add(n.id); v.nodeIds.push(n.id); shown.add(n.id); const f = first.get(n.id) || []; if (f.length < 2) first.set(n.id, [...f, v]); }
+      }
+      views.push(v); seen.add(id);
+    }
+    for (const v of views) if (v.subject) { // the first other view that shows its subject
+      const w = (first.get(v.subject) || []).find(x => x !== v);
+      v.parent = w ? w.id : null;
+    }
+    if (placed) say('', 'skipped', 'positions and sizes in the diagram interchange are not kept: umlimator lays each view out (R5)');
+    if (!views.length) {
+      views.push({ id: BX_VIEW, diagram: 'bpmn', parent: null, nodeIds: [] });
+      if (nodes.length) say('', 'skipped', `no diagram interchange: every element is in one view, ${BX_VIEW}`);
+    }
+    for (const n of nodes) if (!shown.has(n.id)) views[0].nodeIds.push(n.id);
+  } catch (e) { // moddle's parser or handlers, or a getter, threw (a RangeError at depth among them): nothing is kept
+    nodes.length = edges.length = views.length = skipped.length = 0;
+    say('', 'skipped', `the file could not be read (${bxMsg(e)}): nothing read`);
+  }
+  return result();
+}
+
+async function writeBpmnXml(model, viewId, geo, moddle) {
+  const report = [];
+  let more = 0;
+  const say = (line, message) => { if (report.length < BX_MAX) report.push({ line, status: 'skipped', message: `${message}: not written` }); else more++; };
+  const result = xml => {
+    if (more) report.push({ line: '', status: 'skipped', message: `${more} more items like these: not listed` });
+    return { xml, report };
+  };
+  try {
+    if (!moddle || typeof moddle.create !== 'function') { say('', 'no bpmn-moddle instance given (npm install bpmn-moddle@10.3.1)'); return result(''); }
+    const M = (type, props) => { const el = moddle.create(type); for (const [k, v] of Object.entries(props)) if (v != null) el[k] = v; return el; };
+    const all = (model && model.nodes) || [], nodes = all.filter(n => n && typeof n.type === 'string' && n.type.startsWith('bpmn.'));
+    const edges = ((model && model.edges) || []).filter(e => e && typeof e.type === 'string' && e.type.startsWith('bpmn.'));
+    const views = ((model && model.views) || []).filter(v => v && v.diagram === 'bpmn'), root = views.findIndex(v => v.id === model.root);
+    if (root > 0) views.unshift(...views.splice(root, 1)); // a reader takes the first diagram for the root
+    if (all.length > nodes.length) say('', `elements of other diagrams (${all.length - nodes.length})`);
+    if (model && model.views && model.views.length > views.length) say('', `views of other diagrams (${model.views.length - views.length})`);
+    if (model && model.ext && model.ext.bpmn) say('', 'what the model keeps under ext.bpmn (elements a reader skipped)');
+    const pools = nodes.filter(n => n.type === 'bpmn.Participant'), members = pools.flatMap(p => (p.members || []).filter(m => m && m.type === 'bpmn.Lane').map(m => [m, p]));
+    // ids: a model id that is an XML name is the element's; the others escaped, after them, so none takes a model's id
+    const used = new Set(), xid = new Map(), ok = id => typeof id === 'string' && /^[A-Za-z_][\w.-]*$/.test(id);
+    const free = base => { let id = base, k = 1; while (used.has(id)) id = `${base}-${++k}`; used.add(id); return id; };
+    const things = [...nodes, ...members.map(x => x[0]), ...edges, ...views];
+    for (const x of things) if (ok(x.id) && !used.has(x.id)) { used.add(x.id); xid.set(x, x.id); }
+    for (const x of things) if (!xid.has(x)) xid.set(x, free('_' + [...String(x.id)].map(c => (/[A-Za-z0-9.-]/.test(c) ? c : `_${c.codePointAt(0).toString(16)}_`)).join('')));
+    const els = new Map(), byId = new Map(nodes.map(n => [n.id, n])), laneOf = new Map(members.map(([m, p]) => [m.id, [m, p]]));
+    const mk = (type, x, props = {}) => {
+      const el = M(type, { id: xid.get(x), ...props }), doc = x.props && x.props.documentation;
+      if (el.id !== x.id) el.$attrs['umlimator:id'] = String(x.id);
+      if (bxStr(doc)) el.documentation = [M('bpmn:Documentation', { text: doc })];
+      for (const k of Object.keys(x)) if (!BX_FIELDS.has(k)) say(x.id, k);
+      for (const k of Object.keys(x.props || {})) if (!bxProp(x.type, k)) say(x.id, `props.${k}`);
+      if (x.ext && x.ext.bpmn) say(x.id, 'what it keeps under ext.bpmn');
+      return el;
+    };
+    // containers: a participant's process, made when something sits in it; a sub-process; the process for no pool
+    const roots = [], procs = new Map(), stores = new Map();
+    const collab = pools.length ? M('bpmn:Collaboration', { id: free('collaboration'), participants: [], messageFlows: [], artifacts: [] }) : null;
+    let loose = null;
+    const proc = p => {
+      if (!p) return loose ??= (roots.push(M('bpmn:Process', { id: free('process'), flowElements: [], artifacts: [] })), roots.at(-1));
+      if (!procs.has(p)) {
+        const r = p.props && p.props.processRef;
+        const base = `${xid.get(p)}-process`, id = free(ok(r) ? r : base);
+        if (r && !ok(r)) say(p.id, 'props.processRef, which is not an XML name');
+        else if (r && id !== r) say(p.id, `props.processRef ${r}, an id already taken (written as ${id})`);
+        else if (r && r.startsWith(base + '-') && /^\d+$/.test(r.slice(base.length + 1))) say(p.id, `props.processRef ${r}, which a reader takes for ${base} made unique`);
+        procs.set(p, M('bpmn:Process', { id, flowElements: [], artifacts: [] })); roots.push(procs.get(p));
+        els.get(p).processRef = procs.get(p);
+      }
+      return procs.get(p);
+    };
+    const holder = n => { // the process or sub-process n sits in (lanes are its pool's), or null at the top
+      for (let up = n.parent, k = 0; up != null && k <= all.length; k++) {
+        if (laneOf.has(up)) return proc(laneOf.get(up)[1]);
+        const q = byId.get(up);
+        if (!q) return null;
+        if (q.type === 'bpmn.Participant') return proc(q);
+        if (q.type === 'bpmn.SubProcess') return els.get(q);
+        up = q.parent;
+      }
+      return null;
+    };
+    for (const n of nodes) {
+      const t = n.type, k = t.slice(5), pr = n.props || {};
+      if (t === 'bpmn.Task') els.set(n, mk(BX_TASK_OUT[pr.taskType] || 'bpmn:Task', n, { name: n.label }));
+      else if (t === 'bpmn.DataObject') els.set(n, mk('bpmn:DataObjectReference', n, { name: n.label }));
+      else if (t === 'bpmn.TextAnnotation') els.set(n, mk('bpmn:TextAnnotation', n, { text: n.label }));
+      else if (t === 'bpmn.Group') {
+        const el = mk('bpmn:Group', n), value = M('bpmn:CategoryValue', { id: free(`${el.id}-value`), value: n.label });
+        roots.push(M('bpmn:Category', { id: free(`${el.id}-category`), categoryValue: [value] })); el.categoryValueRef = value; els.set(n, el);
+      } else if (BX_SAME.has(k)) {
+        const el = mk(`bpmn:${k}`, n, { name: n.label, ...(k === 'SubProcess' ? { flowElements: [], artifacts: [] } : {}) });
+        if (k in BX_DEFS) {
+          const def = pr.definition || 'none';
+          if (!BX_DEFS[k].includes(def)) say(n.id, `the definition ${def}, which a ${k} may not take`);
+          else if (def !== 'none') el.eventDefinitions = [M(BX_DEF_OUT[def], {})];
+          if (k === 'BoundaryEvent' && pr.cancelActivity === false) el.cancelActivity = false;
+        }
+        if (k === 'CallActivity' && bxStr(pr.calledElement)) el.calledElement = pr.calledElement;
+        if (k === 'DataStoreReference' && bxStr(pr.dataStoreRef)) {
+          if (!stores.has(pr.dataStoreRef)) { stores.set(pr.dataStoreRef, M('bpmn:DataStore', { id: free(`${el.id}-store`), name: pr.dataStoreRef })); roots.push(stores.get(pr.dataStoreRef)); }
+          el.dataStoreRef = stores.get(pr.dataStoreRef);
+        }
+        els.set(n, el);
+      } else say(n.id, `${t}, outside the subset`);
+    }
+    for (const [m] of members) els.set(m, mk('bpmn:Lane', m, { name: m.label, flowNodeRef: [] }));
+    const el = id => els.get(byId.get(id) || (laneOf.get(id) || [])[0]);
+    const ring = new Set(); // lanes whose parents lead round to them: written at the top of their pool
+    for (const [m, p] of members) {
+      let up = m.parent;
+      for (let k = 0; k <= members.length && up !== m.id && laneOf.has(up) && laneOf.get(up)[1] === p; k++) up = laneOf.get(up)[0].parent;
+      if (up === m.id) { ring.add(m); say(m.id, `parent ${m.parent}, which leads round to this lane (written at the top of its pool)`); }
+    }
+    const upOf = m => (ring.has(m) ? null : m.parent);
+    // place each node; a flow node in a lane is named by it and every lane around it
+    for (const n of nodes) {
+      const e = els.get(n); if (!e) continue;
+      const groups = bxProp(n.type, 'categoryValueRef') ? ((n.props && n.props.categoryValueRef) || []).map(g => el(g) && el(g).categoryValueRef).filter(Boolean) : [];
+      if (groups.length && e.$descriptor.properties.some(p => p.name === 'categoryValueRef')) e.categoryValueRef = groups;
+      else if (groups.length) e.$attrs['umlimator:groups'] = groups.map(g => g.id).join(' ');
+      if (n.type === 'bpmn.Participant') { collab.participants.push(e); if (n.props && n.props.processRef || (n.members || []).length) proc(n); continue; }
+      if (BX_LOOSE.has(n.type) && laneOf.has(n.parent)) say(n.id, `parent ${n.parent}, a lane, which BPMN gives no ${n.type.slice(5)} (written in its pool)`);
+      const c = holder(n), art = n.type === 'bpmn.TextAnnotation' || n.type === 'bpmn.Group';
+      if (art) (c || collab || proc(null)).artifacts.push(e);
+      else {
+        (c || proc(null)).flowElements.push(e);
+        if (n.type === 'bpmn.DataObject') { e.dataObjectRef = M('bpmn:DataObject', { id: free(`${e.id}-object`) }); (c || proc(null)).flowElements.push(e.dataObjectRef); }
+      }
+      if (n.type === 'bpmn.BoundaryEvent' && n.props && el(n.props.attachedTo)) e.attachedToRef = el(n.props.attachedTo);
+      for (let l = laneOf.get(n.parent), k = 0; l && k <= members.length; l = laneOf.get(upOf(l[0])), k++) els.get(l[0]).flowNodeRef.push(e);
+    }
+    for (const p of pools) { // lane sets, nested by parent, in members order
+      const ms = members.filter(x => x[1] === p).map(x => x[0]); if (!ms.length) continue;
+      const own = new Set(ms.map(m => m.id)), set = (ls, base) => (ls.length ? M('bpmn:LaneSet', { id: free(`${base}-lanes`), lanes: ls.map(m => els.get(m)) }) : null);
+      proc(p).laneSets = [set(ms.filter(m => !own.has(upOf(m))), xid.get(p))];
+      for (const m of ms) { const s = set(ms.filter(c => upOf(c) === m.id), xid.get(m)); if (s) els.get(m).childLaneSet = s; }
+    }
+    // lines: each where BPMN keeps it
+    const lines = new Map();
+    for (const e of edges) {
+      const a = byId.get(e.from), b = byId.get(e.to), A = a && els.get(a), B = b && els.get(b), pr = e.props || {};
+      if (!A || !B) { say(e.id, `${e.type} whose ${A ? 'target' : 'source'} is not written`); continue; }
+      let x = null;
+      if (e.type === 'bpmn.SequenceFlow') { x = mk('bpmn:SequenceFlow', e, { name: e.label, sourceRef: A, targetRef: B }); (holder(a) || proc(null)).flowElements.push(x); }
+      else if (e.type === 'bpmn.MessageFlow') {
+        if (!collab) { say(e.id, 'a message flow in a model with no participant'); continue; }
+        collab.messageFlows.push(x = mk('bpmn:MessageFlow', e, { name: e.label, sourceRef: A, targetRef: B }));
+      } else if (e.type === 'bpmn.Association') {
+        x = mk('bpmn:Association', e, { sourceRef: A, targetRef: B, associationDirection: { one: 'One', both: 'Both' }[pr.direction] });
+        const at = [a, b].find(n => n.type === 'bpmn.TextAnnotation') || a;
+        (holder(at) || collab || proc(null)).artifacts.push(x);
+      } else if (e.type === 'bpmn.DataAssociation') {
+        const data = n => n.type === 'bpmn.DataObject' || n.type === 'bpmn.DataStoreReference';
+        const takes = (n, dir) => BX_ACTIVITY.has(n.type) || (dir === 'in' ? ['bpmn.EndEvent', 'bpmn.IntermediateThrowEvent'] : ['bpmn.StartEvent', 'bpmn.IntermediateCatchEvent', 'bpmn.BoundaryEvent']).includes(n.type);
+        if (data(a) && takes(b, 'in')) {
+          const target = BX_ACTIVITY.has(b.type) ? M('bpmn:Property', { id: free(`${xid.get(e)}-target`), name: '__targetRef_placeholder' }) : M('bpmn:DataInput', { id: free(`${xid.get(e)}-target`) });
+          (BX_ACTIVITY.has(b.type) ? (B.properties ??= []) : (B.dataInputs ??= [])).push(target);
+          (B.dataInputAssociations ??= []).push(x = mk('bpmn:DataInputAssociation', e, { sourceRef: [A], targetRef: target }));
+        } else if (data(b) && takes(a, 'out')) (A.dataOutputAssociations ??= []).push(x = mk('bpmn:DataOutputAssociation', e, { targetRef: B }));
+        else { say(e.id, 'a data association against BPMN\'s direction (data-ends)'); continue; }
+      } else { say(e.id, `${e.type}, outside the subset`); continue; }
+      if (e.label != null && (e.type === 'bpmn.Association' || e.type === 'bpmn.DataAssociation')) say(e.id, 'label, which BPMN gives no association');
+      lines.set(e, x);
+    }
+    // what a reader derives from the diagrams, against the model: a view's subject (a sub-process), its parent (the first
+    // other view showing its subject), a sub-process's opensView (the first view with it as subject), a node in no view
+    const sub = v => { const s = byId.get(v.subject); return s && s.type === 'bpmn.SubProcess' && els.get(s) ? s : null; };
+    const opens = new Map(), showing = new Map(); // a sub-process -> the view it opens; a node -> the first two views showing it
+    for (const v of views) {
+      if (sub(v) && !opens.has(v.subject)) opens.set(v.subject, v.id);
+      for (const id of v.nodeIds || []) { const f = showing.get(id) || []; if (f.length < 2 && !f.includes(v)) showing.set(id, [...f, v]); }
+    }
+    for (const v of views) {
+      if (v.subject != null && !sub(v)) say(v.id, `the view's subject ${v.subject}, which is no sub-process written`);
+      const w = sub(v) && (showing.get(v.subject) || []).find(x => x !== v), parent = w ? w.id : null;
+      if ((v.parent ?? null) !== parent) say(v.id, `the view's parent ${v.parent ?? null} (a reader takes ${parent} from its subject)`);
+      for (const id of v.nodeIds || []) if (!els.get(byId.get(id))) say(v.id, `the view's node ${id}, which is no element written`);
+    }
+    for (const n of nodes) {
+      if ((n.opensView ?? null) !== (opens.get(n.id) ?? null)) say(n.id, `opensView ${n.opensView ?? 'none'} (a reader takes ${opens.get(n.id) ?? null}, the first view with it as subject)`);
+      if (els.get(n) && views.length && !showing.has(n.id)) say(n.id, `in no view (a reader puts it in the first, ${views[0].id})`);
+    }
+    // diagram interchange: a diagram per view, viewId's from geo, the others on a plain grid
+    const G = new Map(((geo && geo.nodes) || []).map(g => [g.id, g])), GE = new Map(((geo && geo.edges) || []).map(g => [g.id, g]));
+    const diagrams = views.map(v => {
+      for (const k of Object.keys(v)) if (!['id', 'diagram', 'title', 'parent', 'subject', 'nodeIds'].includes(k)) say(v.id, `the view's ${k}`);
+      const box = new Map(), ids = new Set(v.nodeIds || []), planeElement = [], mine = v.id === viewId;
+      const shape = (x, more) => {
+        const g = mine && G.get(x.id), [w, h] = BX_SIZE[x.type] || (bxEvent(x.type) ? [36, 36] : [100, 80]), k = box.size;
+        const b = g ? { x: g.x, y: g.y, w: g.w, h: g.h } : { x: 40 + (k % 8) * 180, y: 40 + Math.floor(k / 8) * 140, w, h };
+        box.set(x.id, b);
+        planeElement.push(M('bpmndi:BPMNShape', { id: free(`${els.get(x).id}_di`), bpmnElement: els.get(x), ...more,
+          bounds: M('dc:Bounds', { x: b.x, y: b.y, width: b.w, height: b.h }) }));
+      };
+      for (const id of v.nodeIds || []) {
+        const n = byId.get(id); if (!n || !els.get(n) || box.has(id)) continue;
+        shape(n, n.type === 'bpmn.Participant' ? { isHorizontal: true } : n.type === 'bpmn.SubProcess' ? { isExpanded: nodes.some(c => c.parent === id && ids.has(c.id)) } : {});
+        if (n.type === 'bpmn.Participant') for (const [m] of members.filter(x => x[1] === n)) shape(m, { isHorizontal: true });
+      }
+      for (const [e, x] of lines) {
+        const a = box.get(e.from), b = box.get(e.to), g = mine && GE.get(e.id); if (!a || !b) continue;
+        const pts = g && Array.isArray(g.pts) && g.pts.length > 1 ? g.pts : [[a.x + a.w / 2, a.y + a.h / 2], [b.x + b.w / 2, b.y + b.h / 2]];
+        planeElement.push(M('bpmndi:BPMNEdge', { id: free(`${x.id}_di`), bpmnElement: x, waypoint: pts.map(([px, py]) => M('dc:Point', { x: px, y: py })) }));
+      }
+      const subject = v.subject && byId.get(v.subject), d = M('bpmndi:BPMNDiagram', { id: xid.get(v), name: v.title });
+      if (d.id !== v.id) d.$attrs['umlimator:id'] = String(v.id);
+      d.plane = M('bpmndi:BPMNPlane', { id: free(`${d.id}-plane`), bpmnElement: (subject && els.get(subject)) || collab || proc(null), planeElement });
+      return d;
+    });
+    if (collab) roots.unshift(collab);
+    const defs = M('bpmn:Definitions', { id: free('definitions'), name: model && bxStr(model.title), targetNamespace: BX_NS, exporter: 'umlimator', rootElements: roots, diagrams });
+    defs.$attrs['xmlns:umlimator'] = BX_NS;
+    return result((await moddle.toXML(defs, { format: true })).xml);
+  } catch (e) {
+    say('', `the model (${bxMsg(e)})`);
+    return result('');
+  }
+}