@memoarchitect/ontology 0.12.1 → 0.15.0

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/interconnection_view.sysml

@@ -1,4 +1,5 @@
-package diagram_samples {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_interconnection_view {
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
     private import ScalarValues::*;
     private import memo_architecture_operational_context_actors::*;
     private import memo_architecture_operational_context_use_context::*;
@@ -19,7 +20,7 @@ package diagram_samples {
     // real containment, not a port-to-port `Composes` edge, which is what
     // CR-ONT-65 used to forbid before nesting made the rule unnecessary.
     part coffeeMachine : LogicalComponent {
-        attribute :>> name = "Coffee Machine";
+@MemoIdentity { :>> label = "Coffee Machine"; }
         in port mainsWaterIn : DataPort { in item payload : MemoItem; }
         out port beverageOut : DataPort { out item payload : MemoItem; }
         inout port serviceInterface : DataPort {
@@ -28,58 +29,56 @@ package diagram_samples {
         }
 
         part waterTank : LogicalComponent {
-            attribute :>> name = "Water Reservoir";
+@MemoIdentity { :>> label = "Water Reservoir"; }
             out port tankWaterOut : DataPort { out item payload : MemoItem; }
             in port tankWaterIn : DataPort { in item payload : MemoItem; }
         }
         part heaterAssembly : LogicalComponent {
-            attribute :>> name = "Thermal Control Assembly";
+@MemoIdentity { :>> label = "Thermal Control Assembly"; }
             in port heaterWaterIn : DataPort { in item payload : MemoItem; }
             out port heatedWaterOut : DataPort { out item payload : MemoItem; }
 
             part thermostat : LogicalComponent {
-                attribute :>> name = "Thermostat";
                 in port tempReadingIn : DataPort { in item payload : MemoItem; }
                 out port powerCommandOut : DataPort { out item payload : MemoItem; }
             }
 
             part heatingElement : LogicalComponent {
-                attribute :>> name = "Water Heating Element";
+@MemoIdentity { :>> label = "Water Heating Element"; }
                 in port powerIn : DataPort { in item payload : MemoItem; }
                 out port heaterStatusOut : DataPort { out item payload : MemoItem; }
 
                 part resistiveCoil : LogicalComponent {
-                    attribute :>> name = "Resistive Coil";
+@MemoIdentity { :>> label = "Resistive Coil"; }
                     in port coilPowerIn : DataPort { in item payload : MemoItem; }
                     out port heatOut : DataPort { out item payload : MemoItem; }
                 }
                 part temperatureSensor : LogicalComponent {
-                    attribute :>> name = "Temperature Sensor";
+@MemoIdentity { :>> label = "Temperature Sensor"; }
                     in port heatIn : DataPort { in item payload : MemoItem; }
                     out port sensorReadingOut : DataPort { out item payload : MemoItem; }
                 }
             }
         }
         part brewGroup : LogicalComponent {
-            attribute :>> name = "Brew Group";
+@MemoIdentity { :>> label = "Brew Group"; }
             in port brewWaterIn : DataPort { in item payload : MemoItem; }
             out port brewedCoffeeOut : DataPort { out item payload : MemoItem; }
         }
     }
     part waterSupply : LogicalComponent {
-        attribute :>> name = "Water Supply";
+@MemoIdentity { :>> label = "Water Supply"; }
         out port supplyWaterOut : DataPort { out item payload : MemoItem; }
     }
     part cup : LogicalComponent {
-        attribute :>> name = "Cup";
         in port cupBeverageIn : DataPort { in item payload : MemoItem; }
     }
 
     // Transport between two components: `out` to `in`, one item moving.
-    flow from waterSupply.supplyWaterOut to coffeeMachine.mainsWaterIn;
-    flow from coffeeMachine.waterTank.tankWaterOut to coffeeMachine.heaterAssembly.heaterWaterIn;
-    flow from coffeeMachine.heaterAssembly.heatedWaterOut to coffeeMachine.brewGroup.brewWaterIn;
-    flow from coffeeMachine.beverageOut to cup.cupBeverageIn;
+    flow supplyWaterOutToMainsWaterIn from waterSupply.supplyWaterOut to coffeeMachine.mainsWaterIn;
+    flow tankWaterOutToHeaterWaterIn from coffeeMachine.waterTank.tankWaterOut to coffeeMachine.heaterAssembly.heaterWaterIn;
+    flow heatedWaterOutToBrewWaterIn from coffeeMachine.heaterAssembly.heatedWaterOut to coffeeMachine.brewGroup.brewWaterIn;
+    flow beverageOutToCupBeverageIn from coffeeMachine.beverageOut to cup.cupBeverageIn;
 
     // Delegation between a boundary port and the interior it stands for. These
     // are `in`-to-`in` and `out`-to-`out`, because nothing travels: the two
@@ -90,58 +89,11 @@ package diagram_samples {
     bind coffeeMachine.heaterAssembly.heatingElement.heaterStatusOut = coffeeMachine.serviceInterface.diagnostics;
 
     // Internal flows within the heater assembly
-    flow from coffeeMachine.heaterAssembly.thermostat.powerCommandOut to coffeeMachine.heaterAssembly.heatingElement.powerIn;
-    flow from coffeeMachine.heaterAssembly.heatingElement.heaterStatusOut to coffeeMachine.heaterAssembly.thermostat.tempReadingIn;
+    flow powerCommandOutToPowerIn from coffeeMachine.heaterAssembly.thermostat.powerCommandOut to coffeeMachine.heaterAssembly.heatingElement.powerIn;
+    flow heaterStatusOutToTempReadingIn from coffeeMachine.heaterAssembly.heatingElement.heaterStatusOut to coffeeMachine.heaterAssembly.thermostat.tempReadingIn;
 
     // Internal flows within the heating element
-    flow from coffeeMachine.heaterAssembly.heatingElement.resistiveCoil.heatOut to coffeeMachine.heaterAssembly.heatingElement.temperatureSensor.heatIn;
+    flow heatOutToHeatIn from coffeeMachine.heaterAssembly.heatingElement.resistiveCoil.heatOut to coffeeMachine.heaterAssembly.heatingElement.temperatureSensor.heatIn;
     bind coffeeMachine.heaterAssembly.heatingElement.powerIn = coffeeMachine.heaterAssembly.heatingElement.resistiveCoil.coilPowerIn;
     bind coffeeMachine.heaterAssembly.heatingElement.temperatureSensor.sensorReadingOut = coffeeMachine.heaterAssembly.heatingElement.heaterStatusOut;
-
-    // Child IBD view — the heater assembly's own internal wiring. Its subject
-    // is `heaterAssembly`, so the parent IBD shows a "navigate to view" button
-    // on the Thermal Control Assembly part.
-    view heaterAssemblyIBD : MemoDiagramView {
-        expose coffeeMachine.heaterAssembly::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Internal wiring of the Thermal Control Assembly — heating element and its status output."; }
-        attribute :>> viewKind = DiagramViewKind::interconnection;
-        attribute :>> diagramType = "ibd";
-        attribute :>> rendererProfile = "ibd";
-        ref :>> viewpointDefinition = ibdViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeRelationshipKinds = ("Composes", "flow", "bind");
-        }
-    }
-
-    view heatingElementIBD : MemoDiagramView {
-        expose coffeeMachine.heaterAssembly.heatingElement::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Third-level IBD — resistive coil and temperature sensor inside the heating element."; }
-        attribute :>> viewKind = DiagramViewKind::interconnection;
-        attribute :>> diagramType = "ibd";
-        attribute :>> rendererProfile = "ibd";
-        ref :>> viewpointDefinition = ibdViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeRelationshipKinds = ("Composes", "flow", "bind");
-        }
-    }
-
-    view beverageMachineIBD : MemoDiagramView {
-        expose coffeeMachine::**;
-        expose waterSupply::**;
-        expose cup::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Balanced internal architecture with readable boundary ports, nested service diagnostics, and external water and beverage interfaces."; }
-        attribute :>> viewKind = DiagramViewKind::interconnection;
-        attribute :>> diagramType = "ibd";
-        // The dedicated IBD renderer (Base -> Ibd class hierarchy): square
-        // wall ports, orange-in/green-out, solid grabbable nested-connector
-        // housings, orthogonal crossing-bridge routing, monochrome shading.
-        attribute :>> rendererProfile = "ibd";
-        ref :>> viewpointDefinition = ibdViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeRelationshipKinds = ("Composes", "flow", "bind");
-        }
-    }
 }

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/operational_behaviour_view.sysml

@@ -1,4 +1,5 @@
-package diagram_samples {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_operational_behaviour_view {
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
     private import ScalarValues::*;
     private import memo_architecture_operational_context_actors::*;
     private import memo_core_relationships::*;
@@ -28,49 +29,49 @@ package diagram_samples {
     // Use the canonical MEMO operational system type—never a sample-local
     // placeholder—so ontology-driven Explorer grouping remains authoritative.
     part opCareSystem : OperationalEntity {
-        attribute :>> name = "PCA Care System";
+@MemoIdentity { :>> label = "PCA Care System"; }
         attribute :>> entityKind = OperationalEntityKind::device;
         attribute :>> responsibility = "System of interest for this context view.";
         part opClinicalTeam : User {
-            attribute :>> actorKind = ActorKind::clinician; attribute :>> name = "Clinical Team";
+            attribute :>> actorKind = ActorKind::clinician; @MemoIdentity { :>> label = "Clinical Team"; }
             part opRolePhysician : User {
-                attribute :>> actorKind = ActorKind::clinician; attribute :>> name = "Physician"; }
+                attribute :>> actorKind = ActorKind::clinician; @MemoIdentity { :>> label = "Physician"; } }
             part opRoleNurse : User {
-                attribute :>> actorKind = ActorKind::clinician; attribute :>> name = "Nurse"; }
+                attribute :>> actorKind = ActorKind::clinician; @MemoIdentity { :>> label = "Nurse"; } }
             part opRoleBiomed : User {
-                attribute :>> actorKind = ActorKind::technician; attribute :>> name = "Biomed Tech"; }
+                attribute :>> actorKind = ActorKind::technician; @MemoIdentity { :>> label = "Biomed Tech"; } }
         }
         part opPatientGroup : User {
-            attribute :>> actorKind = ActorKind::patient; attribute :>> name = "Patient Interaction";
+            attribute :>> actorKind = ActorKind::patient; @MemoIdentity { :>> label = "Patient Interaction"; }
             part opRolePatient : User {
-                attribute :>> actorKind = ActorKind::patient; attribute :>> name = "Patient"; }
+                attribute :>> actorKind = ActorKind::patient; @MemoIdentity { :>> label = "Patient"; } }
         }
     }
 
     action opSetupFlow : OperativeAction {
-        action opPrescribe : OpPrescribeTherapy { attribute :>> name = "Prescribe Therapy"; }
-        action opVerify : OpVerifyPrescription { attribute :>> name = "Verify Prescription"; }
+        action opPrescribe : OpPrescribeTherapy {@MemoIdentity { :>> label = "Prescribe Therapy"; } }
+        action opVerify : OpVerifyPrescription {@MemoIdentity { :>> label = "Verify Prescription"; } }
         fork opForkPrep;
-        action opPrime : OperativeAction { attribute :>> name = "Prime Pump & Load Reservoir"; }
-        action opSelfTest : OperativeAction { attribute :>> name = "Run Device Self-Test"; }
+        action opPrime : OperativeAction {@MemoIdentity { :>> label = "Prime Pump & Load Reservoir"; } }
+        action opSelfTest : OperativeAction {@MemoIdentity { :>> label = "Run Device Self-Test"; } }
         join opJoinPrep;
-        action opProgram : OperativeAction { attribute :>> name = "Program Pump Parameters"; }
-        action opConnect : OperativeAction { attribute :>> name = "Connect to Patient"; }
-        action opStart : OperativeAction { attribute :>> name = "Start Infusion"; }
+        action opProgram : OperativeAction {@MemoIdentity { :>> label = "Program Pump Parameters"; } }
+        action opConnect : OperativeAction {@MemoIdentity { :>> label = "Connect to Patient"; } }
+        action opStart : OperativeAction {@MemoIdentity { :>> label = "Start Infusion"; } }
         action opAdminister : OperativeAction {
-            attribute :>> name = "Administer PCA Therapy";
-            action opRequestBolus : OpRequestBolus { attribute :>> name = "Request Bolus"; }
-            action opCheckLockout : OpCheckLockout { attribute :>> name = "Check Lockout"; }
-            action opDeliverDose : OperativeAction { attribute :>> name = "Deliver Dose"; }
-            action opLogEvent : OperativeAction { attribute :>> name = "Log Dose Event"; }
-            flow of OpBolusRequest from opRequestBolus.bolusRequest to opCheckLockout.bolusRequest;
+@MemoIdentity { :>> label = "Administer PCA Therapy"; }
+            action opRequestBolus : OpRequestBolus {@MemoIdentity { :>> label = "Request Bolus"; } }
+            action opCheckLockout : OpCheckLockout {@MemoIdentity { :>> label = "Check Lockout"; } }
+            action opDeliverDose : OperativeAction {@MemoIdentity { :>> label = "Deliver Dose"; } }
+            action opLogEvent : OperativeAction {@MemoIdentity { :>> label = "Log Dose Event"; } }
+            flow opBolusRequestFlow of OpBolusRequest from opRequestBolus.bolusRequest to opCheckLockout.bolusRequest;
             first start then opRequestBolus;
             first opRequestBolus then opCheckLockout;
             first opCheckLockout then opDeliverDose;
             first opDeliverDose then opLogEvent;
             first opLogEvent then done;
         }
-        flow of OpPrescription from opPrescribe.prescription to opVerify.prescription;
+        flow opPrescriptionFlow of OpPrescription from opPrescribe.prescription to opVerify.prescription;
         first start then opPrescribe;
         first opPrescribe then opVerify;
         first opVerify then opForkPrep;
@@ -97,14 +98,4 @@ package diagram_samples {
     allocate opSetupFlow.opAdminister.opCheckLockout to opCareSystem.opClinicalTeam.opRoleNurse;
     allocate opSetupFlow.opAdminister.opDeliverDose to opCareSystem.opClinicalTeam.opRoleNurse;
     allocate opSetupFlow.opAdminister.opLogEvent to opCareSystem.opClinicalTeam.opRoleNurse;
-
-    view clinicalSetupActivity : MemoDiagramView {
-        expose opSetupFlow::**;
-        expose opCareSystem::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Operational activity across clinical roles with concurrent preparation and a composite therapy step."; }
-        attribute :>> viewKind = DiagramViewKind::actionflow;
-        attribute :>> diagramType = "ofd";
-        ref :>> viewpointDefinition = actionFlowViewpoint;
-    }
 }

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/package_view.sysml

@@ -1,4 +1,5 @@
-package diagram_samples {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_package_view {
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
     private import ScalarValues::*;
     private import memo_architecture_logical_structure::*;
     private import memo_architecture_logical_interfaces::*;
@@ -16,54 +17,40 @@ package diagram_samples {
 
     package presentation {
         part dashboardUI : LogicalComponent {
-            attribute :>> name = "Dashboard UI";
+@MemoIdentity { :>> label = "Dashboard UI"; }
             out port apiCall : DataPort { out item payload : MemoItem; }
         }
         part settingsUI : LogicalComponent {
-            attribute :>> name = "Settings UI";
+@MemoIdentity { :>> label = "Settings UI"; }
             out port configRequest : DataPort { out item payload : MemoItem; }
         }
     }
 
     package domain {
         part therapyEngine : LogicalComponent {
-            attribute :>> name = "Therapy Engine";
+@MemoIdentity { :>> label = "Therapy Engine"; }
             in port incomingRequest : DataPort { in item payload : MemoItem; }
             out port statusUpdate : DataPort { out item payload : MemoItem; }
         }
         part alarmManager : LogicalComponent {
-            attribute :>> name = "Alarm Manager";
+@MemoIdentity { :>> label = "Alarm Manager"; }
             in port trigger : DataPort { in item payload : MemoItem; }
         }
         part configService : LogicalComponent {
-            attribute :>> name = "Configuration Service";
+@MemoIdentity { :>> label = "Configuration Service"; }
             in port configIn : DataPort { in item payload : MemoItem; }
         }
     }
 
     package infrastructure {
         part dataStore : LogicalComponent {
-            attribute :>> name = "Data Store";
+@MemoIdentity { :>> label = "Data Store"; }
             in port writePort : DataPort { in item payload : MemoItem; }
             out port readPort : DataPort { out item payload : MemoItem; }
         }
         part networkAdapter : LogicalComponent {
-            attribute :>> name = "Network Adapter";
+@MemoIdentity { :>> label = "Network Adapter"; }
             inout port netIO : DataPort { inout item payload : MemoItem; }
         }
     }
-
-    view threeLayerPackages : MemoDiagramView {
-        expose presentation::**;
-        expose domain::**;
-        expose infrastructure::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Three-layer package overview — presentation, domain, infrastructure — rendered as a browser membership tree."; }
-        attribute :>> viewKind = DiagramViewKind::browser;
-        attribute :>> diagramType = "pkg";
-        ref :>> viewpointDefinition = browserViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeRelationshipKinds = ("Composes");
-        }
-    }
 }

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/requirements_view.sysml

@@ -1,4 +1,5 @@
-package diagram_samples {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_requirements_view {
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
     // Requirements sample (general view kind, `req` diagram type). Stakeholder needs
     // on the left derive into system requirements; `DerivesFrom` edges render as the
     // requirements-diagram trace lines.
@@ -15,28 +16,28 @@ package diagram_samples {
     private import memo_core_common::MemoIdentity;
     requirement needSafeTherapy : Need {
         attribute :>> needKind = NeedKind::'stakeholder';
-        @MemoIdentity { :>> providedId = "NEED-1"; } attribute :>> name = "SafeTherapy";
+        @MemoIdentity { :>> providedId = "NEED-1"; :>> label = "SafeTherapy"; }
         attribute :>> statement = "The device shall support safe patient-controlled infusion therapy.";
     }
     requirement needTimelyAlarms : Need {
         attribute :>> needKind = NeedKind::'stakeholder';
-        @MemoIdentity { :>> providedId = "NEED-2"; } attribute :>> name = "TimelyAlarms";
+        @MemoIdentity { :>> providedId = "NEED-2"; :>> label = "TimelyAlarms"; }
         attribute :>> statement = "Clinicians shall be notified promptly of any condition that endangers therapy.";
     }
 
     requirement reqDoseLimit : Requirement {
         attribute :>> requirementType = RequirementTypeKind::system;
-        @MemoIdentity { :>> providedId = "REQ-1"; } attribute :>> name = "DoseLimitEnforcement";
+        @MemoIdentity { :>> providedId = "REQ-1"; :>> label = "DoseLimitEnforcement"; }
         attribute :>> statement = "The pump shall not deliver more than the prescribed maximum dose in any one-hour window.";
     }
     requirement reqOcclusionAlarm : Requirement {
         attribute :>> requirementType = RequirementTypeKind::system;
-        @MemoIdentity { :>> providedId = "REQ-2"; } attribute :>> name = "OcclusionAlarm";
+        @MemoIdentity { :>> providedId = "REQ-2"; :>> label = "OcclusionAlarm"; }
         attribute :>> statement = "The pump shall raise an alarm within two seconds of detecting a downstream occlusion.";
     }
     requirement reqAlarmLoudness : Requirement {
         attribute :>> requirementType = RequirementTypeKind::system;
-        @MemoIdentity { :>> providedId = "REQ-3"; } attribute :>> name = "AlarmLoudness";
+        @MemoIdentity { :>> providedId = "REQ-3"; :>> label = "AlarmLoudness"; }
         attribute :>> statement = "An active alarm shall be audible at 65 dBA at one metre.";
     }
 
@@ -44,20 +45,4 @@ package diagram_samples {
     connection : DerivesFrom connect sourceDriver ::> needSafeTherapy to targetRequirement ::> reqOcclusionAlarm;
     connection : DerivesFrom connect sourceDriver ::> needTimelyAlarms to targetRequirement ::> reqOcclusionAlarm;
     connection : DerivesFrom connect sourceDriver ::> needTimelyAlarms to targetRequirement ::> reqAlarmLoudness;
-
-    view needsToRequirements : MemoDiagramView {
-        expose needSafeTherapy::**;
-        expose needTimelyAlarms::**;
-        expose reqDoseLimit;
-        expose reqOcclusionAlarm;
-        expose reqAlarmLoudness;
-        attribute depth = 1;
-        @MemoIdentity { :>> shortDescription = "Stakeholder needs deriving into system requirements, wired by DerivesFrom trace edges."; }
-        attribute :>> viewKind = DiagramViewKind::general;
-        attribute :>> diagramType = "req";
-        ref :>> viewpointDefinition = requirementsDiagramViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeRelationshipKinds = ("DerivesFrom");
-        }
-    }
 }

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/sequence_view.sysml

@@ -1,6 +1,7 @@
-package diagram_samples {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_sequence_view {
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
     // Sequence sample (sequence view kind, `seq` diagram type). A FunctionalFlow
-    // owns an ordered chain of FunctionalFlowSteps; each step is `allocate`d to
+    // owns an ordered chain of nested actions (its steps); each step is `allocate`d to
     // the lifeline (an actor or component) that performs it, and the sequence
     // template lays lifelines out as columns with one row per step in
     // declaration order.
@@ -18,39 +19,39 @@ package diagram_samples {
     private import memo_core_common::MemoIdentity;
 
     // Lifelines — the actor and components each step is allocated to.
-    part clinician : User { attribute :>> name = "Clinician"; }
-    part pumpController : LogicalComponent { attribute :>> name = "Pump Controller"; }
-    part pumpMechanism : LogicalComponent { attribute :>> name = "Pump Mechanism"; }
+    part clinician : User { }
+    part pumpController : LogicalComponent {@MemoIdentity { :>> label = "Pump Controller"; } }
+    part pumpMechanism : LogicalComponent {@MemoIdentity { :>> label = "Pump Mechanism"; } }
 
     // Combined fragment definitions — referenced by steps' `fragment` attribute.
     part monitorLoop {
-        attribute :>> name = "Monitor Loop";
+        attribute name = "Monitor Loop";
         attribute fragmentType = "loop";
         attribute guard = "vitals abnormal";
     }
     part errorHandling {
-        attribute :>> name = "Error Handling";
+        attribute name = "Error Handling";
         attribute fragmentType = "alt";
         attribute fragmentGuards = "[error recoverable]|[else]";
     }
 
     action startInfusion : FunctionalFlow {
-        attribute :>> name = "Start Infusion";
+@MemoIdentity { :>> label = "Start Infusion"; }
 
-        action stepRequestStart : FunctionalFlowStep { attribute :>> name = "Request start infusion"; }
-        action stepValidate : FunctionalFlowStep { attribute :>> name = "Validate prescribed rate"; }
-        action stepCommandMotor : FunctionalFlowStep { attribute :>> name = "Command motor drive"; }
-        action stepConfirm : FunctionalFlowStep { attribute :>> name = "Confirm delivery started"; }
+        action stepRequestStart {@MemoIdentity { :>> label = "Request start infusion"; } }
+        action stepValidate {@MemoIdentity { :>> label = "Validate prescribed rate"; } }
+        action stepCommandMotor {@MemoIdentity { :>> label = "Command motor drive"; } }
+        action stepConfirm {@MemoIdentity { :>> label = "Confirm delivery started"; } }
 
         // Steps inside the monitoring loop fragment
-        action stepReadSensor : FunctionalFlowStep { attribute :>> name = "Read sensor data"; attribute stepOrder = "5"; attribute fragment = "monitorLoop"; }
-        action stepCheckVitals : FunctionalFlowStep { attribute :>> name = "Check vital signs"; attribute stepOrder = "6"; attribute fragment = "monitorLoop"; }
+        action stepReadSensor {@MemoIdentity { :>> label = "Read sensor data"; } attribute stepOrder = "5"; attribute fragment = "monitorLoop"; }
+        action stepCheckVitals {@MemoIdentity { :>> label = "Check vital signs"; } attribute stepOrder = "6"; attribute fragment = "monitorLoop"; }
 
         // Steps inside the alt (error-handling) fragment
-        action stepRetryDelivery : FunctionalFlowStep { attribute :>> name = "Retry delivery"; attribute stepOrder = "7"; attribute fragment = "errorHandling"; attribute fragmentOperand = "1"; }
-        action stepAlertUser : FunctionalFlowStep { attribute :>> name = "Alert user"; attribute stepOrder = "8"; attribute fragment = "errorHandling"; attribute fragmentOperand = "2"; }
+        action stepRetryDelivery {@MemoIdentity { :>> label = "Retry delivery"; } attribute stepOrder = "7"; attribute fragment = "errorHandling"; attribute fragmentOperand = "1"; }
+        action stepAlertUser {@MemoIdentity { :>> label = "Alert user"; } attribute stepOrder = "8"; attribute fragment = "errorHandling"; attribute fragmentOperand = "2"; }
 
-        action stepNotify : FunctionalFlowStep { attribute :>> name = "Notify delivery started"; attribute stepOrder = "9"; }
+        action stepNotify {@MemoIdentity { :>> label = "Notify delivery started"; } attribute stepOrder = "9"; }
 
         first start then stepRequestStart;
         first stepRequestStart then stepValidate;
@@ -77,21 +78,4 @@ package diagram_samples {
     allocate startInfusion.stepRetryDelivery to pumpController;
     allocate startInfusion.stepAlertUser to clinician;
     allocate startInfusion.stepNotify to clinician;
-
-    view startInfusionSequence : MemoDiagramView {
-        expose startInfusion::**;
-        expose clinician::**;
-        expose pumpController::**;
-        expose pumpMechanism::**;
-        expose monitorLoop::**;
-        expose errorHandling::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Start-infusion sequence with combined fragments — loop for sensor monitoring and alt for error handling."; }
-        attribute :>> viewKind = DiagramViewKind::sequence;
-        attribute :>> diagramType = "seq";
-        ref :>> viewpointDefinition = sequenceViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeElementKinds = ("FunctionalFlowStep", "User", "LogicalComponent", "Part");
-        }
-    }
 }

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/standard_activity_view.sysml

@@ -1,4 +1,5 @@
-package diagram_samples {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_standard_activity_view {
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
     // Standard SysML v2 activity sample (actionflow view kind, `afd` diagram type).
     //
     // The view over `activity_example::CustomerProcess`, the standard-SysML activity
@@ -23,12 +24,4 @@ package diagram_samples {
 
     private import memo_core_common::*;
     private import memo_core_common::MemoIdentity;
-    view orderFulfillmentActivity : MemoDiagramView {
-        expose FulfillOrder::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Order fulfilment — accept, validate, decide, fork into parallel shipment and invoice, join, notify, send receipt, and terminate."; }
-        attribute :>> viewKind = DiagramViewKind::actionflow;
-        attribute :>> diagramType = "afd";
-        ref :>> viewpointDefinition = actionFlowViewpoint;
-    }
 }

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/state_transition_view.sysml

@@ -1,4 +1,5 @@
-package diagram_samples {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_state_transition_view {
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
     // State transition sample (statetransition view kind, `stm` diagram type). A
     // behaviour machine owns its mode states by containing them, and each native
     // transition lives inside the state whose substates it connects.
@@ -13,76 +14,51 @@ package diagram_samples {
 
     private import memo_core_common::MemoIdentity;
     state pumpModes : StateMachine {
-        attribute :>> name = "Pump Operating Modes";
+@MemoIdentity { :>> label = "Pump Operating Modes"; }
 
-        state idle : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Idle"; }
+        state idle : MemoState { attribute :>> stateKind = StateKind::mode; }
 
         // Infusing is a composite state: its substates show what the pump is
         // doing while it is infusing, and containment is the nesting itself —
         // not a parallel set of Composes edges.
         state infusing : MemoState {
             attribute :>> stateKind = StateKind::mode;
-            attribute :>> name = "Infusing";
 
-            state priming : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Priming"; }
-            state delivering : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Delivering"; }
-            state holding : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Holding (KVO)"; }
+            state priming : MemoState { attribute :>> stateKind = StateKind::mode; }
+            state delivering : MemoState { attribute :>> stateKind = StateKind::mode; }
+            state holding : MemoState { attribute :>> stateKind = StateKind::mode; @MemoIdentity { :>> label = "Holding (KVO)"; } }
 
             transition tPrimed first priming then delivering {
-                @TransitionRecord { :>> name = "primed"; :>> trigger = "primeComplete"; }
+                @MemoIdentity { :>> label = "primed"; } @TransitionRecord { :>> trigger = "primeComplete"; }
             }
             transition tKvo first delivering then holding {
-                @TransitionRecord { :>> name = "keepVeinOpen"; :>> trigger = "doseComplete"; }
+                @MemoIdentity { :>> label = "keepVeinOpen"; } @TransitionRecord { :>> trigger = "doseComplete"; }
             }
             transition tResumeDose first holding then delivering {
-                @TransitionRecord { :>> name = "resumeDose"; :>> trigger = "doseScheduled"; }
+                @MemoIdentity { :>> label = "resumeDose"; } @TransitionRecord { :>> trigger = "doseScheduled"; }
             }
         }
 
-        state paused : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Paused"; }
-        state alarm : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Alarm"; }
+        state paused : MemoState { attribute :>> stateKind = StateKind::mode; }
+        state alarm : MemoState { attribute :>> stateKind = StateKind::mode; }
 
         transition tStart first idle then infusing {
-            @TransitionRecord { :>> name = "start"; :>> trigger = "startInfusion"; }
+            @MemoIdentity { :>> label = "start"; } @TransitionRecord { :>> trigger = "startInfusion"; }
         }
         transition tPause first infusing then paused {
-            @TransitionRecord { :>> name = "pause"; :>> trigger = "pauseRequested"; }
+            @MemoIdentity { :>> label = "pause"; } @TransitionRecord { :>> trigger = "pauseRequested"; }
         }
         transition tResume first paused then infusing {
-            @TransitionRecord { :>> name = "resume"; :>> trigger = "resumeRequested"; }
+            @MemoIdentity { :>> label = "resume"; } @TransitionRecord { :>> trigger = "resumeRequested"; }
         }
         transition tFault first infusing then alarm {
-            @TransitionRecord { :>> name = "fault"; :>> trigger = "occlusionDetected"; }
+            @MemoIdentity { :>> label = "fault"; } @TransitionRecord { :>> trigger = "occlusionDetected"; }
         }
         transition tRecover first alarm then idle {
-            @TransitionRecord { :>> name = "acknowledge"; :>> trigger = "alarmCleared"; }
+            @MemoIdentity { :>> label = "acknowledge"; } @TransitionRecord { :>> trigger = "alarmCleared"; }
         }
         transition tStop first infusing then idle {
-            @TransitionRecord { :>> name = "stop"; :>> trigger = "stopInfusion"; }
-        }
-    }
-
-    view pumpModeStateMachine : MemoDiagramView {
-        expose pumpModes::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "A pump-mode state machine — Idle, Infusing, Paused, Alarm — where Infusing is a composite state nesting Priming, Delivering and Holding."; }
-        attribute :>> viewKind = DiagramViewKind::statetransition;
-        attribute :>> diagramType = "stm";
-        ref :>> viewpointDefinition = stateMachineViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeElementKinds = ("StateMachine", "MemoState");
-        }
-    }
-
-    view infusingSubStates : MemoDiagramView {
-        expose pumpModes.infusing::**;
-        attribute depth = 2;
-        @MemoIdentity { :>> shortDescription = "Sub-states of the Infusing composite state — Priming, Delivering, and Holding with their internal transitions."; }
-        attribute :>> viewKind = DiagramViewKind::statetransition;
-        attribute :>> diagramType = "stm";
-        ref :>> viewpointDefinition = stateMachineViewpoint;
-        part :>> selectionQuery {
-            attribute :>> includeElementKinds = ("MemoState");
+            @MemoIdentity { :>> label = "stop"; } @TransitionRecord { :>> trigger = "stopInfusion"; }
         }
     }