umlimator 0.19.0 → 0.20.0

package/README.md

@@ -58,6 +58,16 @@ drill-down, a data pipeline, an AI agent's skills, and host pages for embedding,
   ([`examples/bookshop-packages.json`](examples/bookshop-packages.json), [what it covers](docs/conformance/uml-package.md)).
   Ownership is edited by dropping an element into a box, or with the Owner field; both are checked by their types'
   rules, and the PDF's tables list slots and element kinds.
+- **UML sequence and communication diagrams** (0.20.0): lifelines on a time axis with calls, async messages, replies,
+  creates and deletes, activation bars derived from the messages, `alt`, `opt`, `loop`, `par` and `break` frames with
+  their guards, and interaction uses ([`examples/checkout-sequence.json`](examples/checkout-sequence.json),
+  [what it covers](docs/conformance/uml-sequence.md)); the same interaction as lifelines joined by connectors, each
+  link's messages a stack of numbered rows (1, 1.1, 1.1.2) ([`examples/checkout-communication.json`](examples/checkout-communication.json),
+  [what it covers](docs/conformance/uml-communication.md)). Messages are inserted, moved in time, wrapped in a frame and
+  deleted on the canvas, by pointer and by key, each gesture an `edit` event; checked by the types' rules; a sequence
+  diagram is read from and written to Mermaid's `sequenceDiagram`, and an OpenTelemetry trace becomes one
+  (`umlimator.py trace --diagram uml.sequence`). The MCP server, the `map-repo` skill and the diff Action learn these
+  types in one package after 0.20.0; until then a reorder of a view's messages shows in a diff as changed, not moved.
 - **Export**: any view as a stand-alone SVG or PNG, in the browser or from the CLI; the whole map as one PDF to hand in
   for a review: a cover with the contents, each view with its legend and tables of its cards, lines and boxes, then the
   rules (`umlimator.py pdf`).
@@ -80,7 +90,7 @@ drill-down, a data pipeline, an AI agent's skills, and host pages for embedding,
 npm install umlimator
 ```
 
-Or from GitHub, at a tag or any commit: `"umlimator": "github:zintaen/umlimator#v0.19.0"`. npm 12 refuses git
+Or from GitHub, at a tag or any commit: `"umlimator": "github:zintaen/umlimator#v0.20.0"`. npm 12 refuses git
 dependencies unless the project opts in, so that also needs `allow-git=root` in the `.npmrc` next to `package.json`.
 
 ## Embed
@@ -129,7 +139,7 @@ function MapView({ model, onSelect }) {
   `map.shapes` reads the notation shown and sets another (`null`: each view's own again); the cards are drawn again from
   the geometry they have, with the camera, selection and marks kept, and nothing is laid out.
 - `editable: true` turns on editing gestures ([docs/editing.md](docs/editing.md); `examples/edit.html` is a working host).
-- `import { render, apply, history } from 'umlimator/all'` draws diagram types too: a class, object or package diagram, whose gestures emit
+- `import { render, apply, history } from 'umlimator/all'` draws diagram types too: a class, object, package, sequence or communication diagram, whose gestures emit
   `edit` transactions that `apply(model, e.commands)` turns into the next model (`examples/class-editor.html` is a
   working host). `umlimator` alone draws maps, and a typed view as plain cards with a warning.
 - `diff(before, after)` returns `after` with each card and line marked added, changed or removed, what changed in words,
@@ -208,8 +218,8 @@ path. The full schema is `engine/references/schema.md` (§ Map model); `examples
 A model file that starts with `"$schema": "<path to>/umlimator.schema.json"` (exported as `umlimator/schema.json`)
 gets completion and checks in editors, and `validate(model)` lists its errors and warnings, each with where it is.
 `"schemaVersion": 2` marks a model that may hold typed elements and typed views (`docs/diagrams/model.md`). A view whose
-`diagram` is `"uml.class"`, `"uml.object"` or `"uml.package"` is a UML class, object or package diagram, drawn by
-`umlimator/all` and the CLI; a type not drawn yet shows its
+`diagram` is `"uml.class"`, `"uml.object"`, `"uml.package"`, `"uml.sequence"` or `"uml.communication"` is a UML class, object,
+package, sequence or communication diagram, drawn by `umlimator/all` and the CLI; a type not drawn yet shows its
 nodes as plain cards, with a warning. A model with no `schemaVersion` is a map, as always, and a version newer than the
 module reads is an error.
 
@@ -264,6 +274,19 @@ In a version-2 model, a class diagram (`examples/sales-classes.json`; every fiel
 | view | `direction` | `"down"` lays it out top to bottom, the general class above (default `"right"`) |
 | view | `present` | per element: `collapsed` compartments, and at most `rows` rows each, then "+k more" |
 
+A sequence diagram (`examples/checkout-sequence.json`, [`docs/conformance/uml-sequence.md`](docs/conformance/uml-sequence.md))
+and a communication diagram (`examples/checkout-communication.json`,
+[`docs/conformance/uml-communication.md`](docs/conformance/uml-communication.md)), from 0.20.0:
+
+| On | Field | What it does |
+|---|---|---|
+| node | `type` | `uml.Lifeline`; its `props.represents` is what it is an instance of, drawn `name : Type` |
+| edge | `type` | `uml.Message`; on a communication view also `uml.Connector`, the link messages are sent along |
+| edge | `props` | a message's `sort` (`call`, `async`, `reply`, `create`, `delete`) and a reply's `replyTo`, the call it answers |
+| view | `diagram` | `"uml.sequence"` or `"uml.communication"` |
+| view | `edges` | a sequence view's messages and interaction uses (`uml.InteractionUse`, `props.covers`), inline and in time order; a communication view's connectors, then its messages, by id, in order. Bars and numbers are derived |
+| view | `fragments` | a sequence view's combined fragments (`uml.CombinedFragment`, `props.operator`), each with its operands as `members` (`label` the guard); a message's or fragment's `parent` is its operand |
+
 ## Command line
 
 ```bash
@@ -279,11 +302,13 @@ python3 umlimator.py check page.html --expand                          # also ea
 python3 umlimator.py record bike-share.html --story ride --out ride.png   # bike-share's story as an animated PNG, its tours riding
 python3 umlimator.py import workspace.dsl --out model.json            # a diagram you have already, as a model
 python3 umlimator.py import classes.mmd --out classes.json            # a Mermaid classDiagram, as a UML class diagram (needs Node)
+python3 umlimator.py import checkout.mmd --out checkout.json          # a Mermaid sequenceDiagram, as a UML sequence diagram (needs Node)
 python3 umlimator.py render examples/sales-classes.json --out classes.html   # a class diagram's page; stills, check and pdf take it too
 docker compose config --format json > compose.json && python3 umlimator.py import compose.json --out model.json
 kubectl get deploy,sts,svc,ing -A -o json > cluster.json && python3 umlimator.py import cluster.json --out model.json
 python3 umlimator.py pdf page.html --out map.pdf                       # every view in one PDF: a cover, each view with its tables, the rules
 python3 umlimator.py trace model.json trace.json --view ride-end --match match.json --out model.json   # an OTLP trace kept as a numbered view
+python3 umlimator.py trace model.json trace.json --view ride-end --match match.json --diagram uml.sequence --out traced.json  # ... as a UML sequence diagram, in a version-2 model
 python3 umlimator.py mcp model.json                                    # an MCP server over stdio, for an AI assistant (below)
 ```
 
@@ -291,7 +316,8 @@ python3 umlimator.py mcp model.json                                    # an MCP
 
 `import` reads Structurizr DSL (people, systems, containers and components, their relationships, and the workspace's
 views), C4-PlantUML (its element, relationship and boundary macros), Mermaid (`flowchart` or `graph`, and `C4Context`,
-`C4Container` or `C4Component`; a `classDiagram` becomes a UML class diagram, read through Node), and the JSON of `docker compose config` (services, `depends_on`, networks) and of
+`C4Container` or `C4Component`; a `classDiagram` becomes a UML class diagram and a `sequenceDiagram` a UML sequence
+diagram, each read through Node), and the JSON of `docker compose config` (services, `depends_on`, networks) and of
 `kubectl get` (workloads, Services, Ingresses). It tells the format from the content, then the extension; `--format`
 decides. Groups, boundaries, subgraphs, networks and namespaces become boxes; Structurizr's views stay views, a card
 opening the view below it; `examples/clinic.json` is `examples/clinic.dsl`, imported. What each element becomes, and
@@ -342,7 +368,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: zintaen/umlimator@v0.19.0
+      - uses: zintaen/umlimator@v0.20.0
         with:
           models: "docs/*.json"   # optional: where the models are (default: every .json that is a map model)
 ```

package/lib/umlimator-all.js

@@ -1701,7 +1701,9 @@ function routeAudit(geo, where, only, refs) { // only: a set of edges; counts ju
 const box = n => ({ x: n.x, y: n.y, w: n.w, h: n.h });
 function overlapIssues(geo, where, refs) {
   const issues = [], nodes = geo.nodes, say = teller(issues, refs);
-  for (let i = 0; i < nodes.length; i++) for (let j = i + 1; j < nodes.length; j++) if (hit(box(nodes[i]), box(nodes[j]), -1)) say(`${where}: nodes "${nodes[i].label}" and "${nodes[j].label}" overlap`, nodes[i], nodes[j]);
+  const inside = (a, b) => a.x >= b.x - 1 && a.y >= b.y - 1 && a.x + a.w <= b.x + b.w + 1 && a.y + a.h <= b.y + b.h + 1;
+  const holds = (a, b) => (a.holder && inside(b, a)) || (b.holder && inside(a, b)); // a holder (a sequence's frame) may hold what it meets, not cross it
+  for (let i = 0; i < nodes.length; i++) for (let j = i + 1; j < nodes.length; j++) if (hit(box(nodes[i]), box(nodes[j]), -1) && !holds(nodes[i], nodes[j])) say(`${where}: nodes "${nodes[i].label}" and "${nodes[j].label}" overlap`, nodes[i], nodes[j]);
   return issues;
 }
 function leaveIssues(geo, where, refs) {
@@ -1724,7 +1726,7 @@ function leaveIssues(geo, where, refs) {
 function auditSvg(svg, geo, where) {
   const issues = overlapIssues(geo, where), R = box;
   const T = [...svg.querySelectorAll('text[data-t]')].map(t => { let b; try { b = t.getBBox(); } catch (_) { return null; } return { t: t.dataset.t, o: t.dataset.o, txt: t.textContent, b: { x: b.x, y: b.y, w: b.width, h: b.height } }; }).filter(x => x && x.b.w);
-  const nodes = geo.nodes, faces = Object.fromEntries([...svg.querySelectorAll('.node[data-face]')].map(g => [g.dataset.id, g.dataset.face.split(' ').map(Number)])); // a shape's face (0.15.0)
+  const nodes = geo.nodes.filter(n => !n.holder), faces = Object.fromEntries([...svg.querySelectorAll('.node[data-face]')].map(g => [g.dataset.id, g.dataset.face.split(' ').map(Number)])); // a shape's face (0.15.0)
   T.forEach(a => {
     if (a.t === 'lt' || a.t === 'ft') {
       nodes.forEach(n => { if (hit(a.b, R(n), -1)) issues.push(`${where}: lane "${a.txt}": header covers node "${n.label}"`); });
@@ -7955,11 +7957,11 @@ function sqRun(model, view) {
     ...o.heads.map((h, j) => { const n = H.get(h.id), st = sqStereo(n);
       return { ...h, shape: 'lifeline', type: 'uml.Lifeline', label: sqHeadText(n), stereotypes: st, k: 'file', stem: o.stems[j], aria: `Lifeline ${sqHeadText(n)}${st.length ? ` (${st.join(', ')})` : ''}` }; }),
     ...o.frames.flatMap(fr => { const f = X.F.get(fr.id), op = sqOperator(f), ms = SQ_ARR(f.members).filter(SQ_OBJ);
-      return [{ id: fr.id, shape: 'frame', type: 'uml.CombinedFragment', label: op, k: 'file', x: fr.x, y: fr.y, w: fr.w, h: fr.h, aria: `Combined fragment ${op}, ${ms.length} ${ms.length === 1 ? 'operand' : 'operands'}` },
+      return [{ id: fr.id, shape: 'frame', type: 'uml.CombinedFragment', label: op, k: 'file', holder: true, x: fr.x, y: fr.y, w: fr.w, h: fr.h, aria: `Combined fragment ${op}, ${ms.length} ${ms.length === 1 ? 'operand' : 'operands'}` },
         ...fr.parts.map(p => { const m = ms.find(x => x.id === p.id) || {}, k = direct(p.id);
-          return { ...p, shape: 'operand', type: 'uml.InteractionOperand', label: m.label, k: 'file', aria: `Operand ${SQ_HAS(m.label) ? m.label + ' ' : ''}of ${op}, ${k} ${k === 1 ? 'occurrence' : 'occurrences'}` }; })]; }),
+          return { ...p, shape: 'operand', type: 'uml.InteractionOperand', label: m.label, k: 'file', holder: true, aria: `Operand ${SQ_HAS(m.label) ? m.label + ' ' : ''}of ${op}, ${k} ${k === 1 ? 'occurrence' : 'occurrences'}` }; })]; }),
     ...o.spans.map(s => { const u = X.byId.get(s.id), cs = SQ_ARR(sqProps(u.el).covers).filter(id => H.has(id)), all = heads.map(n => n.id), ids = cs.length ? all.filter(id => cs.includes(id)) : all;
-      return { ...s, shape: 'use', type: 'uml.InteractionUse', label: String(u.el.label ?? ''), k: 'file',
+      return { ...s, shape: 'use', type: 'uml.InteractionUse', label: String(u.el.label ?? ''), k: 'file', holder: true,
         aria: `Interaction use ${u.el.label ?? ''}${ids.length ? `, over ${sqName(H.get(ids[0]))}${ids.length > 1 ? ' to ' + sqName(H.get(ids[ids.length - 1])) : ''}` : ''}` }; }),
   ];
   const byId = Object.fromEntries(nodes.map(n => [n.id, n]));

package/lib/umlimator.d.ts

@@ -48,8 +48,8 @@ export interface MapNode {
 /** A typed element in schema version 2's envelope (docs/diagrams/model.md §1): a node, a member, a typed edge, a
  *  fragment. Nodes, edges, members and fragments share one id space; an id never contains "->". A typed edge is an
  *  Element with `from` and `to`, which may name a member. A typed view is a MapView with `diagram` (uml.class), and may
- *  have `subject`, `direction` ('right' | 'down'), `notation`, `present`, `fragments` and `timeline`. umlimator/all draws `uml.class` (0.18.0), `uml.object` and `uml.package` (0.19.0); other types draw as plain cards.
- *  From 0.19.0 those three draw a shown package that owns something the view shows as a box holding it (`parent`), and
+ *  have `subject`, `direction` ('right' | 'down'), `notation`, `present`, `fragments` and `timeline`. umlimator/all draws `uml.class` (0.18.0), `uml.object` and `uml.package` (0.19.0), `uml.sequence` and `uml.communication` (0.20.0); other types draw as plain cards.
+ *  From 0.19.0 the class, object and package types draw a shown package that owns something the view shows as a box holding it (`parent`), and
  *  qualify names (`sales::Order`) from the nearest shown owner, the view's `subject`, or the top. */
 export interface Element {
   id: string; type: string; label?: string; parent?: string; props?: Record<string, unknown>; members?: Element[];
@@ -99,6 +99,33 @@ export interface UmlPackageImportProps { visibility?: 'public' | 'private'; ster
 /** What a typed view shows of one element, in its `present` by the element's id: compartments not drawn, divider and
  *  all, and at most `rows` rows in each, then "+k more". */
 export interface UmlPresent { collapsed?: ('attributes' | 'operations' | 'literals')[]; rows?: number }
+/** The sequence diagram's vocabulary (a view with `diagram: 'uml.sequence'`, umlimator/all from 0.20.0;
+ *  docs/conformance/uml-sequence.md). Lifelines are model nodes the view lists in `nodeIds`, left to right. Messages and
+ *  interaction uses are inline in the view's `edges`, in time order; a fragment's content is one run there, operand by
+ *  operand. Combined fragments are in the view's `fragments`, each with its operands as `members`; an occurrence's or a
+ *  fragment's `parent` is the operand that holds it. Activations and message numbers are derived, never stored. */
+export type UmlSequenceElementType = 'uml.Lifeline' | 'uml.InteractionUse' | 'uml.CombinedFragment';
+export type UmlSequenceMemberType = 'uml.InteractionOperand';
+export type UmlSequenceLineType = 'uml.Message';
+/** A lifeline's props: what it represents, by name, as text (drawn `name : Type`); stereotype `actor` draws «actor». */
+export interface UmlLifelineProps { represents?: string; stereotypes?: string[]; [key: string]: unknown }
+/** A message's kind: a call (filled arrow, the default), async (open arrow), reply (dashed, open), create (dashed, open;
+ *  the receiver's head is lowered to it) or delete (the receiver's stem ends in a cross). */
+export type UmlMessageSort = 'call' | 'async' | 'reply' | 'create' | 'delete';
+/** A message's props: its sort; a reply's `replyTo`, the id of the earlier call it answers. */
+export interface UmlMessageProps { sort?: UmlMessageSort; replyTo?: string; stereotypes?: string[]; [key: string]: unknown }
+/** An interaction use's props: the lifelines it covers (next to each other in `nodeIds`), and the view it refers to. */
+export interface UmlInteractionUseProps { covers?: string[]; refersTo?: string; [key: string]: unknown }
+/** A combined fragment's operator; any other is drawn by its name, with a warning. opt, loop and break have one operand,
+ *  whose `label` is its guard. */
+export type UmlInteractionOperator = 'alt' | 'opt' | 'loop' | 'par' | 'break';
+export interface UmlCombinedFragmentProps { operator?: UmlInteractionOperator; [key: string]: unknown }
+/** The communication diagram's vocabulary (a view with `diagram: 'uml.communication'`, umlimator/all from 0.20.0;
+ *  docs/conformance/uml-communication.md): lifelines; connectors and messages are model edges the view's `edges` lists,
+ *  connectors first. Only the messages' order means anything; their numbers (1, 1.1, 1.1.2) are derived. A message's
+ *  props are UmlMessageProps; a message needs a connector between its two lifelines. */
+export type UmlCommunicationElementType = 'uml.Lifeline';
+export type UmlCommunicationLineType = 'uml.Connector' | 'uml.Message';
 /** What a line means, drawn as its colour: calls (the default), feeds (hands work on), triggers (suggests, offers, fires),
  *  state (reads or writes a file, board or config: a thinner line, a muted label, no flow) and guard (a hook steps in).
  *  Colours are --um-w-<kind>. An edge's `style` (emphasis, dashed, security) wins over its kind's colour. */
@@ -139,7 +166,8 @@ export interface MapEdge {
 }
 export interface MapView {
   id: string; parent?: string | null; title?: string; nodeIds: string[];
-  edges?: (string | MapEdge)[]; layout?: Record<string, [number, number]>; repair?: boolean;
+  /** Model line ids or lines of its own; in a sequence view (0.20.0) its messages and interaction uses (Elements), in time order. */
+  edges?: (string | MapEdge | Element)[]; layout?: Record<string, [number, number]>; repair?: boolean;
   /** Cards 80 px tall that show their sub-line and then their chips (`verbs`) on a third line. Default: 64 px, and a card's
    *  chips take its sub-line's place. A script card (no kind) shows no sub-line either way. */
   subAndChips?: boolean;

package/lib/umlimator.js

@@ -1700,7 +1700,9 @@ function routeAudit(geo, where, only, refs) { // only: a set of edges; counts ju
 const box = n => ({ x: n.x, y: n.y, w: n.w, h: n.h });
 function overlapIssues(geo, where, refs) {
   const issues = [], nodes = geo.nodes, say = teller(issues, refs);
-  for (let i = 0; i < nodes.length; i++) for (let j = i + 1; j < nodes.length; j++) if (hit(box(nodes[i]), box(nodes[j]), -1)) say(`${where}: nodes "${nodes[i].label}" and "${nodes[j].label}" overlap`, nodes[i], nodes[j]);
+  const inside = (a, b) => a.x >= b.x - 1 && a.y >= b.y - 1 && a.x + a.w <= b.x + b.w + 1 && a.y + a.h <= b.y + b.h + 1;
+  const holds = (a, b) => (a.holder && inside(b, a)) || (b.holder && inside(a, b)); // a holder (a sequence's frame) may hold what it meets, not cross it
+  for (let i = 0; i < nodes.length; i++) for (let j = i + 1; j < nodes.length; j++) if (hit(box(nodes[i]), box(nodes[j]), -1) && !holds(nodes[i], nodes[j])) say(`${where}: nodes "${nodes[i].label}" and "${nodes[j].label}" overlap`, nodes[i], nodes[j]);
   return issues;
 }
 function leaveIssues(geo, where, refs) {
@@ -1723,7 +1725,7 @@ function leaveIssues(geo, where, refs) {
 function auditSvg(svg, geo, where) {
   const issues = overlapIssues(geo, where), R = box;
   const T = [...svg.querySelectorAll('text[data-t]')].map(t => { let b; try { b = t.getBBox(); } catch (_) { return null; } return { t: t.dataset.t, o: t.dataset.o, txt: t.textContent, b: { x: b.x, y: b.y, w: b.width, h: b.height } }; }).filter(x => x && x.b.w);
-  const nodes = geo.nodes, faces = Object.fromEntries([...svg.querySelectorAll('.node[data-face]')].map(g => [g.dataset.id, g.dataset.face.split(' ').map(Number)])); // a shape's face (0.15.0)
+  const nodes = geo.nodes.filter(n => !n.holder), faces = Object.fromEntries([...svg.querySelectorAll('.node[data-face]')].map(g => [g.dataset.id, g.dataset.face.split(' ').map(Number)])); // a shape's face (0.15.0)
   T.forEach(a => {
     if (a.t === 'lt' || a.t === 'ft') {
       nodes.forEach(n => { if (hit(a.b, R(n), -1)) issues.push(`${where}: lane "${a.txt}": header covers node "${n.label}"`); });

package/lib/umlimator.schema.json

@@ -419,7 +419,7 @@
      }
     },
     "type": {
-     "description": "Schema version 2: the element's type, <notation>.<Name> (uml.Class). validate() checks typed fields only in a model with schemaVersion 2. The class diagram (uml.class, 0.18.0): uml.Class, uml.Interface, uml.Enumeration, uml.DataType, uml.PrimitiveType, uml.Package and uml.Comment; their members uml.Property, uml.Operation and uml.EnumerationLiteral. The object diagram (uml.object, 0.19.0): uml.InstanceSpecification and uml.Comment; an instance's members uml.Slot. The package diagram (uml.package, 0.19.0): uml.Package and the class diagram's classifiers, and uml.Comment.",
+     "description": "Schema version 2: the element's type, <notation>.<Name> (uml.Class). validate() checks typed fields only in a model with schemaVersion 2. The class diagram (uml.class, 0.18.0): uml.Class, uml.Interface, uml.Enumeration, uml.DataType, uml.PrimitiveType, uml.Package and uml.Comment; their members uml.Property, uml.Operation and uml.EnumerationLiteral. The object diagram (uml.object, 0.19.0): uml.InstanceSpecification and uml.Comment; an instance's members uml.Slot. The package diagram (uml.package, 0.19.0): uml.Package and the class diagram's classifiers, and uml.Comment. The sequence and communication diagrams (uml.sequence, uml.communication, 0.20.0): uml.Lifeline.",
      "examples": [
       "uml.Class",
       "uml.Interface",
@@ -428,14 +428,15 @@
       "uml.PrimitiveType",
       "uml.Package",
       "uml.Comment",
-      "uml.InstanceSpecification"
+      "uml.InstanceSpecification",
+      "uml.Lifeline"
      ]
     },
     "parent": {
      "description": "Schema version 2: the element that owns it (a package, a composite state, a lane). From 0.19.0 a class, object or package view draws a shown package that owns something it shows as a box holding it."
     },
     "props": {
-     "description": "Schema version 2: the type's own properties. The class diagram (uml.class, 0.18.0): isAbstract and stereotypes on a classifier; on a member, the fields of its UML text (docs/conformance/uml-class.md). The object diagram (uml.object, 0.19.0): an instance's classifier and stereotypes; a slot's value (docs/conformance/uml-object.md).",
+     "description": "Schema version 2: the type's own properties. The class diagram (uml.class, 0.18.0): isAbstract and stereotypes on a classifier; on a member, the fields of its UML text (docs/conformance/uml-class.md). The object diagram (uml.object, 0.19.0): an instance's classifier and stereotypes; a slot's value (docs/conformance/uml-object.md). The sequence and communication diagrams (uml.sequence, uml.communication, 0.20.0): a lifeline's represents, and stereotypes (actor draws «actor» over its name).",
      "anyOf": [
       {
        "type": "object",
@@ -448,6 +449,9 @@
         },
         "classifier": {
          "description": "uml.InstanceSpecification: the name (or qualified name, sales::Order) of the classifier it is an instance of, as text; drawn name : Classifier, underlined."
+        },
+        "represents": {
+         "description": "uml.Lifeline: what it is an instance of, by name, as text; drawn name : Type (docs/diagrams/risks.md M8)."
         }
        }
       },
@@ -814,7 +818,7 @@
      "description": "When the line is used."
     },
     "type": {
-     "description": "Schema version 2: the element's type, <notation>.<Name> (uml.Class). The class diagram (uml.class, 0.18.0): uml.Association, uml.Generalization (from the specific to the general), uml.InterfaceRealization (to the interface), uml.Dependency (from the client) and uml.CommentLink (from the comment). The object diagram (uml.object, 0.19.0): uml.Link and uml.CommentLink. The package diagram (uml.package, 0.19.0): uml.PackageImport and uml.PackageMerge (from the importing or merging package), uml.Dependency and uml.CommentLink.",
+     "description": "Schema version 2: the element's type, <notation>.<Name> (uml.Class). The class diagram (uml.class, 0.18.0): uml.Association, uml.Generalization (from the specific to the general), uml.InterfaceRealization (to the interface), uml.Dependency (from the client) and uml.CommentLink (from the comment). The object diagram (uml.object, 0.19.0): uml.Link and uml.CommentLink. The package diagram (uml.package, 0.19.0): uml.PackageImport and uml.PackageMerge (from the importing or merging package), uml.Dependency and uml.CommentLink. The sequence diagram (uml.sequence, 0.20.0): uml.Message, inline in its view's edges, in time order. The communication diagram (uml.communication, 0.20.0): uml.Connector and uml.Message, model lines its view lists, connectors first; only the messages' order means anything.",
      "examples": [
       "uml.Association",
       "uml.Generalization",
@@ -823,14 +827,16 @@
       "uml.CommentLink",
       "uml.Link",
       "uml.PackageImport",
-      "uml.PackageMerge"
+      "uml.PackageMerge",
+      "uml.Message",
+      "uml.Connector"
      ]
     },
     "parent": {
-     "description": "Schema version 2: the element that owns it (a package, a composite state, a lane)."
+     "description": "Schema version 2: the element that owns it (a package, a composite state, a lane). In a sequence view: the operand (uml.InteractionOperand) of one of its fragments that holds the message; none at the top level."
     },
     "props": {
-     "description": "Schema version 2: the type's own properties. The class diagram (uml.class, 0.18.0): an association's ends, and stereotypes on any line («use» on a dependency). The object diagram (uml.object, 0.19.0): a link's association and the roles at its ends. The package diagram (uml.package, 0.19.0): a package import's visibility.",
+     "description": "Schema version 2: the type's own properties. The class diagram (uml.class, 0.18.0): an association's ends, and stereotypes on any line («use» on a dependency). The object diagram (uml.object, 0.19.0): a link's association and the roles at its ends. The package diagram (uml.package, 0.19.0): a package import's visibility. The sequence and communication diagrams (0.20.0): a message's sort and replyTo.",
      "anyOf": [
       {
        "type": "object",
@@ -900,6 +906,19 @@
         },
         "visibility": {
          "description": "uml.PackageImport: public (the default, drawn «import») or private (drawn «access»)."
+        },
+        "sort": {
+         "description": "uml.Message: call (the default), async, reply, create or delete; any other is drawn as a call, with a warning.",
+         "examples": [
+          "call",
+          "async",
+          "reply",
+          "create",
+          "delete"
+         ]
+        },
+        "replyTo": {
+         "description": "uml.Message, a reply: the id of the earlier call it answers, which it goes back along."
         }
        }
       },
@@ -985,7 +1004,7 @@
     },
     "edges": {
      "type": "array",
-     "description": "The lines this view draws: model line ids or lines of its own. Default: every model line between its cards; [] draws none.",
+     "description": "The lines this view draws: model line ids or lines of its own. Default: every model line between its cards; [] draws none. In a sequence view (uml.sequence, 0.20.0): its occurrences in time order, each message and interaction use inline, a fragment's operand by operand.",
      "items": {
       "anyOf": [
        {
@@ -993,6 +1012,49 @@
        },
        {
         "$ref": "#/$defs/edge"
+       },
+       {
+        "type": "object",
+        "required": [
+         "id",
+         "type"
+        ],
+        "properties": {
+         "type": {
+          "const": "uml.InteractionUse"
+         },
+         "label": {
+          "description": "The interaction it refers to, by name."
+         },
+         "parent": {
+          "description": "The operand (uml.InteractionOperand) that holds it; none at the top level."
+         },
+         "props": {
+          "properties": {
+           "covers": {
+            "description": "The ids of the lifelines it spans, next to each other in the view's nodeIds."
+           },
+           "refersTo": {
+            "description": "The id of the view it refers to."
+           }
+          }
+         }
+        },
+        "not": {
+         "anyOf": [
+          {
+           "required": [
+            "from"
+           ]
+          },
+          {
+           "required": [
+            "to"
+           ]
+          }
+         ]
+        },
+        "description": "Schema version 2: an occurrence of a sequence view that is not a line: an interaction use (uml.InteractionUse), its label the interaction it refers to, props.covers the lifelines it spans (next to each other in nodeIds), props.refersTo a view's id, parent its operand."
        }
       ]
      }
@@ -1146,18 +1208,20 @@
      "description": "Guess a line's kind from its label's words when its edges name none (render() and layout(); the standalone page always does)."
     },
     "diagram": {
-     "description": "Schema version 2: the view's diagram type; without it the view is a map. uml.class draws a class diagram (0.18.0, lib/umlimator-all.js), uml.object an object diagram and uml.package a package diagram (0.19.0); a type this release does not draw is drawn as plain cards, with a warning.",
+     "description": "Schema version 2: the view's diagram type; without it the view is a map. uml.class draws a class diagram (0.18.0, lib/umlimator-all.js), uml.object an object diagram and uml.package a package diagram (0.19.0), uml.sequence a sequence diagram and uml.communication a communication diagram (0.20.0); a type this release does not draw is drawn as plain cards, with a warning.",
      "examples": [
       "uml.class",
       "uml.object",
-      "uml.package"
+      "uml.package",
+      "uml.sequence",
+      "uml.communication"
      ]
     },
     "subject": {
      "description": "Schema version 2: the element this diagram is the inside of. In a class, object or package view, the package names are qualified from (sales::Order without sales:: in a view of sales); not drawn unless the view lists it."
     },
     "direction": {
-     "description": "Schema version 2: a typed view's layout direction (default right). A map stays left to right."
+     "description": "Schema version 2: a typed view's layout direction (default right). A map stays left to right. A sequence view is always down; another direction is a warning."
     },
     "notation": {
      "description": "Schema version 2: a skin of the diagram type (crowsfoot for er)."
@@ -1189,7 +1253,48 @@
      ]
     },
     "fragments": {
-     "description": "Schema version 2: a sequence view's combined fragments and interaction uses."
+     "description": "Schema version 2: a sequence view's combined fragments (uml.CombinedFragment, props.operator alt, opt, loop, par or break), outermost first; each one's members are its operands (uml.InteractionOperand, label the guard) in order, and its parent is the operand that holds it (uml.sequence, 0.20.0).",
+     "items": {
+      "properties": {
+       "type": {
+        "examples": [
+         "uml.CombinedFragment"
+        ]
+       },
+       "parent": {
+        "description": "The operand (uml.InteractionOperand) that holds it; none at the top level."
+       },
+       "props": {
+        "properties": {
+         "operator": {
+          "description": "The fragment's operator; any other is a warning.",
+          "examples": [
+           "alt",
+           "opt",
+           "loop",
+           "par",
+           "break"
+          ]
+         }
+        }
+       },
+       "members": {
+        "description": "Its operands, in order.",
+        "items": {
+         "properties": {
+          "type": {
+           "examples": [
+            "uml.InteractionOperand"
+           ]
+          },
+          "label": {
+           "description": "The operand's guard."
+          }
+         }
+        }
+       }
+      }
+     }
     },
     "timeline": {
      "description": "Schema version 2: a timing view's unit, changes and constraints."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umlimator",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Embeddable, layered architecture maps: layout, orthogonal routing and an interactive canvas in one ES module.",
   "keywords": ["architecture", "diagram", "c4", "map", "svg", "layout", "orthogonal-routing", "drill-down"],
   "homepage": "https://zintaen.github.io/umlimator/",