@rse/specbook 1.5.2 → 1.6.1

package/dst/specbook-format.yaml

@@ -329,13 +329,21 @@
         -   Evans: Domain-Driven Design: Tackling Complexity in the Heart of Software (2003),
             https://www.domainlanguage.com/ddd/
     diagram:
-        type: grid
-        nodes: "[[TERM:*]]"
-        properties:
-            -   TYPE
-        config:
-            size-node-width-max: 440
-            grid-columns-max: 4
+        -   type: grid
+            nodes: "[[TERM:*]]"
+            markUncovered: referenced
+            properties:
+                -   TYPE
+            config:
+                size-node-width-max: 440
+                grid-columns-max: 4
+        -   type: tree
+            nodes: "[[TERM:*]]"
+            links: []
+            onlyConnected: true
+            nest:
+                properties:
+                    -   BROADER
     children:
         -   kind: TERM
             name: "[A-Z][A-Za-z0-9-]*( [A-Z][A-Za-z0-9-]*)*"
@@ -430,12 +438,22 @@
         -   Pruitt/Adlin: The Persona Lifecycle: Keeping People in Mind Throughout Product Design (2006),
             https://www.sciencedirect.com/book/9780125662512/the-persona-lifecycle
     diagram:
-        type: graph
-        nodes: "[[ROLE:*]], [[PERSONA:*]]"
-        labeled: true
-        qualified: true
-        config:
-            size-node-width-max: 440
+        -   type: graph
+            nodes: "[[ROLE:*]], [[PERSONA:*]]"
+            labeled: true
+            qualified: true
+            markUncovered: referenced
+            config:
+                size-node-width-max: 440
+        -   type: tree
+            nodes: "[[ROLE:*]]"
+            links: []
+            onlyConnected: true
+            nest:
+                properties:
+                    -   INHERITS
+            config:
+                mark-violation: false
     children:
         -   kind: ROLE
             desc: >
@@ -452,11 +470,18 @@
                 maxTableColumns: 5
             referenced:
                 -   "[[*]]"
+            badge:
+                property: TYPE
+                map:
+                    Person: person
+                    System: bot
             diagram:
                 type: hub
                 center: self
                 nodes: "[[ROLE:*]], [[TERM:*]], [[PERSONA:*]], [[WORKFLOW:*]], [[ACTIVITY:*]],
-                    [[USE-CASE:*]], [[TRANSITION:*]], [[CV.ENTITY:*]]"
+                    [[USE-CASE:*]], [[TRANSITION:*]], [[CV.ENTITY:*]], [[INTERACTION:*]]"
+                descend:
+                    -   MESSAGE
                 labeled: true
                 qualified: true
                 config:
@@ -495,6 +520,11 @@
             optional: true
             format:
                 maxTableColumns: 5
+            badge:
+                property: TYPE
+                map:
+                    Stakeholder: team
+                default: person
             props:
                 -   name: TYPE
                     desc: >
@@ -655,16 +685,26 @@
         -   DSDM: MoSCoW Prioritisation, DSDM Agile Project Framework (2014),
             https://www.agilebusiness.org/dsdm-project-framework/moscow-prioritisation.html
     diagram:
-        type: grid
-        nodes: "[[FR.REQUIREMENT:*]]"
-        nest:
+        -   type: grid
+            nodes: "[[FR.REQUIREMENT:*]]"
+            markUncovered: referenced
+            nest:
+                properties:
+                    -   GROUP
             properties:
-                -   GROUP
-        properties:
-            -   PRIORITY
-        config:
-            size-node-width-max: 440
-            grid-columns-max: 2
+                -   PRIORITY
+            config:
+                size-node-width-max: 440
+                grid-columns-max: 2
+        -   type: matrix
+            nodes: "[[FR.REQUIREMENT:*]]"
+            links:
+                -   DEPENDS-ON
+            onlyConnected: true
+            qualified: true
+            nest:
+                properties:
+                    -   GROUP
     children:
         -   kind: GROUP
             desc: >
@@ -768,6 +808,7 @@
     diagram:
         type: grid
         nodes: "[[NR.REQUIREMENT:*]]"
+        markUncovered: referenced
         nest:
             properties:
                 -   GROUP
@@ -901,6 +942,7 @@
     diagram:
         type: grid
         nodes: "[[RULE:*]]"
+        markUncovered: referenced
         properties:
             -   CATEGORY
             -   SOURCE
@@ -1360,14 +1402,23 @@
         -   OMG UML 2.5.1: Unified Modeling Language (2017),
             https://www.omg.org/spec/UML/2.5.1
     diagram:
-        type: graph
-        nodes: "[[DM.ENTITY:*]]"
-        edges: "[[RELATION:*]]"
-        nest:
-            properties:
-                -   GROUP
-        config:
-            graph-columns-max: 2
+        -   type: graph
+            nodes: "[[DM.ENTITY:*]]"
+            edges: "[[RELATION:*]]"
+            nest:
+                properties:
+                    -   GROUP
+            config:
+                graph-columns-max: 2
+        -   type: matrix
+            nodes: "[[DM.ENTITY:*]]"
+            edges: "[[RELATION:*]]"
+            qualified: true
+            nest:
+                properties:
+                    -   GROUP
+            config:
+                mark-violation: false
     children:
         -   kind: GROUP
             name: "[A-Z][a-zA-Z0-9]*"
@@ -1391,6 +1442,7 @@
                 per-artifact unique name, and described by a 1-sentence description ("what") plus a
                 1-sentence rationale ("why").
             optional: true
+            badge: database
             diagram:
                 type: hub
                 center: self
@@ -1567,14 +1619,11 @@
                 initial: INITIAL
                 final: FINAL
             diagram:
-                type: graph
+                type: state
                 edges: "[[TRANSITION:*]]"
                 edgeSource: FROM
                 edgeTarget: TO
                 onlyConnected: true
-                properties:
-                    -   INITIAL
-                    -   FINAL
                 config:
                     size-node-width-max: 440
                     size-node-height-scale: 1.75
@@ -1688,6 +1737,9 @@
         domain rules. The model is closed: an operation not granted to a role is forbidden,
         exactly like a move not listed as a state transition.
     optional: true
+    coverage:
+        -   "[[DM.ENTITY:*]]"
+        -   "[[USE-CASE:*]]"
     refs: >
         -   Ferraiolo/Kuhn: Role-Based Access Controls, 15th National Computer Security Conference (1992),
             https://csrc.nist.gov/publications/detail/conference-paper/1992/10/13/role-based-access-controls
@@ -1837,6 +1889,7 @@
                 direction, command) are carried by the `OPERATION` and `LOCATOR` properties of the
                 endpoints only.
             optional: true
+            badge: api
             diagram:
                 type: hub
                 center: self
@@ -1901,14 +1954,23 @@
         -   GraphQL Foundation: GraphQL Specification (2021),
             https://spec.graphql.org/October2021/
     diagram:
-        type: graph
-        nodes: "[[TYPE:*]]"
-        deep: true
-        onlyConnected: true
-        labeled: true
-        qualified: true
-        config:
-            size-node-width-max: 440
+        -   type: graph
+            nodes: "[[TYPE:*]]"
+            deep: true
+            onlyConnected: true
+            labeled: true
+            qualified: true
+            config:
+                size-node-width-max: 440
+        -   type: tree
+            nodes: "[[TYPE:*]]"
+            links: []
+            onlyConnected: true
+            nest:
+                properties:
+                    -   EXTENDS
+            config:
+                mark-violation: false
     children:
         -   kind: TYPE
             name: "[A-Z][A-Za-z0-9_]*"
@@ -2093,6 +2155,7 @@
                 is expressed by a path-style `LOCATOR` (e.g. `remote add`,
                 `/events/{eventId}/chat`) only.
             optional: true
+            badge: api
             diagram:
                 type: hub
                 center: self
@@ -2309,6 +2372,7 @@
     diagram:
         type: grid
         nodes: "[[IC.PRINCIPLE:*]]"
+        markUncovered: referenced
         properties:
             -   CATEGORY
         config:
@@ -2494,14 +2558,20 @@
             https://www.oreilly.com/library/view/designing-interfaces-3rd/9781492051954/
     optional: true
     diagram:
-        type: grid
-        nodes: "[[DIALOG-PATTERN:*]]"
-        properties:
-            -   CATEGORY
-        config:
-            size-node-width-max: 440
-            size-node-height-scale: 2
-            grid-columns-max: 4
+        -   type: grid
+            nodes: "[[DIALOG-PATTERN:*]]"
+            properties:
+                -   CATEGORY
+            config:
+                size-node-width-max: 440
+                size-node-height-scale: 2
+                grid-columns-max: 4
+        -   type: matrix
+            nodes: "[[DIALOG-PATTERN:*]]"
+            links:
+                -   USES
+            onlyConnected: true
+            qualified: true
     children:
         -   kind: DIALOG-PATTERN
             desc: >
@@ -2588,6 +2658,8 @@
         -   NN/g: Storyboards Help Visualize UX Ideas (2018),
             https://www.nngroup.com/articles/storyboards-visualize-ideas/
     optional: true
+    coverage:
+        -   "[[USE-CASE:*]]"
     diagram:
         type: grid
         nodes: "[[STORYBOARD:*]]"
@@ -3074,6 +3146,18 @@
             format:
                 type: compact
                 maxTableColumns: 5
+            diagram:
+                type: hub
+                center: self
+                nodes: "[[CV.ENTITY:*]], [[PREMISE:*]], [[TERM:*]], [[ROLE:*]], [[USE-CASE:*]],
+                    [[INTERFACE:*]], [[INTERACTION:*]], [[DECISION:*]]"
+                descend:
+                    -   MESSAGE
+                labeled: true
+                qualified: true
+                config:
+                    size-node-width-max: 440
+                    size-node-height-scale: 1.75
             props:
                 -   name: KIND
                     desc: |
@@ -3163,6 +3247,9 @@
         interactions, describing *how* the solution's runtime elements are structured and which
         responsibility each owns, delivering the behaviors the Functional Requirements state.
     optional: true
+    coverage:
+        -   "[[FR.REQUIREMENT:*]]"
+        -   "[[DM.ENTITY:*]]"
     refs: >
         -   Rozanski/Woods: Software Systems Architecture, 2nd ed.: The Functional Viewpoint (2011),
             https://www.viewpoints-and-perspectives.info/home/viewpoints/functional/
@@ -3171,14 +3258,22 @@
         -   Brown: The C4 Model (2018),
             https://c4model.com/
     diagram:
-        type: graph
-        nodes: "[[FV.COMPONENT:*]]"
-        labeled: true
-        nest:
+        -   type: graph
+            nodes: "[[FV.COMPONENT:*]]"
+            labeled: true
+            nest:
+                properties:
+                    -   PART-OF
             properties:
-                -   PART-OF
-        properties:
-            -   KIND
+                -   KIND
+        -   type: matrix
+            nodes: "[[FV.COMPONENT:*]]"
+            links:
+                -   DEPENDS-ON
+            qualified: true
+            nest:
+                properties:
+                    -   PART-OF
     children:
         -   kind: COMPONENT
             desc: >
@@ -3193,12 +3288,22 @@
             format:
                 type: compact
                 maxTableColumns: 5
+            badge:
+                property: KIND
+                map:
+                    Component: package
+                    Service: service
+                    Module: code
+                    Connector: communication
+                    Subsystem: network
             diagram:
                 type: hub
                 center: self
-                nodes: "[[FV.COMPONENT:*]], [[FR.REQUIREMENT:*]], [[PATTERN:*]], [[INTERFACE:*]],
-                    [[DM.ENTITY:*]], [[UNIT:*]], [[NODE:*]], [[CONCERN:*]], [[TACTIC:*]],
-                    [[DECISION:*]], [[CODE-PATTERN:*]]"
+                nodes: "[[FV.COMPONENT:*]], [[INTERACTION:*]], [[FR.REQUIREMENT:*]], [[PATTERN:*]],
+                    [[INTERFACE:*]], [[DM.ENTITY:*]], [[UNIT:*]], [[NODE:*]], [[CONCERN:*]],
+                    [[TACTIC:*]], [[DECISION:*]], [[CODE-PATTERN:*]]"
+                descend:
+                    -   MESSAGE
                 labeled: true
                 qualified: true
                 properties:
@@ -3257,8 +3362,10 @@
                     desc: >
                         Comma-separated references to the INTERFACE-MODEL objects the component
                         provides, i.e. through which other components and external entities
-                        interact with it; omitted when the component provides no modeled interface
-                        (e.g. a user interface or an internal module).
+                        interact with it, which are always `Provided` ones, as a `Required`
+                        interface is offered by an external entity instead; omitted when the
+                        component provides no modeled interface (e.g. a user interface or an
+                        internal module).
                     value: list([[INTERFACE:*]])
                     optional: true
                 -   name: CONSUMES
@@ -3279,10 +3386,274 @@
                     value: list([[FV.COMPONENT:*]])
                     optional: true
 
+-   kind: ARCH
+    name: Runtime View
+    id: RV
+    file: 26-ARCH-RV-Runtime-View.md
+    desc: >
+        The runtime interactions of the solution: for each significant use case scenario or
+        technical situation, the ordered messages its participants -- roles, Functionality View
+        components, and Context View entities -- exchange, describing *how* the components
+        collaborate at runtime to deliver the behaviors their static structure merely enables.
+    optional: true
+    coverage:
+        -   "[[USE-CASE:*]]"
+        -   "[[SCENARIO:*]]"
+    refs: >
+        -   Starke/Hruschka: arc42 Template: Runtime View (2005),
+            https://docs.arc42.org/section-6/
+        -   OMG UML 2.5.1: Unified Modeling Language: Interactions (2017),
+            https://www.omg.org/spec/UML/2.5.1
+        -   Brown: The C4 Model: Dynamic Diagram (2018),
+            https://c4model.com/diagrams/dynamic
+        -   Kruchten: Architectural Blueprints -- The "4+1" View Model of Software Architecture (1995),
+            https://ieeexplore.ieee.org/document/469759
+        -   Rozanski/Woods: Software Systems Architecture, 2nd ed.: The Functional Viewpoint (2011),
+            https://www.viewpoints-and-perspectives.info/home/viewpoints/functional/
+    diagram:
+        type: grid
+        nodes: "[[INTERACTION:*]]"
+        config:
+            size-node-width-max: 440
+            grid-columns-max: 3
+    children:
+        -   kind: INTERACTION
+            desc: >
+                A single runtime interaction, named with a short (2-5 word) summary of the
+                situation it shows (e.g. `Ask a Question`, `Login with Token`) and described in a
+                concise (1-3 sentence) paragraph by its trigger and its outcome, plus a 1-sentence
+                rationale ("why") stating what the interaction makes explicit, while its MESSAGE
+                children, in document order, are the messages its participants exchange.
+            optional: true
+            diagram:
+                type: sequence
+                edges: "[[MESSAGE:*]]"
+                local: true
+                edgeSource: FROM
+                edgeTarget: TO
+                edgeKind: KIND
+                edgeDuration: DURATION
+                edgeTime: TIME
+                qualified: true
+            props:
+                -   name: REALIZES
+                    desc: >
+                        Comma-separated references to the USE-CASES objects (use cases or their
+                        scenarios) the interaction realizes, tracing the runtime behavior back to
+                        the behavior the requirements state; omitted for a purely technical
+                        interaction (e.g. a startup or a failover).
+                    value: list([[USE-CASE:*]], [[SCENARIO:*]])
+                    optional: true
+            children:
+                -   kind: MESSAGE
+                    desc: >
+                        A single message of the interaction, named with a short (1-4 word),
+                        per-interaction unique summary of the operation, event, or response it
+                        carries (e.g. `submit question`, `question stored`) and described by a
+                        1-sentence description of its effect.
+                    format:
+                        type: concise
+                        maxTableColumns: 7
+                        withUnusedProps: true
+                    props:
+                        -   name: FROM
+                            desc: >
+                                Reference to the participant sending the message: a USER-PERSONAS
+                                role, a FUNCTIONALITY-VIEW component, or a CONTEXT-VIEW entity.
+                            value: list([[ROLE:*]], [[FV.COMPONENT:*]], [[CV.ENTITY:*]])
+                        -   name: TO
+                            desc: >
+                                Comma-separated references to the participants receiving the
+                                message (several ones yielding one message each): USER-PERSONAS
+                                roles, FUNCTIONALITY-VIEW components, or CONTEXT-VIEW entities.
+                            value: list([[ROLE:*]], [[FV.COMPONENT:*]], [[CV.ENTITY:*]])
+                        -   name: KIND
+                            desc: |
+                                The kind of the message, one of:
+                                -   `Call`:    Synchronous request the sender waits for (the default).
+                                -   `Signal`:  Asynchronous notification the sender does not wait for.
+                                -   `Return`:  Response to the latest unanswered call of its receiver.
+                                -   `Create`:  Instantiation of its receiver, which starts there.
+                                -   `Destroy`: Termination of its receiver, which ends there.
+                            value: enum(Call,Signal,Return,Create,Destroy)
+                            optional: true
+                        -   name: DURATION
+                            desc: >
+                                Duration constraint of a call up to its return (e.g. `< 200ms`),
+                                drawn as a bracket beside the lifeline of the caller.
+                            optional: true
+                        -   name: TIME
+                            desc: >
+                                Time constraint or observation at the start of the message (e.g.
+                                `t = now`), drawn beside the lifeline of the sender.
+                            optional: true
+
+-   kind: ARCH
+    name: Concurrency View
+    id: CO
+    file: 27-ARCH-CO-Concurrency-View.md
+    desc: >
+        The concurrency structure of the solution, mapping functional components to processes and
+        threads, and defining how they coordinate and communicate. The artifact is absent when the
+        solution runs as a single sequential unit of execution and has no concurrency structure
+        worth describing.
+    optional: true
+    coverage:
+        -   "[[FV.COMPONENT:*]]"
+    refs: >
+        -   Rozanski/Woods: Software Systems Architecture, 2nd ed.: The Concurrency Viewpoint (2011),
+            https://www.viewpoints-and-perspectives.info/home/viewpoints/concurrency/
+        -   Kruchten: Architectural Blueprints -- The "4+1" View Model of Software Architecture (1995),
+            https://ieeexplore.ieee.org/document/469759
+        -   Schmidt et al.: Pattern-Oriented Software Architecture, Volume 2: Patterns for Concurrent and Networked Objects (2000),
+            https://www.wiley.com/en-us/Pattern+Oriented+Software+Architecture,+Volume+2,+Patterns+for+Concurrent+and+Networked+Objects-p-9781118725177
+    diagram:
+        -   type: graph
+            nodes: "[[UNIT:*]]"
+            labeled: true
+            properties:
+                -   KIND
+        -   type: petri
+            nodes: "[[RESOURCE:*]], [[UNIT:*]]"
+            places: "[[RESOURCE:*]]"
+            links:
+                -   CONSUMES
+                -   PRODUCES
+            reverse:
+                -   CONSUMES
+            tokens: TOKENS
+            capacity: CAPACITY
+            onlyConnected: true
+    children:
+        -   kind: RESOURCE
+            desc: >
+                A single coordination resource the concurrency units share, named with a short (2-5
+                word) summary (e.g. `Ingest Queue`, `Database Connections`, `Render Lock`) and
+                described in a concise (1-3 sentence) paragraph by what its items are and how full
+                it may get, plus a 1-sentence rationale ("why") for its bound.
+
+                The resources and the units form a Petri net: a resource is a place holding items
+                (tokens), a unit a transition taking items out of the resources it names in
+                `CONSUMES` and putting items into the resources it names in `PRODUCES`, so the
+                analysis of the net reveals unbounded resources (missing backpressure), deadlocks,
+                and units never or no longer able to work.
+            optional: true
+            props:
+                -   name: KIND
+                    desc: |
+                        The kind of the coordination resource, one of:
+
+                        -   `Queue`:     A buffer of work items between producers and consumers.
+                        -   `Topic`:     A publish/subscribe channel delivering messages.
+                        -   `Pool`:      A bounded set of reusable instances (e.g. connections).
+                        -   `Mutex`:     An exclusive lock (a single token).
+                        -   `Semaphore`: A counting lock (several tokens).
+                    value: enum(Queue,Topic,Pool,Mutex,Semaphore)
+                -   name: CAPACITY
+                    desc: >
+                        The maximum number of items the resource holds (e.g. a queue limit or the
+                        size of a pool), omitted for an unbounded resource.
+                    value: /^[1-9][0-9]*$/
+                    optional: true
+                -   name: TOKENS
+                    desc: >
+                        The number of items the resource initially holds (e.g. the free
+                        connections of a pool or the `1` of a free mutex), omitted for none.
+                    value: /^(?:0|[1-9][0-9]*)$/
+                    optional: true
+        -   kind: UNIT
+            desc: >
+                A single concurrency unit, named with a short (2-5 word) summary (e.g. `Web Worker
+                Pool`, `Background Scheduler`, `Ingest Queue Consumer`) and described in a concise
+                (1-3 sentence) paragraph by how it executes and how it avoids or manages contention,
+                races, and deadlocks (including its start order and failure/restart behavior where
+                non-obvious), plus a 1-sentence rationale ("why") for the chosen concurrency
+                structure.
+
+                A unit executes work at runtime: a queue or channel between units is not a unit
+                but the coordination mechanism stated in `COORDINATION`, its contract an Interface
+                Model interface (e.g. of kind `MQTT` or `WebSocket`), and the platform element
+                hosting a managed broker a Deployment View `Managed` node -- only the executing
+                structure itself belongs to the Concurrency View.
+            optional: true
+            multiple:
+                property: MULTIPLICITY
+                pattern: ^\s*(?:\d*\.\.\s*(?:n|\*|[2-9]|\d{2,})|[2-9]|\d{2,}|n\b)
+            diagram:
+                type: hub
+                center: self
+                nodes: "[[UNIT:*]], [[RESOURCE:*]], [[FV.COMPONENT:*]], [[NODE:*]], [[TACTIC:*]], [[DECISION:*]]"
+                labeled: true
+                qualified: true
+                properties:
+                    -   KIND
+                config:
+                    size-node-width-max:    440
+                    size-node-height-scale: 1.75
+                    hub-node-count-max:     3
+            props:
+                -   name: KIND
+                    desc: |
+                        The kind of the concurrency unit, one of:
+
+                        -   `Process`:   An independent OS process with its own address space.
+                        -   `Thread`:    A thread of execution within a process.
+                        -   `Task`:      A lightweight cooperative task (e.g. coroutine, fiber).
+                        -   `Pool`:      A managed group of interchangeable workers.
+                        -   `EventLoop`: A single-threaded cooperative scheduler of tasks.
+                    value: enum(Process,Thread,Task,Pool,EventLoop)
+                -   name: PART-OF
+                    desc: >
+                        Reference to the CONCURRENCY-VIEW object this unit is contained in,
+                        expressing the containment the kinds imply: a `Thread`, `Task`, `Pool`, or
+                        `EventLoop` references the `Process` it executes within, and a `Task` the
+                        `EventLoop` or `Pool` scheduling it; omitted for a top-level unit.
+                    value: "[[UNIT:*]]"
+                    optional: true
+                    acyclic: true
+                -   name: HOSTS
+                    desc: >
+                        Comma-separated references to the FUNCTIONALITY-VIEW objects that run inside
+                        this concurrency unit; omitted when no modeled component runs inside it.
+                    value: list([[FV.COMPONENT:*]])
+                    optional: true
+                -   name: MULTIPLICITY
+                    desc: >
+                        How many instances of the unit run (e.g. `1`, `1 per CPU core`, `0..n
+                        auto-scaled`).
+                -   name: COORDINATES-WITH
+                    desc: >
+                        Comma-separated references to the CONCURRENCY-VIEW objects this unit
+                        coordinates or communicates with at runtime, naming the peer unit only
+                        (e.g. a producer names the consumer it feeds through a shared queue),
+                        while the mechanism is stated by `COORDINATION`.
+                    value: list([[UNIT:*]])
+                    optional: true
+                -   name: COORDINATION
+                    desc: >
+                        The mechanism by which the unit coordinates or communicates with other
+                        units, usually those referenced in `COORDINATES-WITH` (e.g. `shared
+                        queue`, `mutex`, `message passing`, `optimistic locking`).
+                -   name: CONSUMES
+                    desc: >
+                        Comma-separated references to the CONCURRENCY-VIEW resources the unit takes
+                        work items or instances out of (e.g. the queue it drains, the pool it takes
+                        a connection from), modeling the unit as a transition of the Petri net its
+                        resources form; omitted when it consumes from none.
+                    value: list([[RESOURCE:*]])
+                    optional: true
+                -   name: PRODUCES
+                    desc: >
+                        Comma-separated references to the CONCURRENCY-VIEW resources the unit puts
+                        work items or freed instances into (e.g. the queue it feeds, the pool it
+                        returns a connection to); omitted when it produces into none.
+                    value: list([[RESOURCE:*]])
+                    optional: true
+
 -   kind: ARCH
     name: Technology Stack
     id: TS
-    file: 26-ARCH-TS-Technology-Stack.md
+    file: 28-ARCH-TS-Technology-Stack.md
     desc: >
         The concrete technology products the solution is built upon, organized by tier and lifecycle
         phase, recording for each component its chosen product, its purpose, and the alternatives
@@ -3294,16 +3665,14 @@
         -   Brown: The C4 Model: Container Diagram (2018),
             https://c4model.com/diagrams/container
     diagram:
-        type: grid
+        type: layer
         nodes: "[[TS.TIER:*]], [[TS.TIER:*.COMPONENT:*]]"
         nest:
             parent: true
-            layout: grid
         properties:
             -   PRODUCT
         config:
             size-node-width-max: 440
-            grid-columns-max: 2
     children:
         -   kind: TIER
             desc: |
@@ -3643,7 +4012,7 @@
 -   kind: ARCH
     name: Development Aspects
     id: DA
-    file: 27-ARCH-DA-Development-Aspects.md
+    file: 29-ARCH-DA-Development-Aspects.md
     desc: >
         The architecture supporting the software development process, defining the module
         organization, build approach, and codeline conventions. The artifact is absent when the
@@ -3715,109 +4084,16 @@
                     value: list([[MAXIM:*]], [[AT.PRINCIPLE:*]])
                     optional: true
 
--   kind: ARCH
-    name: Concurrency View
-    id: CO
-    file: 28-ARCH-CO-Concurrency-View.md
-    desc: >
-        The concurrency structure of the solution, mapping functional components to processes and
-        threads, and defining how they coordinate and communicate. The artifact is absent when the
-        solution runs as a single sequential unit of execution and has no concurrency structure
-        worth describing.
-    optional: true
-    refs: >
-        -   Rozanski/Woods: Software Systems Architecture, 2nd ed.: The Concurrency Viewpoint (2011),
-            https://www.viewpoints-and-perspectives.info/home/viewpoints/concurrency/
-        -   Kruchten: Architectural Blueprints -- The "4+1" View Model of Software Architecture (1995),
-            https://ieeexplore.ieee.org/document/469759
-        -   Schmidt et al.: Pattern-Oriented Software Architecture, Volume 2: Patterns for Concurrent and Networked Objects (2000),
-            https://www.wiley.com/en-us/Pattern+Oriented+Software+Architecture,+Volume+2,+Patterns+for+Concurrent+and+Networked+Objects-p-9781118725177
-    diagram:
-        type: graph
-        nodes: "[[UNIT:*]]"
-        labeled: true
-        properties:
-            -   KIND
-    children:
-        -   kind: UNIT
-            desc: >
-                A single concurrency unit, named with a short (2-5 word) summary (e.g. `Web Worker
-                Pool`, `Background Scheduler`, `Ingest Queue Consumer`) and described in a concise
-                (1-3 sentence) paragraph by how it executes and how it avoids or manages contention,
-                races, and deadlocks (including its start order and failure/restart behavior where
-                non-obvious), plus a 1-sentence rationale ("why") for the chosen concurrency
-                structure.
-
-                A unit executes work at runtime: a queue or channel between units is not a unit
-                but the coordination mechanism stated in `COORDINATION`, its contract an Interface
-                Model interface (e.g. of kind `MQTT` or `WebSocket`), and the platform element
-                hosting a managed broker a Deployment View `Managed` node -- only the executing
-                structure itself belongs to the Concurrency View.
-            optional: true
-            diagram:
-                type: hub
-                center: self
-                nodes: "[[UNIT:*]], [[FV.COMPONENT:*]], [[NODE:*]], [[TACTIC:*]], [[DECISION:*]]"
-                labeled: true
-                qualified: true
-                properties:
-                    -   KIND
-                config:
-                    size-node-width-max:    440
-                    size-node-height-scale: 1.75
-                    hub-node-count-max:     3
-            props:
-                -   name: KIND
-                    desc: |
-                        The kind of the concurrency unit, one of:
-
-                        -   `Process`:   An independent OS process with its own address space.
-                        -   `Thread`:    A thread of execution within a process.
-                        -   `Task`:      A lightweight cooperative task (e.g. coroutine, fiber).
-                        -   `Pool`:      A managed group of interchangeable workers.
-                        -   `EventLoop`: A single-threaded cooperative scheduler of tasks.
-                    value: enum(Process,Thread,Task,Pool,EventLoop)
-                -   name: PART-OF
-                    desc: >
-                        Reference to the CONCURRENCY-VIEW object this unit is contained in,
-                        expressing the containment the kinds imply: a `Thread`, `Task`, `Pool`, or
-                        `EventLoop` references the `Process` it executes within, and a `Task` the
-                        `EventLoop` or `Pool` scheduling it; omitted for a top-level unit.
-                    value: "[[UNIT:*]]"
-                    optional: true
-                    acyclic: true
-                -   name: HOSTS
-                    desc: >
-                        Comma-separated references to the FUNCTIONALITY-VIEW objects that run inside
-                        this concurrency unit; omitted when no modeled component runs inside it.
-                    value: list([[FV.COMPONENT:*]])
-                    optional: true
-                -   name: MULTIPLICITY
-                    desc: >
-                        How many instances of the unit run (e.g. `1`, `1 per CPU core`, `0..n
-                        auto-scaled`).
-                -   name: COORDINATES-WITH
-                    desc: >
-                        Comma-separated references to the CONCURRENCY-VIEW objects this unit
-                        coordinates or communicates with at runtime, naming the peer unit only
-                        (e.g. a producer names the consumer it feeds through a shared queue),
-                        while the mechanism is stated by `COORDINATION`.
-                    value: list([[UNIT:*]])
-                    optional: true
-                -   name: COORDINATION
-                    desc: >
-                        The mechanism by which the unit coordinates or communicates with other
-                        units, usually those referenced in `COORDINATES-WITH` (e.g. `shared
-                        queue`, `mutex`, `message passing`, `optimistic locking`).
-
 -   kind: ARCH
     name: Deployment View
     id: DV
-    file: 29-ARCH-DV-Deployment-View.md
+    file: 30-ARCH-DV-Deployment-View.md
     desc: >
         The environment into which the solution is deployed, partitioning it into tiers and mapping
         software elements to the runtime platform, hardware, and network topology.
     optional: true
+    coverage:
+        -   "[[UNIT:*]]"
     refs: >
         -   Rozanski/Woods: Software Systems Architecture, 2nd ed.: The Deployment Viewpoint (2011),
             https://www.viewpoints-and-perspectives.info/home/viewpoints/deployment/
@@ -3826,20 +4102,28 @@
         -   Brown: The C4 Model: Deployment Diagram (2018),
             https://c4model.com/diagrams/deployment
     diagram:
-        type: graph
-        nodes: "[[NODE:*]]"
-        labeled: true
-        qualified: true
-        nest:
+        -   type: graph
+            nodes: "[[NODE:*]]"
+            labeled: true
+            qualified: true
+            nest:
+                properties:
+                    -   PART-OF
+                    -   TIER
             properties:
-                -   PART-OF
-                -   TIER
-        properties:
-            -   AREA
-            -   KIND
-            -   PLATFORM
-        config:
-            size-node-width-max: 350
+                -   AREA
+                -   KIND
+                -   PLATFORM
+            config:
+                size-node-width-max: 350
+        -   type: tree
+            nodes: "[[NODE:*]]"
+            links: []
+            qualified: true
+            nest:
+                properties:
+                    -   PART-OF
+                    -   TIER
     children:
         -   kind: TIER
             desc: >
@@ -3919,6 +4203,52 @@
                 config:
                     size-node-width-max:    440
                     size-node-height-scale: 1.75
+        -   kind: NETWORK
+            desc: >
+                A single network segment the deployment nodes are attached to, named with a short
+                (2-5 word) summary (e.g. `Public Internet`, `Backend VLAN`, `Database Subnet`) and
+                described in a concise (1-3 sentence) paragraph by its reach, its isolation from the
+                other segments, and the traffic it carries, plus a 1-sentence rationale ("why") for
+                the segmentation.
+
+                A segment is the medium the nodes communicate over: the attached nodes reference it
+                via `NETWORKS`, the directed links between them are their `CONNECTS-TO` references,
+                and the contract of the carried traffic is an Interface Model interface -- only the
+                network itself belongs here. The kind is absent when the topology has no
+                segmentation worth describing.
+            optional: true
+            format:
+                type: concise
+            diagram:
+                type: hub
+                center: self
+                nodes: "[[NETWORK:*]], [[NODE:*]], [[TACTIC:*]], [[DECISION:*]]"
+                labeled: true
+                qualified: true
+                properties:
+                    -   KIND
+                    -   SCOPE
+                config:
+                    size-node-width-max:    440
+                    size-node-height-scale: 1.75
+                    hub-node-count-max:     3
+            props:
+                -   name: SCOPE
+                    desc: |
+                        The reach of the segment, one of:
+                        -   `Public`:   Reachable from the Internet.
+                        -   `Private`:  Reachable from the solution's own nodes only.
+                        -   `Isolated`: Reachable from selected nodes only (e.g. a database subnet).
+                    value: enum(Public,Private,Isolated)
+                -   name: PROTOCOLS
+                    desc: >
+                        The protocols and ports carried by the segment (e.g. `HTTPS 443, WSS 443`,
+                        `HTTP, WS, TCP 5432`).
+                -   name: ADDRESSING
+                    desc: >
+                        The address range or naming of the segment (e.g. `10.0.0.0/8`, `public IPv4
+                        and IPv6`, `*.example.com`).
+                    optional: true
         -   kind: NODE
             desc: >
                 A single deployment node, named with a short (2-5 word) summary (e.g. `Web Servers`,
@@ -3935,6 +4265,18 @@
                 and the network segments it is attached to as its `TIER`, `AREA`, and `NETWORK`
                 siblings.
             optional: true
+            badge:
+                property: KIND
+                map:
+                    Server: service
+                    Container: package
+                    Cluster: network
+                    Function: function
+                    Device: device
+                    Managed: cloud
+            multiple:
+                property: INSTANCES
+                pattern: ^\s*(?:\d*\.\.\s*(?:n|\*|[2-9]|\d{2,})|[2-9]|\d{2,}|n\b)
             diagram:
                 type: hub
                 center: self
@@ -4018,57 +4360,11 @@
                         when the topology models no network segments.
                     value: list([[NETWORK:*]])
                     optional: true
-        -   kind: NETWORK
-            desc: >
-                A single network segment the deployment nodes are attached to, named with a short
-                (2-5 word) summary (e.g. `Public Internet`, `Backend VLAN`, `Database Subnet`) and
-                described in a concise (1-3 sentence) paragraph by its reach, its isolation from the
-                other segments, and the traffic it carries, plus a 1-sentence rationale ("why") for
-                the segmentation.
-
-                A segment is the medium the nodes communicate over: the attached nodes reference it
-                via `NETWORKS`, the directed links between them are their `CONNECTS-TO` references,
-                and the contract of the carried traffic is an Interface Model interface -- only the
-                network itself belongs here. The kind is absent when the topology has no
-                segmentation worth describing.
-            optional: true
-            format:
-                type: concise
-            diagram:
-                type: hub
-                center: self
-                nodes: "[[NETWORK:*]], [[NODE:*]], [[TACTIC:*]], [[DECISION:*]]"
-                labeled: true
-                qualified: true
-                properties:
-                    -   KIND
-                    -   SCOPE
-                config:
-                    size-node-width-max:    440
-                    size-node-height-scale: 1.75
-                    hub-node-count-max:     3
-            props:
-                -   name: SCOPE
-                    desc: |
-                        The reach of the segment, one of:
-                        -   `Public`:   Reachable from the Internet.
-                        -   `Private`:  Reachable from the solution's own nodes only.
-                        -   `Isolated`: Reachable from selected nodes only (e.g. a database subnet).
-                    value: enum(Public,Private,Isolated)
-                -   name: PROTOCOLS
-                    desc: >
-                        The protocols and ports carried by the segment (e.g. `HTTPS 443, WSS 443`,
-                        `HTTP, WS, TCP 5432`).
-                -   name: ADDRESSING
-                    desc: >
-                        The address range or naming of the segment (e.g. `10.0.0.0/8`, `public IPv4
-                        and IPv6`, `*.example.com`).
-                    optional: true
 
 -   kind: ARCH
     name: Operations View
     id: OV
-    file: 30-ARCH-OV-Operations-View.md
+    file: 31-ARCH-OV-Operations-View.md
     desc: >
         The way the solution is operated, administered, and supported in production, defining the
         standing procedures by which the operating organization installs, configures, migrates,
@@ -4183,7 +4479,7 @@
 -   kind: ARCH
     name: Quality Perspectives
     id: QP
-    file: 31-ARCH-QP-Quality-Perspectives.md
+    file: 32-ARCH-QP-Quality-Perspectives.md
     desc: >
         How the Non-Functional Requirements (NR) are addressed by the architecture, through the
         tactics built into the solution across the views.
@@ -4328,7 +4624,7 @@
 -   kind: ARCH
     name: Design Decisions
     id: DD
-    file: 32-ARCH-DD-Design-Decisions.md
+    file: 33-ARCH-DD-Design-Decisions.md
     desc: >
         The major decisions related to the solution design, each recording the forces at play, the
         chosen response, and the reasoning that justifies it. The artifact is the last
@@ -4583,7 +4879,7 @@
 -   kind: ARCH
     name: Code Patterns
     id: CP
-    file: 33-ARCH-CP-Code-Patterns.md
+    file: 34-ARCH-CP-Code-Patterns.md
     desc: >
         The implementation patterns the source code of the solution follows, each prescribing how
         one recurring concern (e.g. authorization enforcement, entity persistence, error
@@ -4699,7 +4995,7 @@
 -   kind: TEST
     name: Test Cases
     id: TC
-    file: 34-TEST-TC-Test-Cases.md
+    file: 35-TEST-TC-Test-Cases.md
     desc: >
         The verifiable conditions and steps used to confirm that requirements, domain rules, use
         case scenarios, state transitions, and the mechanisms, procedures, and decisions of the