@memoarchitect/ontology 0.7.0 → 0.8.24

package/examples/reusable-instrument/model/catalog/viewpoints/unassigned/views/reusable_instrument_overview.sysml

@@ -6,7 +6,6 @@ package memo_examples_reusable_instrument_viewpoints_unassigned_views_reusable_i
     view reusableInstrumentOverview : MemoDiagramView {
         expose memo_examples_reusable_instrument::*;
         attribute depth = 2;
-        attribute :>> title = "Reusable Instrument Overview";
         attribute :>> viewKind = DiagramViewKind::actionflow;
         attribute :>> diagramType = "ofd";
     }

package/examples/ros-mobile-robot/README.md

@@ -0,0 +1,40 @@
+# ROS mobile robot
+
+A focused MEMO example that demonstrates **using an extension**. The subject is
+a ROS 2 mobile logistics robot; the point is the mechanism.
+
+Extensions are a way to model, so they live in [`extensions/`](../../extensions),
+beside the ontology. This project is one of their consumers.
+
+- `model/catalog/project.sysml` — the binding. It lists three extension modules
+  (`memo_extension_messaging`, `memo_extension_container`, `memo_extension_ros`)
+  in `includedModule`. That is how extensions compose: at the project binding,
+  never by chaining methodologies.
+- `model/catalog/ros_mobile_robot.sysml` — the model.
+- `model/catalog/viewpoints/` — diagram views over that catalog.
+
+## What it shows
+
+1. **Extension types are used exactly like base types.** `RosNode` specializes
+   `SoftwareComponent`, so it inherits period, WCET, priority, safety class and
+   fault containment, and every base rule still applies to it. The three nodes
+   set `runtimeKind` individually — two composed into one container process,
+   the safety monitor in its own — because that is a design decision the
+   extension type must not make for the modeller.
+2. **Publish and subscribe use native SysML.** A ROS message is an item
+   definition, a named topic is its item usage, nodes own `out` publisher and
+   `in` subscriber ports, and native interfaces/flows connect those ports. The
+   extension declares no publish/subscribe relation.
+3. **Deployment reuses the base relations unchanged.** `BuildsInto`,
+   `DeploysTo` and `ProvidesEnvironment` carry the whole chain from source
+   module to container image to compute unit to ROS runtime, with no
+   ROS-specific relation anywhere in it. That is the evidence the base is
+   factored correctly.
+4. **QoS is a typed profile, not a property bag.** Publisher ports carry an
+   offered `RosQosProfile` and subscriber ports a requested one, so the incompatibility
+   that silently delivers nothing at runtime is two adjacent values in the
+   model. This is why the `PropertySet` stub was deleted rather than made real.
+5. **Services and actions are different native interface contracts.** A service
+   has one request and one correlated response. An action has goal,
+   acceptance, feedback, cancellation, result, and status features plus a
+   native execution-state family.

package/examples/ros-mobile-robot/memo.package.yaml

@@ -0,0 +1,3 @@
+name: ros-mobile-robot
+entrypoint: model/catalog/project.sysml
+include: [model]

package/examples/ros-mobile-robot/model/catalog/project.sysml

@@ -0,0 +1,33 @@
+// ROS Mobile Robot — project identity and method binding.
+//
+// The native entrypoint. The imports name what this project contains and the
+// binding names the methodology it is governed by. No YAML file participates.
+package memo_examples_ros_mobile_robot_project {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_methodology_core::*;
+    private import memo_methodology_profiles::*;
+
+    // The project's own content, imported so the catalog is one reachable
+    // closure from a single entrypoint.
+    private import memo_examples_ros_mobile_robot_viewpoints_unassigned::*;
+    private import memo_examples_ros_mobile_robot_viewpoints_unassigned_views_ros_mobile_robot_overview::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-ROS-MOBILE-ROBOT-001";
+        attribute :>> name = "RosMobileRobotProjectMethodBinding";
+        attribute :>> projectName = "ROS Mobile Robot";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+        // This is the composition mechanism: three independent extensions,
+        // listed here. `includedModule` is [0..*] on both MethodologyDefinition
+        // and ProjectMethodBinding, while `baseMethodology` is [0..1] — so
+        // extensions combine at the binding and never by chaining.
+        attribute :>> includedModule = (
+            "memo_extension_messaging",
+            "memo_extension_container",
+            "memo_extension_ros"
+        );
+    }
+}

package/examples/ros-mobile-robot/model/catalog/ros_mobile_robot.sysml

@@ -0,0 +1,296 @@
+// Focused example: a ROS 2 mobile logistics robot, modelled with the ROS
+// extension. The point of the example is the MECHANISM, not the robot — it
+// demonstrates how an extension is used, and it is deliberately the only place
+// ROS vocabulary appears outside `extensions/ros`.
+//
+// Three things it shows:
+//   1. Extension types are used exactly like base types. `RosNode` is a
+//      `SoftwareComponent`, so period, WCET, safety class and the rest are
+//      inherited and every base rule still applies to it.
+//   2. ROS communication uses native item definitions/usages, directional
+//      ports, interfaces, and flows — no publish/subscribe relation is added.
+//   3. Deployment reuses the BASE relations unchanged — `BuildsInto`,
+//      `DeploysTo`, `ProvidesEnvironment` — with no ROS-specific relation
+//      anywhere in the chain.
+package memo_examples_ros_mobile_robot {
+    private import ScalarValues::*;
+    private import ModelingMetadata::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_implementation_software_structure::*;
+    private import memo_architecture_implementation_software_runtime::*;
+    private import memo_architecture_functional_behavior::*;
+    private import memo_architecture_realization_deployment::*;
+    private import memo_architecture_realization_physical::*;
+    private import memo_extension_messaging::*;
+    private import memo_extension_container::*;
+    private import memo_extension_ros::*;
+
+    // ── Message definitions and named topic instances ──────────────────
+    // The definition is the ROS message contract. A named usage is the topic
+    // deployed in this system; publisher/subscriber ports reference that same
+    // usage and native flows carry its message type.
+    item def LaserScan specializes RosMessage {
+        attribute :>> rosTypeName = "sensor_msgs/msg/LaserScan";
+        attribute :>> messageSchema = "ranges[], intensities[], angle_min, angle_max, scan_time";
+    }
+    item def VelocityCommand specializes RosMessage {
+        attribute :>> rosTypeName = "geometry_msgs/msg/Twist";
+        attribute :>> messageSchema = "linear.x, angular.z";
+    }
+    item def EmergencyStop specializes RosMessage {
+        attribute :>> rosTypeName = "std_msgs/msg/Bool";
+        attribute :>> messageSchema = "data (true = stop asserted)";
+    }
+
+    item topicScan : LaserScan {
+        attribute :>> id = "RMR-TP-001"; attribute :>> name = "ScanTopic";
+    }
+    item topicCmdVel : VelocityCommand {
+        attribute :>> id = "RMR-TP-002"; attribute :>> name = "CmdVelTopic";
+    }
+    item topicEstop : EmergencyStop {
+        attribute :>> id = "RMR-TP-003"; attribute :>> name = "EmergencyStopTopic";
+    }
+
+    // ── Code ────────────────────────────────────────────────────────────
+    part swPerception : SoftwareModule {
+        attribute :>> moduleKind = ModuleKind::unit;
+        attribute :>> id = "RMR-SW-001"; attribute :>> name = "PerceptionStack";
+        attribute :>> responsibility = "Lidar driver and obstacle segmentation.";
+        attribute :>> safetyClass = SafetyClassKind::B;
+    }
+    part swNavigation : SoftwareModule {
+        attribute :>> moduleKind = ModuleKind::unit;
+        attribute :>> id = "RMR-SW-002"; attribute :>> name = "NavigationStack";
+        attribute :>> responsibility = "Global and local planning; velocity command generation.";
+        attribute :>> safetyClass = SafetyClassKind::B;
+    }
+    part swSafety : SoftwareModule {
+        attribute :>> moduleKind = ModuleKind::unit;
+        attribute :>> id = "RMR-SW-003"; attribute :>> name = "SafetyMonitor";
+        attribute :>> responsibility = "Independent watchdog: stops the base on obstacle proximity or missing heartbeat.";
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+
+    // ── Nodes ───────────────────────────────────────────────────────────
+    //
+    // `runtimeKind` is set per node rather than by the type: the first two are
+    // composed into one container process, the safety monitor runs as its own
+    // process so a fault in navigation cannot take it down. That distinction
+    // is exactly what an extension type must NOT decide for the modeller.
+    part nodeLidar : RosNode {
+        attribute :>> runtimeKind = RuntimeKind::thread;
+        attribute :>> id = "RMR-ND-001"; attribute :>> name = "LidarDriverNode";
+        attribute :>> nodeNamespace = "/robot/perception";
+        attribute :>> lifecycleManaged = true;
+        attribute :>> executorModel = "single-threaded executor, composed";
+        attribute :>> periodMs = 50.0;
+        attribute :>> wcetMs = 8.0;
+        attribute :>> safetyClass = SafetyClassKind::B;
+        out port scanPublisher : RosPublisher {
+            ref :>> topic = topicScan;
+            attribute :>> deliverySemantics = MessagingDeliveryKind::atMostOnce;
+            attribute :>> publishRateHz = 20.0;
+            attribute :>> offeredQos {
+                attribute :>> reliability = RosReliabilityKind::bestEffort;
+                attribute :>> durability = RosDurabilityKind::volatile;
+                attribute :>> deadlineMs = 60.0;
+                attribute :>> livelinessLeaseMs = 200.0;
+                attribute :>> historyDepth = 5;
+            }
+        }
+    }
+    part nodeNavigation : RosNode {
+        attribute :>> runtimeKind = RuntimeKind::thread;
+        attribute :>> id = "RMR-ND-002"; attribute :>> name = "NavigationNode";
+        attribute :>> nodeNamespace = "/robot/navigation";
+        attribute :>> lifecycleManaged = true;
+        attribute :>> executorModel = "multi-threaded executor, composed";
+        attribute :>> periodMs = 100.0;
+        attribute :>> wcetMs = 35.0;
+        attribute :>> safetyClass = SafetyClassKind::B;
+        in port scanSubscriber : RosSubscriber {
+            ref :>> topic = topicScan;
+            attribute :>> deliverySemantics = MessagingDeliveryKind::atMostOnce;
+            attribute :>> lossBehaviour = "hold the last costmap for 200 ms, then command zero velocity";
+            attribute :>> requestedQos {
+                attribute :>> reliability = RosReliabilityKind::bestEffort;
+                attribute :>> durability = RosDurabilityKind::volatile;
+                attribute :>> deadlineMs = 60.0;
+                attribute :>> livelinessLeaseMs = 200.0;
+                attribute :>> historyDepth = 5;
+            }
+        }
+        out port cmdVelPublisher : RosPublisher {
+            ref :>> topic = topicCmdVel;
+            attribute :>> deliverySemantics = MessagingDeliveryKind::atLeastOnce;
+            attribute :>> publishRateHz = 10.0;
+            attribute :>> offeredQos {
+                attribute :>> reliability = RosReliabilityKind::reliable;
+                attribute :>> durability = RosDurabilityKind::volatile;
+                attribute :>> deadlineMs = 150.0;
+                attribute :>> livelinessLeaseMs = 300.0;
+                attribute :>> historyDepth = 1;
+            }
+        }
+        in port estopSubscriber : RosSubscriber {
+            ref :>> topic = topicEstop;
+            attribute :>> deliverySemantics = MessagingDeliveryKind::atLeastOnce;
+            attribute :>> lossBehaviour = "no publisher within the liveliness lease is treated as stop asserted";
+            attribute :>> requestedQos {
+                attribute :>> reliability = RosReliabilityKind::reliable;
+                attribute :>> durability = RosDurabilityKind::transientLocal;
+                attribute :>> deadlineMs = 100.0;
+                attribute :>> livelinessLeaseMs = 200.0;
+                attribute :>> historyDepth = 1;
+            }
+        }
+        inout port setModeClient : RosServiceClient {
+            attribute :>> serviceName = "/robot/safety/set_mode";
+            attribute :>> timeoutMs = 500.0;
+        }
+        inout port navigateActionServer : RosActionServer {
+            attribute :>> actionName = "/robot/navigation/navigate_to_pose";
+        }
+    }
+    part nodeSafetyMonitor : RosNode {
+        attribute :>> runtimeKind = RuntimeKind::process;
+        attribute :>> id = "RMR-ND-003"; attribute :>> name = "SafetyMonitorNode";
+        attribute :>> nodeNamespace = "/robot/safety";
+        attribute :>> lifecycleManaged = false;
+        attribute :>> executorModel = "own process, real-time priority";
+        attribute :>> periodMs = 20.0;
+        attribute :>> deadlineMs = 20.0;
+        attribute :>> wcetMs = 3.0;
+        attribute :>> priority = 90;
+        attribute :>> safetyClass = SafetyClassKind::C;
+        attribute :>> faultContainment = "separate process; watchdog-fed; stops the base on its own timeout";
+        in port scanSubscriber : RosSubscriber {
+            ref :>> topic = topicScan;
+            attribute :>> deliverySemantics = MessagingDeliveryKind::atMostOnce;
+            attribute :>> lossBehaviour = "two consecutive misses assert the stop";
+        }
+        in port cmdVelSubscriber : RosSubscriber {
+            ref :>> topic = topicCmdVel;
+            attribute :>> deliverySemantics = MessagingDeliveryKind::atLeastOnce;
+            attribute :>> lossBehaviour = "missing velocity commands assert the stop";
+        }
+        out port estopPublisher : RosPublisher {
+            ref :>> topic = topicEstop;
+            attribute :>> deliverySemantics = MessagingDeliveryKind::atLeastOnce;
+            attribute :>> publishRateHz = 50.0;
+            attribute :>> offeredQos {
+                attribute :>> reliability = RosReliabilityKind::reliable;
+                attribute :>> durability = RosDurabilityKind::transientLocal;
+                attribute :>> deadlineMs = 100.0;
+                attribute :>> livelinessLeaseMs = 200.0;
+                attribute :>> historyDepth = 1;
+            }
+        }
+        inout port setModeServer : RosServiceServer {
+            attribute :>> serviceName = "/robot/safety/set_mode";
+        }
+        inout port navigateActionClient : RosActionClient {
+            attribute :>> actionName = "/robot/navigation/navigate_to_pose";
+        }
+    }
+
+    // Cross-view mappings: SEI module-view implementation units are distinct
+    // from component-and-connector runtime elements. A runtime node realizes
+    // the module whose code it executes; it is not the same model element.
+    #refinement dependency nodeLidar to swPerception;
+    #refinement dependency nodeNavigation to swNavigation;
+    #refinement dependency nodeSafetyMonitor to swSafety;
+
+    // ── Native topic, service, and action interfaces ───────────────────
+    interface scanToNavigation : RosTopicInterface
+        connect nodeLidar.scanPublisher to nodeNavigation.scanSubscriber {
+            attribute :>> direction = DirectionKind::output;
+        }
+    interface scanToSafety : RosTopicInterface
+        connect nodeLidar.scanPublisher to nodeSafetyMonitor.scanSubscriber {
+            attribute :>> direction = DirectionKind::output;
+        }
+    interface cmdVelToSafety : RosTopicInterface
+        connect nodeNavigation.cmdVelPublisher to nodeSafetyMonitor.cmdVelSubscriber {
+            attribute :>> direction = DirectionKind::output;
+        }
+    interface estopToNavigation : RosTopicInterface
+        connect nodeSafetyMonitor.estopPublisher to nodeNavigation.estopSubscriber {
+            attribute :>> direction = DirectionKind::output;
+        }
+
+    flow of LaserScan from nodeLidar.scanPublisher.payload to nodeNavigation.scanSubscriber.payload;
+    flow of LaserScan from nodeLidar.scanPublisher.payload to nodeSafetyMonitor.scanSubscriber.payload;
+    flow of VelocityCommand from nodeNavigation.cmdVelPublisher.payload to nodeSafetyMonitor.cmdVelSubscriber.payload;
+    flow of EmergencyStop from nodeSafetyMonitor.estopPublisher.payload to nodeNavigation.estopSubscriber.payload;
+
+    interface setModeService : RosServiceInterface
+        connect nodeNavigation.setModeClient to nodeSafetyMonitor.setModeServer {
+            attribute :>> direction = DirectionKind::inputOutput;
+        }
+    interface navigateAction : RosActionInterface
+        connect nodeSafetyMonitor.navigateActionClient to nodeNavigation.navigateActionServer {
+            attribute :>> direction = DirectionKind::inputOutput;
+        }
+
+    // ── Deployment: base relations, unchanged ───────────────────────────
+    part imageRuntime : RosContainerImage {
+        attribute :>> id = "RMR-DU-001"; attribute :>> name = "RobotRuntimeImage";
+        attribute :>> unitKind = "OCI container image";
+        attribute :>> imageReference = "registry.example.com/robot-runtime:2.3.0";
+        attribute :>> registry = "registry.example.com";
+        attribute :>> digest = "sha256:9f2c1ad4e0b7";
+        attribute :>> baseImage = "ros:jazzy-ros-base";
+        attribute :>> rosDistribution = "jazzy";
+        attribute :>> workspaceOverlay = "/opt/robot_ws";
+        attribute :>> integrityProtection = "image signature + SBOM attestation";
+    }
+    part imageSafety : RosContainerImage {
+        attribute :>> id = "RMR-DU-002"; attribute :>> name = "SafetyMonitorImage";
+        attribute :>> unitKind = "OCI container image";
+        attribute :>> imageReference = "registry.example.com/safety-monitor:2.3.0";
+        attribute :>> registry = "registry.example.com";
+        attribute :>> digest = "sha256:41bb7c0e5d92";
+        attribute :>> baseImage = "ros:jazzy-ros-core";
+        attribute :>> rosDistribution = "jazzy";
+        attribute :>> workspaceOverlay = "/opt/safety_ws";
+        attribute :>> integrityProtection = "image signature + SBOM attestation";
+    }
+    connection : BuildsInto connect module ::> swPerception to deploymentUnit ::> imageRuntime;
+    connection : BuildsInto connect module ::> swNavigation to deploymentUnit ::> imageRuntime;
+    connection : BuildsInto connect module ::> swSafety to deploymentUnit ::> imageSafety;
+
+    part nodeComputeUnit : ProcessingNode {
+        attribute :>> id = "RMR-HW-001"; attribute :>> name = "OnboardComputeUnit";
+        attribute :>> nodeKind = ProcessingNodeKind::SoC;
+        attribute :>> processorArchitecture = "arm64, 8 core";
+        attribute :>> memoryMB = "16384";
+        attribute :>> operatingSystem = "Linux with PREEMPT_RT";
+        attribute :>> supportsContainerization = true;
+        attribute :>> realTimeCapable = true;
+    }
+    allocation runtimeImageDeployment : DeploysTo allocate imageRuntime to nodeComputeUnit {
+        attribute :>> deploymentKind = DeploymentKind::containerized;
+    }
+    allocation safetyImageDeployment : DeploysTo allocate imageSafety to nodeComputeUnit {
+        attribute :>> deploymentKind = DeploymentKind::containerized;
+    }
+
+    part rosRuntime : RosContainerRuntime {
+        attribute :>> id = "RMR-RT-001"; attribute :>> name = "OnboardRosRuntime";
+        attribute :>> environmentKind = "container runtime";
+        attribute :>> osOrRtos = "Linux with PREEMPT_RT";
+        attribute :>> orchestrationPlatform = "systemd-managed compose, no cluster orchestrator";
+        attribute :>> runtimeEngine = "containerd";
+        attribute :>> rosDistribution = "jazzy";
+        attribute :>> rmwImplementation = "rmw_cyclonedds_cpp";
+        // Fixed per robot. Two robots sharing a domain would see each other's
+        // topics, which is a hazard on a shared network and is visible in no
+        // single node.
+        attribute :>> rosDomainId = 42;
+    }
+    connection : ProvidesEnvironment connect node ::> nodeComputeUnit to environment ::> rosRuntime;
+}

package/examples/ros-mobile-robot/model/catalog/viewpoints/unassigned/viewpoint.sysml

@@ -0,0 +1,7 @@
+// unassigned viewpoint.
+//
+// This project does not define its own viewpoint here; it binds the reusable
+// MEMO viewpoint that frames these concerns. The views it governs sit beneath
+// `views/`.
+package memo_examples_ros_mobile_robot_viewpoints_unassigned {
+}

package/examples/ros-mobile-robot/model/catalog/viewpoints/unassigned/views/ros_mobile_robot_overview.sysml

@@ -0,0 +1,12 @@
+package memo_examples_ros_mobile_robot_viewpoints_unassigned_views_ros_mobile_robot_overview {
+    private import memo_examples_ros_mobile_robot::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+
+    view rosMobileRobotOverview : MemoDiagramView {
+        expose memo_examples_ros_mobile_robot::*;
+        attribute depth = 2;
+        attribute :>> viewKind = DiagramViewKind::general;
+        attribute :>> diagramType = "bdd";
+    }
+}

package/examples/software-only-medical-device/memo.package.yaml

@@ -0,0 +1,3 @@
+name: software-only-medical-device
+entrypoint: model/catalog/project.sysml
+include: [model]

package/examples/software-only-medical-device/model/catalog/project.sysml

@@ -20,5 +20,9 @@ package memo_examples_software_only_medical_device_project {
         attribute :>> projectName = "Software Only Medical Device";
         ref :>> selectedMethodology = mdDefaultDefinition;
         attribute :>> scopeMode = ScopeModeKind::explicit;
+        // Composition happens here, not by chaining methodologies. The cloud
+        // extension supplies CloudService, which is what the grading service
+        // is.
+        attribute :>> includedModule = "memo_extension_cloud";
     }
 }

package/examples/software-only-medical-device/model/catalog/software_only_medical_device.sysml

@@ -4,6 +4,7 @@
 // off-the-shelf infrastructure the manufacturer does not control.
 package memo_examples_software_only_medical_device {
     private import ScalarValues::*;
+    private import ModelingMetadata::*;
 
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
@@ -11,6 +12,11 @@ package memo_examples_software_only_medical_device {
     private import memo_architecture_implementation_software_runtime::*;
     private import memo_architecture_realization_deployment::*;
     private import memo_architecture_realization_physical::*;
+    // `serviceContract` was an optional attribute on SoftwareComponent, set
+    // only when runtimeKind = service. It moved to `CloudService` in the cloud
+    // extension, so the project that uses it includes the extension — which is
+    // the mechanism working as designed rather than a cost of the move.
+    private import memo_extension_cloud::*;
 
     part swScreeningApp : SoftwareSystem {
         attribute :>> id = "SMD-SW-001"; attribute :>> name = "ScreeningApplication";
@@ -33,18 +39,18 @@ package memo_examples_software_only_medical_device {
         attribute :>> responsibility = "Wraps the grading model behind the service API; owns input validation and result structuring.";
         attribute :>> safetyClass = SafetyClassKind::B;
     }
-    connection : ModuleUses connect usingModule ::> swGradingModule to usedModule ::> soupInference;
+    dependency swGradingModule to soupInference;
 
-    part svcGrading : SoftwareComponent {
-        attribute :>> runtimeKind = RuntimeKind::service;
+    part svcGrading : CloudService {
         attribute :>> id = "SMD-RT-001"; attribute :>> name = "GradingService";
         attribute :>> serviceContract = "REST /grade: image in, structured finding out";
+        attribute :>> discoveryMechanism = "DNS name behind the cluster ingress";
         attribute :>> updatePolicy = "blue/green rollout";
         attribute :>> rollbackPolicy = "previous validated version retained hot";
     }
-    connection : Realizes connect realizing ::> svcGrading to realized ::> swGradingModule;
+    #refinement dependency svcGrading to swGradingModule;
 
-    part duContainerImage : DeploymentUnit {
+    part duContainerImage : SoftwareDeploymentUnit {
         attribute :>> id = "SMD-DU-001"; attribute :>> name = "ScreeningServiceImage";
         attribute :>> unitKind = "OCI container image";
         attribute :>> integrityProtection = "image signature + SBOM attestation";
@@ -55,7 +61,7 @@ package memo_examples_software_only_medical_device {
         attribute :>> supportsContainerization = true;
         attribute :>> realTimeCapable = false;
     }
-    connection : DeploysTo connect deploymentUnit ::> duContainerImage to node ::> nodeCloud {
+    allocation duContainerImageDeployment : DeploysTo allocate duContainerImage to nodeCloud {
         attribute :>> deploymentKind = DeploymentKind::containerized;
     }
     connection : HostedBy connect hostAssembly ::> nodeCloud to processingNode ::> svcGrading;

package/examples/software-only-medical-device/model/catalog/viewpoints/unassigned/views/software_only_medical_device_overview.sysml

@@ -6,7 +6,6 @@ package memo_examples_software_only_medical_device_viewpoints_unassigned_views_s
     view softwareOnlyMedicalDeviceOverview : MemoDiagramView {
         expose memo_examples_software_only_medical_device::*;
         attribute depth = 2;
-        attribute :>> title = "Software-only Medical Device Overview";
         attribute :>> viewKind = DiagramViewKind::general;
         attribute :>> diagramType = "bdd";
     }

package/examples/surgical-closure-workflow/memo.package.yaml

@@ -0,0 +1,3 @@
+name: surgical-closure-workflow
+entrypoint: model/catalog/project.sysml
+include: [model]