umlimator 0.22.0 → 0.24.0

package/lib/umlimator.d.ts

@@ -44,7 +44,7 @@ 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), `uml.sequence` and `uml.communication` (0.20.0), `uml.use-case`, `uml.activity`, `uml.state-machine` and `uml.interaction-overview` (0.21.0), `uml.component`, `uml.deployment` and `uml.composite-structure` (0.22.0); other types draw as plain cards.
+ *  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), `uml.use-case`, `uml.activity`, `uml.state-machine` and `uml.interaction-overview` (0.21.0), `uml.component`, `uml.deployment` and `uml.composite-structure` (0.22.0), `uml.profile` and `uml.timing` (0.23.0), `er`, `flowchart`, `dfd`, `uml.information-flow` and C4's six views `c4.landscape`, `c4.context`, `c4.container`, `c4.component`, `c4.dynamic` and `c4.deployment` (0.24.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 {
@@ -194,6 +194,90 @@ export type UmlCompositeStructureLineType = 'uml.Connector' | 'uml.RoleBinding'
 export interface UmlPartProps { valueType?: string; multiplicity?: string; aggregation?: 'composite' | 'shared'; stereotypes?: string[]; [key: string]: unknown }
 /** A collaboration use's props: the collaboration it uses, by label. */
 export interface UmlCollaborationUseProps { collaboration?: string; stereotypes?: string[]; [key: string]: unknown }
+/** Any UML element's tagged values (0.23.0): by stereotype (as written in `stereotypes`, `Profile::name` when qualified, or
+ *  a required stereotype's name), then by tag name, each value as text. Checked against the profiles applied to the
+ *  element's packages (docs/conformance/uml-profile.md); edited in the properties panel on every typed view. */
+export type UmlTags = Record<string, Record<string, string>>;
+/** The props any UML element may hold from 0.23.0: its stereotypes (a name, or `Profile::name`) and their tags. */
+export interface UmlStereotypedProps { stereotypes?: string[]; tags?: UmlTags; [key: string]: unknown }
+/** The profile diagram's vocabulary (a view with `diagram: 'uml.profile'`, umlimator/all from 0.23.0;
+ *  docs/conformance/uml-profile.md). A stereotype's and a metaclass reference's `parent` is a profile; an enumeration's
+ *  (a tag's type) may be. A metaclass reference's `label` names a UML metaclass (Class, Property, Classifier, …). A
+ *  stereotype's tag definitions are `uml.Property` members (`name : Type [multiplicity] = default`). Any element that
+ *  applies a stereotype may be shown, with a compartment of tags for each stereotype it has. */
+export type UmlProfileElementType = 'uml.Profile' | 'uml.Stereotype' | 'uml.MetaclassReference' | 'uml.Enumeration' | 'uml.Package' | 'uml.Comment';
+export type UmlProfileMemberType = 'uml.Property' | 'uml.EnumerationLiteral';
+/** An extension from a stereotype to a metaclass reference; a profile application from a package to a profile; a
+ *  generalization between stereotypes. */
+export type UmlProfileLineType = 'uml.Extension' | 'uml.ProfileApplication' | 'uml.Generalization' | 'uml.CommentLink';
+/** A stereotype's props: abstract (applied through a specialization). */
+export interface UmlStereotypeProps { isAbstract?: boolean; [key: string]: unknown }
+/** An extension's props: required (the stereotype is applied to every element of the metaclass in its profile's scope). */
+export interface UmlExtensionProps { isRequired?: boolean; [key: string]: unknown }
+/** The timing diagram's vocabulary (a view with `diagram: 'uml.timing'`, umlimator/all from 0.23.0;
+ *  docs/conformance/uml-timing.md). Lifelines are model nodes the view lists in `nodeIds`, top to bottom; messages are inline
+ *  in the view's `edges`; changes and constraints are in its `timeline`. `present.<lifeline>.as: 'values'` draws a value
+ *  lifeline. The scale is derived, never stored. */
+export type UmlTimingElementType = 'uml.Lifeline';
+export type UmlTimingLineType = 'uml.Message';
+/** A timing lifeline's props: what it represents, and its states, top to bottom (ignored by the sequence and
+ *  communication types). */
+export interface UmlTimingLifelineProps { represents?: string; states?: string[]; stereotypes?: string[]; tags?: UmlTags; [key: string]: unknown }
+/** A timing message's props: a sort of call, async or reply, and when it is sent and received, in the view's unit. */
+export interface UmlTimingMessageProps { sort?: 'call' | 'async' | 'reply'; replyTo?: string; sentAt?: number; receivedAt?: number; [key: string]: unknown }
+/** A change of state on a lifeline at a time; an element of the model's id space, drawn by `at`. */
+export interface UmlTimingChange { id: string; lifeline: string; at: number; state: string }
+/** A duration constraint from one change to a later one, or a time constraint on one change. */
+export interface UmlTimingConstraint { id: string; type: 'uml.DurationConstraint' | 'uml.TimeConstraint'; from: string; to?: string; label?: string }
+/** A timing view's `timeline`: the ruler's unit (optional), its changes in any order, its constraints. */
+export interface UmlTimeline { unit?: string; changes?: UmlTimingChange[]; constraints?: UmlTimingConstraint[] }
+/** What a timing view shows of a lifeline, in its `present`: drawn as a value lifeline. */
+export interface UmlTimingPresent { as?: 'values' }
+/** The entity-relationship diagram's vocabulary (a view with `diagram: 'er'`, umlimator/all from 0.24.0;
+ *  docs/conformance/er.md). An entity's columns are `er.Column` members, each read and printed as one row,
+ *  `name type [PK] [FK table.column] [UK] [NULL]`. A relationship runs from the referenced entity to the referring one. The
+ *  view's `notation` is `crowsfoot` (the default) or `idef1x`, a repaint on one geometry. */
+export type ErElementType = 'er.Entity' | 'uml.Comment';
+export type ErMemberType = 'er.Column';
+export type ErLineType = 'er.Relationship' | 'uml.CommentLink';
+/** A column's props; `references` names a column id (a declared reference, dropped when that column is deleted). */
+export interface ErColumnProps { dataType?: string; primaryKey?: boolean; foreignKey?: boolean; references?: string; nullable?: boolean; unique?: boolean; [key: string]: unknown }
+/** A relationship's props: identifying (solid) or not (dashed), and each end's multiplicity (1, 0..1, 1..*, 0..*; other bounds, such as 2..5 or 3, drawn as the nearest of the four with their text). */
+export interface ErRelationshipProps { identifying?: boolean; ends?: { from?: { multiplicity?: string }; to?: { multiplicity?: string } }; [key: string]: unknown }
+/** The flowchart's vocabulary (a view with `diagram: 'flowchart'`, umlimator/all from 0.24.0; docs/conformance/flowchart.md).
+ *  A decision's exits are labelled flows; a connector with flows in and out is a junction. Laid out down by default. */
+export type FlowchartElementType = 'flow.Terminator' | 'flow.Process' | 'flow.Decision' | 'flow.InputOutput' | 'flow.PredefinedProcess' | 'flow.Document'
+  | 'flow.Database' | 'flow.ManualInput' | 'flow.Delay' | 'flow.Connector' | 'uml.Comment';
+export type FlowchartLineType = 'flow.Flow' | 'uml.CommentLink';
+/** The data flow diagram's vocabulary (a view with `diagram: 'dfd'`, umlimator/all from 0.24.0; docs/conformance/dfd.md).
+ *  A process's `opensView` names its level, a `dfd` view whose `parent` is the view the process is on; numbers are stored
+ *  and checked under their parent's. The view's `notation` is `yourdon` (the default) or `gane-sarson`, a repaint. */
+export type DfdElementType = 'dfd.Process' | 'dfd.DataStore' | 'dfd.ExternalEntity' | 'uml.Comment';
+export type DfdLineType = 'dfd.DataFlow' | 'uml.CommentLink';
+/** A process's or a store's props: its number (1, 1.2, D1). */
+export interface DfdNumberProps { number?: string; [key: string]: unknown }
+/** The information flow diagram's vocabulary (a view with `diagram: 'uml.information-flow'`, umlimator/all from 0.24.0;
+ *  docs/conformance/uml-information-flow.md). A flow is a dashed «flow» line labelled with what it conveys. */
+export type UmlInformationFlowElementType = 'uml.Class' | 'uml.Interface' | 'uml.Component' | 'uml.Actor' | 'uml.InformationItem' | 'uml.Comment';
+export type UmlInformationFlowLineType = 'uml.InformationFlow' | 'uml.CommentLink';
+/** An information flow's props: the ids of the information items or classifiers it conveys (a declared reference: a
+ *  deleted id is dropped). Its `label`, when given, is its name, drawn before what it conveys. */
+export interface UmlInformationFlowProps { conveyed?: string[]; [key: string]: unknown }
+/** C4's vocabulary (views with `diagram` one of `c4.landscape`, `c4.context`, `c4.container`, `c4.component`, `c4.dynamic`
+ *  and `c4.deployment`, umlimator/all from 0.24.0; docs/conformance/c4.md). Ownership is `parent`: a container's is a software
+ *  system, a component's a container, a deployment node's a deployment node or none, an instance's a deployment node. A
+ *  view's `subject` is drawn as a boundary when `nodeIds` lists it; a dynamic view's `edges` are relationship ids, each once,
+ *  in time order, numbered when drawn. A relationship whose end a view does not show is drawn between the nearest shown
+ *  owners (an implied line, never stored or edited). */
+export type C4ViewType = 'c4.landscape' | 'c4.context' | 'c4.container' | 'c4.component' | 'c4.dynamic' | 'c4.deployment';
+export type C4ElementType = 'c4.Person' | 'c4.SoftwareSystem' | 'c4.Container' | 'c4.Component' | 'c4.DeploymentNode' | 'c4.ContainerInstance' | 'uml.Comment';
+export type C4LineType = 'c4.Relationship' | 'uml.CommentLink';
+/** A C4 element's props; `shape` names one of the map's card shapes (a person is `person` and every other element `box`
+ *  without it); an instance's `container` is a declared reference (deleting the container deletes its instances). */
+export interface C4ElementProps { description?: string; technology?: string; external?: boolean;
+  shape?: 'person' | 'robot' | 'browser' | 'window' | 'terminal' | 'mobile' | 'cylinder' | 'pipe' | 'folder' | 'document' | 'hexagon' | 'box'; container?: string; [key: string]: unknown }
+/** A C4 relationship's props: its technology (its `label` is its description). */
+export interface C4RelationshipProps { technology?: string; [key: string]: unknown }
 /** 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. */
@@ -511,7 +595,9 @@ export type Command =
   | { op: 'move'; id: string; view: string; index: number; owner?: never }
   | { op: 'hide'; id: string; view: string }
   | { op: 'delete'; id: string }
-  | { op: 'reparent'; id: string; parent: string | null };
+  | { op: 'reparent'; id: string; parent: string | null }
+  /** 0.24.0: a view added to `views` (at `index`, else last); refused when its id is taken. No command deletes a view. */
+  | { op: 'addView'; view: MapView; index?: number };
 /** The model after a transaction: one command, or a list run in order, on a copy (0.17.0). A command that cannot run
  *  throws, and none of the transaction is applied. `delete` takes with it the element's members, what it owns, the lines
  *  to them and every place that names them (references()); one already gone in the same transaction is passed over.

package/lib/umlimator.js

@@ -133,7 +133,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]));
@@ -209,6 +211,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). */
 
@@ -401,7 +406,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)`);
   }
 }
 
@@ -2354,7 +2366,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;
@@ -5826,8 +5838,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>`) },
   ];
 }

package/lib/umlimator.schema.json

@@ -411,7 +411,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. The sequence and communication diagrams (uml.sequence, uml.communication, 0.20.0): uml.Lifeline. The use case diagram (uml.use-case, 0.21.0): uml.Actor, uml.UseCase, uml.Subject and uml.Comment; a use case's members uml.ExtensionPoint. The activity diagram (uml.activity, 0.21.0): uml.InitialNode, uml.ActivityFinalNode, uml.FlowFinalNode, uml.Action, uml.CallBehaviorAction, uml.SendSignalAction, uml.AcceptEventAction, uml.DecisionNode, uml.MergeNode, uml.ForkNode, uml.JoinNode, uml.ObjectNode, uml.DataStoreNode, uml.ActivityPartition and uml.Comment. The state machine diagram (uml.state-machine, 0.21.0): uml.State, uml.Pseudostate, uml.FinalState and uml.Comment; a state's members uml.Region and uml.InternalTransition. The interaction overview diagram (uml.interaction-overview, 0.21.0): the activity's control nodes, uml.InteractionUse, uml.Interaction (an inline interaction) and uml.Comment. The component diagram (uml.component, 0.22.0): uml.Component, uml.Interface, uml.Artifact, uml.Package and uml.Comment; a component's (or class's) members uml.Port. The deployment diagram (uml.deployment, 0.22.0): uml.Node, uml.Device, uml.ExecutionEnvironment, uml.Artifact, uml.DeploymentSpecification, uml.Component and uml.Comment. The composite structure diagram (uml.composite-structure, 0.22.0): the view's subject (a uml.Class, uml.Component or uml.Collaboration), uml.Collaboration, uml.CollaborationUse and uml.Comment; the subject's members uml.Property (its parts) and uml.Port, a collaboration's uml.Property (its roles).",
+     "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. The use case diagram (uml.use-case, 0.21.0): uml.Actor, uml.UseCase, uml.Subject and uml.Comment; a use case's members uml.ExtensionPoint. The activity diagram (uml.activity, 0.21.0): uml.InitialNode, uml.ActivityFinalNode, uml.FlowFinalNode, uml.Action, uml.CallBehaviorAction, uml.SendSignalAction, uml.AcceptEventAction, uml.DecisionNode, uml.MergeNode, uml.ForkNode, uml.JoinNode, uml.ObjectNode, uml.DataStoreNode, uml.ActivityPartition and uml.Comment. The state machine diagram (uml.state-machine, 0.21.0): uml.State, uml.Pseudostate, uml.FinalState and uml.Comment; a state's members uml.Region and uml.InternalTransition. The interaction overview diagram (uml.interaction-overview, 0.21.0): the activity's control nodes, uml.InteractionUse, uml.Interaction (an inline interaction) and uml.Comment. The component diagram (uml.component, 0.22.0): uml.Component, uml.Interface, uml.Artifact, uml.Package and uml.Comment; a component's (or class's) members uml.Port. The deployment diagram (uml.deployment, 0.22.0): uml.Node, uml.Device, uml.ExecutionEnvironment, uml.Artifact, uml.DeploymentSpecification, uml.Component and uml.Comment. The composite structure diagram (uml.composite-structure, 0.22.0): the view's subject (a uml.Class, uml.Component or uml.Collaboration), uml.Collaboration, uml.CollaborationUse and uml.Comment; the subject's members uml.Property (its parts) and uml.Port, a collaboration's uml.Property (its roles). The profile diagram (uml.profile, 0.23.0): uml.Profile, uml.Stereotype and uml.MetaclassReference (each owned by a profile), uml.Enumeration (a tag's type), uml.Package, uml.Comment and any element that applies a stereotype; a stereotype's members uml.Property (its tag definitions), an enumeration's uml.EnumerationLiteral. The timing diagram (uml.timing, 0.23.0): uml.Lifeline (its changes and constraints are in the view's timeline). The entity-relationship diagram (er, 0.24.0): er.Entity and uml.Comment; an entity's members er.Column. The flowchart (flowchart, 0.24.0): flow.Terminator, flow.Process, flow.Decision, flow.InputOutput, flow.PredefinedProcess, flow.Document, flow.Database, flow.ManualInput, flow.Delay, flow.Connector and uml.Comment. The data flow diagram (dfd, 0.24.0): dfd.Process, dfd.DataStore, dfd.ExternalEntity and uml.Comment. The information flow diagram (uml.information-flow, 0.24.0): uml.Class, uml.Interface, uml.Component, uml.Actor, uml.InformationItem and uml.Comment. C4 (c4.landscape, c4.context, c4.container, c4.component, c4.dynamic, c4.deployment, 0.24.0): c4.Person, c4.SoftwareSystem, c4.Container (owned by a software system), c4.Component (owned by a container), c4.DeploymentNode (owned by a deployment node or none), c4.ContainerInstance (owned by a deployment node) and uml.Comment.",
      "examples": [
       "uml.Class",
       "uml.Interface",
@@ -440,23 +440,48 @@
       "uml.ExecutionEnvironment",
       "uml.DeploymentSpecification",
       "uml.Collaboration",
-      "uml.CollaborationUse"
+      "uml.CollaborationUse",
+      "uml.Profile",
+      "uml.Stereotype",
+      "uml.MetaclassReference",
+      "er.Entity",
+      "er.Column",
+      "flow.Terminator",
+      "flow.Process",
+      "flow.Decision",
+      "flow.InputOutput",
+      "flow.PredefinedProcess",
+      "flow.Document",
+      "flow.Database",
+      "flow.ManualInput",
+      "flow.Delay",
+      "flow.Connector",
+      "dfd.Process",
+      "dfd.DataStore",
+      "dfd.ExternalEntity",
+      "uml.InformationItem",
+      "c4.Person",
+      "c4.SoftwareSystem",
+      "c4.Container",
+      "c4.Component",
+      "c4.DeploymentNode",
+      "c4.ContainerInstance"
      ]
     },
     "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. A use case's: a subject or a package. An activity node's: its partition (lane); a partition's: the partition it is nested in. A substate's or pseudostate's: a state, or a region (a member) of one. A component's: a component (drawn nested) or a package. A node's, device's or execution environment's: one of the three (UML's nestedNode); an artifact's or deployment specification's: the target it is deployed on. A collaboration use's: the subject of its composite structure view (0.22.0)."
+     "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. A use case's: a subject or a package. An activity node's: its partition (lane); a partition's: the partition it is nested in. A substate's or pseudostate's: a state, or a region (a member) of one. A component's: a component (drawn nested) or a package. A node's, device's or execution environment's: one of the three (UML's nestedNode); an artifact's or deployment specification's: the target it is deployed on. A collaboration use's: the subject of its composite structure view (0.22.0). A stereotype's and a metaclass reference's: a profile; an enumeration's may be (0.23.0)."
     },
     "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). The sequence and communication diagrams (uml.sequence, uml.communication, 0.20.0): a lifeline's represents, and stereotypes (actor draws «actor» over its name). The state machine diagram (uml.state-machine, 0.21.0): a state's entry, do and exit, a pseudostate's kind (docs/conformance/uml-state-machine.md). The composite structure diagram (uml.composite-structure, 0.22.0): a collaboration use's collaboration (docs/conformance/uml-composite-structure.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). The state machine diagram (uml.state-machine, 0.21.0): a state's entry, do and exit, a pseudostate's kind (docs/conformance/uml-state-machine.md). The composite structure diagram (uml.composite-structure, 0.22.0): a collaboration use's collaboration (docs/conformance/uml-composite-structure.md). On any UML element, stereotypes and their tags, checked against the profiles applied to its packages (0.23.0, docs/conformance/uml-profile.md). The profile diagram (uml.profile, 0.23.0): a stereotype's isAbstract. The timing diagram (uml.timing, 0.23.0): a lifeline's states (docs/conformance/uml-timing.md). The entity-relationship diagram (er, 0.24.0): a column's dataType, primaryKey, foreignKey, references (a column id), nullable and unique (docs/conformance/er.md). The data flow diagram (dfd, 0.24.0): a process's or a store's number (docs/conformance/dfd.md). C4 (0.24.0): an element's description, technology, external and shape (a map card shape: person, robot, browser, window, terminal, mobile, cylinder, pipe, folder, document, hexagon, box); a container instance's container (docs/conformance/c4.md).",
      "anyOf": [
       {
        "type": "object",
        "properties": {
         "isAbstract": {
-         "description": "uml.Class, uml.Operation: true draws the name in italics ({abstract} in a member's text)."
+         "description": "uml.Class, uml.Operation: true draws the name in italics ({abstract} in a member's text). uml.Stereotype (0.23.0): true draws its name in italics; an abstract stereotype is applied through a specialization."
         },
         "stereotypes": {
-         "description": "Any UML element: names drawn «in guillemets», as text (['entity'])."
+         "description": "Any UML element: names drawn «in guillemets», as text (['entity']). From 0.23.0, a name a profile applied to one of the element's packages defines is that profile's stereotype, checked against it; Profile::name picks one of two applied profiles that define a name; outside every applied profile a name is a keyword, as before."
         },
         "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."
@@ -488,6 +513,71 @@
         },
         "collaboration": {
          "description": "uml.CollaborationUse: the collaboration it uses, by label, as text; drawn name : Collaboration."
+        },
+        "tags": {
+         "description": "Any UML element (0.23.0): its tagged values, keyed by stereotype (as written in stereotypes, or a required stereotype's name), then by tag name, each value as text: { \"column\": { \"name\": \"placed_at\", \"indexed\": \"true\" } }. Checked against the tag's definition (a uml.Property of the stereotype or of one of its generals): defined, of its type (Boolean, Integer, Real, UnlimitedNatural, an enumeration of the profile; any text otherwise), present when required. Edited in the properties panel on every typed view.",
+         "type": "object",
+         "additionalProperties": {
+          "type": "object",
+          "additionalProperties": {}
+         }
+        },
+        "states": {
+         "description": "uml.Lifeline in a timing view (0.23.0): its states, top to bottom, as text; each is a row of its timeline. Ignored by the sequence and communication types.",
+         "type": "array",
+         "items": {
+          "type": "string"
+         }
+        },
+        "dataType": {
+         "description": "er.Column (0.24.0): its type, as text (bigint, varchar(80))."
+        },
+        "primaryKey": {
+         "description": "er.Column (0.24.0): true puts it in the key, drawn first under PK."
+        },
+        "foreignKey": {
+         "description": "er.Column (0.24.0): true marks it FK; it should name what it references."
+        },
+        "references": {
+         "description": "er.Column (0.24.0): the id of the column it references (a declared reference, dropped when that column is deleted)."
+        },
+        "nullable": {
+         "description": "er.Column (0.24.0): true allows no value (NULL); an IDEF1X optional parent where it carries a foreign key."
+        },
+        "unique": {
+         "description": "er.Column (0.24.0): true marks it UK."
+        },
+        "number": {
+         "description": "dfd.Process, dfd.DataStore (0.24.0): its number, as text (1, 1.2, D1), checked under its parent process's."
+        },
+        "description": {
+         "description": "A C4 element (0.24.0): what it is and does, drawn under its name."
+        },
+        "technology": {
+         "description": "c4.Container, c4.Component, c4.DeploymentNode (0.24.0): drawn as [Container: technology]."
+        },
+        "external": {
+         "description": "A C4 person or software system (0.24.0): true draws it grey, outside the organisation."
+        },
+        "container": {
+         "description": "c4.ContainerInstance (0.24.0): the id of the container it is an instance of (a declared reference: deleting the container deletes its instances)."
+        },
+        "shape": {
+         "description": "A C4 element (0.24.0): one of the map's card shapes; a person is person and every other element box without it.",
+         "examples": [
+          "person",
+          "robot",
+          "browser",
+          "window",
+          "terminal",
+          "mobile",
+          "cylinder",
+          "pipe",
+          "folder",
+          "document",
+          "hexagon",
+          "box"
+         ]
         }
        }
       },
@@ -495,7 +585,7 @@
      ]
     },
     "members": {
-     "description": "Schema version 2: owned parts, in display order (attributes, ports, regions, lanes), each a typed element. The class diagram (uml.class, 0.18.0): a classifier's attributes (uml.Property) and operations (uml.Operation), an enumeration's literals (uml.EnumerationLiteral). The object diagram (uml.object, 0.19.0): an instance's slots (uml.Slot), each a feature = value row. The use case diagram (uml.use-case, 0.21.0): a use case's extension points (uml.ExtensionPoint, by name). The state machine diagram (uml.state-machine, 0.21.0): a state's regions (uml.Region, by name) and internal transitions (uml.InternalTransition, trigger [guard] / effect). The component diagram (uml.component, 0.22.0): a component's or class's ports (uml.Port), drawn on its border. The composite structure diagram (uml.composite-structure, 0.22.0): the subject's parts (uml.Property, name : Type [multiplicity]) and ports (uml.Port); a collaboration's roles (uml.Property).",
+     "description": "Schema version 2: owned parts, in display order (attributes, ports, regions, lanes), each a typed element. The class diagram (uml.class, 0.18.0): a classifier's attributes (uml.Property) and operations (uml.Operation), an enumeration's literals (uml.EnumerationLiteral). The object diagram (uml.object, 0.19.0): an instance's slots (uml.Slot), each a feature = value row. The use case diagram (uml.use-case, 0.21.0): a use case's extension points (uml.ExtensionPoint, by name). The state machine diagram (uml.state-machine, 0.21.0): a state's regions (uml.Region, by name) and internal transitions (uml.InternalTransition, trigger [guard] / effect). The component diagram (uml.component, 0.22.0): a component's or class's ports (uml.Port), drawn on its border. The composite structure diagram (uml.composite-structure, 0.22.0): the subject's parts (uml.Property, name : Type [multiplicity]) and ports (uml.Port); a collaboration's roles (uml.Property). The profile diagram (uml.profile, 0.23.0): a stereotype's tag definitions (uml.Property, name : Type [multiplicity] = default).",
      "anyOf": [
       {
        "type": "array",
@@ -509,7 +599,7 @@
             "description": "Unique among every node, edge and member of the model."
            },
            "type": {
-            "description": "uml.Property, uml.Operation or uml.EnumerationLiteral in a class diagram; uml.Slot in an object diagram. uml.ExtensionPoint in a use case diagram; uml.Region or uml.InternalTransition in a state machine diagram. uml.Port on a component or class (component and composite structure diagrams); uml.Property as a part or a role in a composite structure diagram (0.22.0)."
+            "description": "uml.Property, uml.Operation or uml.EnumerationLiteral in a class diagram; uml.Slot in an object diagram. uml.ExtensionPoint in a use case diagram; uml.Region or uml.InternalTransition in a state machine diagram. uml.Port on a component or class (component and composite structure diagrams); uml.Property as a part or a role in a composite structure diagram (0.22.0). uml.Property on a stereotype: a tag definition (profile diagram, 0.23.0)."
            },
            "label": {
             "description": "The member's name (a slot's: the feature it gives a value); the rest of its UML text is in props."
@@ -530,7 +620,7 @@
                 "description": "uml.Property, uml.Operation: public, private, protected or package (+ - # ~)."
                },
                "valueType": {
-                "description": "uml.Property, and each of an operation's parameters: its type, as text (Money, String[], Map<K, V>). uml.Port: its type, drawn name : Type beside it (0.22.0). A part's or role's: the class or component it is, by label (a part shows that type's ports)."
+                "description": "uml.Property, and each of an operation's parameters: its type, as text (Money, String[], Map<K, V>). uml.Port: its type, drawn name : Type beside it (0.22.0). A part's or role's: the class or component it is, by label (a part shows that type's ports). A tag definition's (0.23.0): Boolean, Integer, Real, UnlimitedNatural, String, or an enumeration of the profile by label."
                },
                "multiplicity": {
                 "description": "uml.Property: 1, *, n..m or n..* (0..1, 1..*), kept as written."
@@ -870,7 +960,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. 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. The use case diagram (uml.use-case, 0.21.0): uml.Association (an actor and a use case), uml.Include and uml.Extend (from the including or extending use case), uml.Generalization (from the specific to the general) and uml.CommentLink. The activity diagram (uml.activity, 0.21.0): uml.ControlFlow, uml.ObjectFlow and uml.CommentLink. The state machine diagram (uml.state-machine, 0.21.0): uml.Transition and uml.CommentLink. The interaction overview diagram (uml.interaction-overview, 0.21.0): uml.ControlFlow and uml.CommentLink. The component diagram (uml.component, 0.22.0): uml.InterfaceRealization (from a component, a class or a port to the interface: a plain stem to a ball), uml.Usage (to the interface: a socket at a ball, else a dashed «use» arrow), uml.ComponentRealization (from the realizing classifier to the component), uml.Connector (props.kind assembly or delegation; from or to a port), uml.Dependency, uml.Manifestation (from an artifact) and uml.CommentLink. The deployment diagram (uml.deployment, 0.22.0): uml.Deployment (from an artifact or deployment specification to its target), uml.Manifestation, uml.CommunicationPath (between two targets), uml.Dependency and uml.CommentLink. The composite structure diagram (uml.composite-structure, 0.22.0): uml.Connector (between parts and ports; an end through a part keeps props.ends.<end>.part), uml.RoleBinding (from a part to a collaboration use; its label the role) 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. The use case diagram (uml.use-case, 0.21.0): uml.Association (an actor and a use case), uml.Include and uml.Extend (from the including or extending use case), uml.Generalization (from the specific to the general) and uml.CommentLink. The activity diagram (uml.activity, 0.21.0): uml.ControlFlow, uml.ObjectFlow and uml.CommentLink. The state machine diagram (uml.state-machine, 0.21.0): uml.Transition and uml.CommentLink. The interaction overview diagram (uml.interaction-overview, 0.21.0): uml.ControlFlow and uml.CommentLink. The component diagram (uml.component, 0.22.0): uml.InterfaceRealization (from a component, a class or a port to the interface: a plain stem to a ball), uml.Usage (to the interface: a socket at a ball, else a dashed «use» arrow), uml.ComponentRealization (from the realizing classifier to the component), uml.Connector (props.kind assembly or delegation; from or to a port), uml.Dependency, uml.Manifestation (from an artifact) and uml.CommentLink. The deployment diagram (uml.deployment, 0.22.0): uml.Deployment (from an artifact or deployment specification to its target), uml.Manifestation, uml.CommunicationPath (between two targets), uml.Dependency and uml.CommentLink. The composite structure diagram (uml.composite-structure, 0.22.0): uml.Connector (between parts and ports; an end through a part keeps props.ends.<end>.part), uml.RoleBinding (from a part to a collaboration use; its label the role) and uml.CommentLink. The profile diagram (uml.profile, 0.23.0): uml.Extension (from a stereotype to a metaclass reference; props.isRequired), uml.ProfileApplication (from a package to a profile), uml.Generalization (between stereotypes) and uml.CommentLink. The timing diagram (uml.timing, 0.23.0): uml.Message, inline in its view's edges (props.sentAt, props.receivedAt). The entity-relationship diagram (er, 0.24.0): er.Relationship (from the referenced entity to the referring one) and uml.CommentLink. The flowchart (flowchart, 0.24.0): flow.Flow (a decision's exits labelled) and uml.CommentLink. The data flow diagram (dfd, 0.24.0): dfd.DataFlow and uml.CommentLink. The information flow diagram (uml.information-flow, 0.24.0): uml.InformationFlow (props.conveyed) and uml.CommentLink. C4 (0.24.0): c4.Relationship (its label the description, props.technology) and uml.CommentLink; a dynamic view's edges list relationship ids, each once, in time order.",
      "examples": [
       "uml.Association",
       "uml.Generalization",
@@ -892,20 +982,27 @@
       "uml.Manifestation",
       "uml.Deployment",
       "uml.CommunicationPath",
-      "uml.RoleBinding"
+      "uml.RoleBinding",
+      "uml.Extension",
+      "uml.ProfileApplication",
+      "er.Relationship",
+      "flow.Flow",
+      "dfd.DataFlow",
+      "uml.InformationFlow",
+      "c4.Relationship"
      ]
     },
     "parent": {
      "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. The sequence and communication diagrams (0.20.0): a message's sort and replyTo. The use case diagram (0.21.0): an extend's extensionPoints and condition. The activity and interaction overview diagrams (0.21.0): a flow's guard (its label is its name). The state machine diagram (0.21.0): a transition's trigger, guard and effect, drawn trigger [guard] / effect. The component diagram (0.22.0): a connector's kind (assembly or delegation). The composite structure diagram (0.22.0): a connector end's part (ends.from.part, ends.to.part), UML's partWithPort.",
+     "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. The use case diagram (0.21.0): an extend's extensionPoints and condition. The activity and interaction overview diagrams (0.21.0): a flow's guard (its label is its name). The state machine diagram (0.21.0): a transition's trigger, guard and effect, drawn trigger [guard] / effect. The component diagram (0.22.0): a connector's kind (assembly or delegation). The composite structure diagram (0.22.0): a connector end's part (ends.from.part, ends.to.part), UML's partWithPort. The profile diagram (0.23.0): an extension's isRequired. The timing diagram (0.23.0): a message's sort (call, async or reply), replyTo, sentAt and receivedAt. The entity-relationship diagram (er, 0.24.0): a relationship's identifying and ends.<from|to>.multiplicity (1, 0..1, 1..*, 0..*; other bounds, such as 2..5 or 3, drawn as the nearest of the four with their text). The information flow diagram (uml.information-flow, 0.24.0): a flow's conveyed, ids of information items or classifiers (docs/conformance/uml-information-flow.md). C4 (0.24.0): a relationship's technology.",
      "anyOf": [
       {
        "type": "object",
        "properties": {
         "ends": {
-         "description": "uml.Association: { from, to }, each end's role, multiplicity, aggregation and navigability. uml.Link: each end's role. uml.Connector (composite structure, 0.22.0): an end through a part, { part }: the end (from or to) is a port of the part's type, reached through that part.",
+         "description": "uml.Association: { from, to }, each end's role, multiplicity, aggregation and navigability. uml.Link: each end's role. uml.Connector (composite structure, 0.22.0): an end through a part, { part }: the end (from or to) is a port of the part's type, reached through that part. er.Relationship (0.24.0): each end's multiplicity (1, 0..1, 1..*, 0..*; other bounds, such as 2..5 or 3, drawn as the nearest of the four with their text), drawn as the view's notation says.",
          "anyOf": [
           {
            "type": "object",
@@ -1010,6 +1107,26 @@
           "assembly",
           "delegation"
          ]
+        },
+        "isRequired": {
+         "description": "uml.Extension (0.23.0): true marks it {required}: the stereotype is applied to every element of the metaclass in its profile's scope."
+        },
+        "sentAt": {
+         "description": "uml.Message in a timing view (0.23.0): when it is sent, a number in the view's unit.",
+         "type": "number"
+        },
+        "receivedAt": {
+         "description": "uml.Message in a timing view (0.23.0): when it is received, a number in the view's unit, no earlier than sentAt.",
+         "type": "number"
+        },
+        "identifying": {
+         "description": "er.Relationship (0.24.0): true draws it solid (the child's key holds the parent's), false dashed."
+        },
+        "conveyed": {
+         "description": "uml.InformationFlow (0.24.0): the ids of the information items or classifiers it conveys, drawn after «flow»; a deleted id is dropped."
+        },
+        "technology": {
+         "description": "c4.Relationship (0.24.0): drawn as [technology] after its description."
         }
        }
       },
@@ -1291,7 +1408,7 @@
      "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), uml.sequence a sequence diagram and uml.communication a communication diagram (0.20.0), uml.use-case a use case diagram, uml.activity an activity diagram, uml.state-machine a state machine diagram and uml.interaction-overview an interaction overview diagram (0.21.0), uml.component a component diagram, uml.deployment a deployment diagram and uml.composite-structure a composite structure diagram (0.22.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), uml.use-case a use case diagram, uml.activity an activity diagram, uml.state-machine a state machine diagram and uml.interaction-overview an interaction overview diagram (0.21.0), uml.component a component diagram, uml.deployment a deployment diagram and uml.composite-structure a composite structure diagram (0.22.0), uml.profile a profile diagram and uml.timing a timing diagram (0.23.0), er an entity-relationship diagram, flowchart a flowchart, dfd a data flow diagram, uml.information-flow an information flow diagram, and c4.landscape, c4.context, c4.container, c4.component, c4.dynamic and c4.deployment C4's six views (0.24.0); a type this release does not draw is drawn as plain cards, with a warning.",
      "examples": [
       "uml.class",
       "uml.object",
@@ -1304,20 +1421,32 @@
       "uml.interaction-overview",
       "uml.component",
       "uml.deployment",
-      "uml.composite-structure"
+      "uml.composite-structure",
+      "uml.profile",
+      "uml.timing",
+      "uml.information-flow",
+      "er",
+      "flowchart",
+      "dfd",
+      "c4.landscape",
+      "c4.context",
+      "c4.container",
+      "c4.component",
+      "c4.dynamic",
+      "c4.deployment"
      ]
     },
     "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. In a composite structure view (0.22.0): the class, component or collaboration whose parts and ports it draws, listed in nodeIds."
+     "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. In a composite structure view (0.22.0): the class, component or collaboration whose parts and ports it draws, listed in nodeIds. In a C4 view (0.24.0): the software system or container it zooms into, drawn as a boundary when nodeIds lists it."
     },
     "direction": {
      "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)."
+     "description": "Schema version 2: a skin of the diagram type, drawn on one geometry: crowsfoot (default) or idef1x for er, yourdon (default) or gane-sarson for dfd (0.24.0)."
     },
     "present": {
-     "description": "Schema version 2: what the layout cannot derive, per element: collapsed compartments, rows shown before +n more. A component view's interface drawn as a ball (as: 'ball'), and a port's side (side); a port on a part, by the part's id: ports.<port>.side (0.22.0).",
+     "description": "Schema version 2: what the layout cannot derive, per element: collapsed compartments, rows shown before +n more. A component view's interface drawn as a ball (as: 'ball'), and a port's side (side); a port on a part, by the part's id: ports.<port>.side (0.22.0). A timing view's lifeline drawn as a value lifeline (as: 'values', 0.23.0).",
      "anyOf": [
       {
        "type": "object",
@@ -1334,9 +1463,10 @@
             "description": "At most this many rows in each compartment, then \"+k more\"."
            },
            "as": {
-            "description": "uml.Interface in a component view (0.22.0): 'ball' draws it as a ball (a 16 px circle); left out, a rectangle with «interface».",
+            "description": "uml.Interface in a component view (0.22.0): 'ball' draws it as a ball (a 16 px circle); left out, a rectangle with «interface». uml.Lifeline in a timing view (0.23.0): 'values' draws it as a value lifeline, a band crossed at each change with its value inside; left out, a state line.",
             "examples": [
-             "ball"
+             "ball",
+             "values"
             ]
            },
            "side": {
@@ -1405,7 +1535,87 @@
      }
     },
     "timeline": {
-     "description": "Schema version 2: a timing view's unit, changes and constraints."
+     "description": "Schema version 2: a timing view's ruler (uml.timing, 0.23.0): its unit, its changes and its constraints. Times are numbers in one unit; the scale is derived, never stored.",
+     "anyOf": [
+      {
+       "type": "object",
+       "properties": {
+        "unit": {
+         "description": "The unit drawn after the ruler's last label (ms); optional.",
+         "type": "string"
+        },
+        "changes": {
+         "description": "Each lifeline's state changes, in any order: drawn by at. A change is an element of the model's id space, not a node.",
+         "type": "array",
+         "items": {
+          "type": "object",
+          "required": [
+           "id",
+           "lifeline",
+           "at",
+           "state"
+          ],
+          "properties": {
+           "id": {
+            "type": "string",
+            "description": "Unique among every element of the model."
+           },
+           "lifeline": {
+            "type": "string",
+            "description": "The uml.Lifeline it is on; deleting the lifeline deletes its changes."
+           },
+           "at": {
+            "type": "number",
+            "description": "When it happens, in the view's unit."
+           },
+           "state": {
+            "type": "string",
+            "description": "The state it enters: one of its lifeline's states (a value lifeline: any text)."
+           }
+          }
+         }
+        },
+        "constraints": {
+         "description": "Time and duration constraints on the changes, drawn in a strip under the lane of their first change.",
+         "type": "array",
+         "items": {
+          "type": "object",
+          "required": [
+           "id",
+           "type",
+           "from"
+          ],
+          "properties": {
+           "id": {
+            "type": "string",
+            "description": "Unique among every element of the model."
+           },
+           "type": {
+            "description": "uml.DurationConstraint (from a change to a later one) or uml.TimeConstraint (on one change).",
+            "examples": [
+             "uml.DurationConstraint",
+             "uml.TimeConstraint"
+            ]
+           },
+           "from": {
+            "type": "string",
+            "description": "A change of the view; deleting it deletes the constraint."
+           },
+           "to": {
+            "type": "string",
+            "description": "uml.DurationConstraint: the change it runs to."
+           },
+           "label": {
+            "type": "string",
+            "description": "The constraint's text ({<= 800 ms})."
+           }
+          }
+         }
+        }
+       }
+      },
+      true
+     ]
     }
    }
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umlimator",
-  "version": "0.22.0",
+  "version": "0.24.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/",