@memoarchitect/ontology 0.6.5 → 0.8.22

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

@@ -0,0 +1,94 @@
+format: memo.viewlayout/v1
+viewSource: model/catalog/viewpoints/unassigned/views/interconnection_view.sysml
+layouts:
+  diag-sample-sampleInterconnectionView:
+    nodes:
+      coffeeMachine:
+        x: 301.2
+        y: 0
+        ports:
+          mainsWaterIn:
+            x: -12
+            y: 95
+            side: left
+          beverageOut:
+            x: 536
+            y: 375
+            side: right
+          serviceInterface:
+            x: 536
+            y: 217
+            side: right
+          diagnostics:
+            x: 536
+            y: 247
+            side: right
+        width: 768
+        height: 422
+      waterTank:
+        x: 118.75
+        y: 48
+        ports:
+          tankWaterOut:
+            x: 299.5
+            y: 47
+            side: right
+          tankWaterIn:
+            x: -12
+            y: 47
+            side: left
+      heaterAssembly:
+        x: 78.80000000000001
+        y: 220
+        ports:
+          heaterWaterIn:
+            x: -12
+            y: 47
+            side: left
+          heatedWaterOut:
+            x: 352
+            y: 47
+            side: right
+      brewGroup:
+        x: 134
+        y: 328
+        ports:
+          brewWaterIn:
+            x: -12
+            y: 47
+            side: left
+          brewedCoffeeOut:
+            x: 268
+            y: 47
+            side: right
+      waterSupply:
+        x: 0
+        y: 170
+        ports:
+          supplyWaterOut:
+            x: 198.8
+            y: 47
+            side: right
+      cup:
+        x: 1000
+        y: 320
+        ports:
+          cupBeverageIn:
+            x: -12
+            y: 50
+            side: left
+    edges:
+      rel-66: {}
+      rel-67: {}
+      rel-68: {}
+      rel-69: {}
+      rel-70: {}
+      rel-71: {}
+    annotations: {}
+    canvas:
+      autoLayout: false
+      zoom: 0.83251321227496
+      pan:
+        x: -129.43112026011397
+        y: -3.900376690780462
+      coordinateSpace: context-child-v1

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

@@ -0,0 +1,109 @@
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_operational_behaviour_view {
+    private import ScalarValues::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_logical_interfaces::*;
+    private import memo_architecture_operational_structure::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_operational_operational_viewpoint::*;
+    private import memo_core_enumerations::*;
+
+    // Operational activity across clinical roles. The fixture is intentionally
+    // product-neutral and belongs only to the diagram-samples project.
+    item def OpPrescription specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::data;
+    }
+    item def OpBolusRequest specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::signal;
+    }
+
+    action def OpPrescribeTherapy specializes OperationalActivity { out item prescription : OpPrescription; }
+    action def OpVerifyPrescription specializes OperationalActivity { in item prescription : OpPrescription; }
+    action def OpRequestBolus specializes OperationalActivity { out item bolusRequest : OpBolusRequest; }
+    action def OpCheckLockout specializes OperationalActivity { in item bolusRequest : OpBolusRequest; }
+
+    // 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";
+        attribute :>> entityKind = OperationalEntityKind::device;
+        attribute :>> responsibility = "System of interest for this context view.";
+        part opClinicalTeam : User {
+            attribute :>> actorKind = ActorKind::clinician; attribute :>> name = "Clinical Team";
+            part opRolePhysician : User {
+                attribute :>> actorKind = ActorKind::clinician; attribute :>> name = "Physician"; }
+            part opRoleNurse : User {
+                attribute :>> actorKind = ActorKind::clinician; attribute :>> name = "Nurse"; }
+            part opRoleBiomed : User {
+                attribute :>> actorKind = ActorKind::technician; attribute :>> name = "Biomed Tech"; }
+        }
+        part opPatientGroup : User {
+            attribute :>> actorKind = ActorKind::patient; attribute :>> name = "Patient Interaction";
+            part opRolePatient : User {
+                attribute :>> actorKind = ActorKind::patient; attribute :>> name = "Patient"; }
+        }
+    }
+
+    action opSetupFlow : OperationalActivity {
+        action opPrescribe : OpPrescribeTherapy { attribute :>> name = "Prescribe Therapy"; }
+        action opVerify : OpVerifyPrescription { attribute :>> name = "Verify Prescription"; }
+        fork opForkPrep;
+        action opPrime : OperationalActivity { attribute :>> name = "Prime Pump & Load Reservoir"; }
+        action opSelfTest : OperationalActivity { attribute :>> name = "Run Device Self-Test"; }
+        join opJoinPrep;
+        action opProgram : OperationalActivity { attribute :>> name = "Program Pump Parameters"; }
+        action opConnect : OperationalActivity { attribute :>> name = "Connect to Patient"; }
+        action opStart : OperationalActivity { attribute :>> name = "Start Infusion"; }
+        action opAdminister : OperationalActivity {
+            attribute :>> name = "Administer PCA Therapy";
+            action opRequestBolus : OpRequestBolus { attribute :>> name = "Request Bolus"; }
+            action opCheckLockout : OpCheckLockout { attribute :>> name = "Check Lockout"; }
+            action opDeliverDose : OperationalActivity { attribute :>> name = "Deliver Dose"; }
+            action opLogEvent : OperationalActivity { attribute :>> name = "Log Dose Event"; }
+            flow 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;
+        first start then opPrescribe;
+        first opPrescribe then opVerify;
+        first opVerify then opForkPrep;
+        first opForkPrep then opPrime;
+        first opForkPrep then opSelfTest;
+        first opPrime then opJoinPrep;
+        first opSelfTest then opJoinPrep;
+        first opJoinPrep then opProgram;
+        first opProgram then opConnect;
+        first opConnect then opStart;
+        first opStart then opAdminister;
+        first opAdminister then done;
+    }
+
+    allocate opSetupFlow.opPrescribe to opCareSystem.opClinicalTeam.opRolePhysician;
+    allocate opSetupFlow.opVerify to opCareSystem.opClinicalTeam.opRoleNurse;
+    allocate opSetupFlow.opPrime to opCareSystem.opClinicalTeam.opRoleNurse;
+    allocate opSetupFlow.opSelfTest to opCareSystem.opClinicalTeam.opRoleBiomed;
+    allocate opSetupFlow.opProgram to opCareSystem.opClinicalTeam.opRoleNurse;
+    allocate opSetupFlow.opConnect to opCareSystem.opClinicalTeam.opRoleNurse;
+    allocate opSetupFlow.opStart to opCareSystem.opClinicalTeam.opRoleNurse;
+    allocate opSetupFlow.opAdminister to opCareSystem.opClinicalTeam.opRoleNurse;
+    allocate opSetupFlow.opAdminister.opRequestBolus to opCareSystem.opPatientGroup.opRolePatient;
+    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 opSetupView : MemoDiagramView {
+        expose opSetupFlow::**;
+        expose opCareSystem::**;
+        attribute depth = 2;
+        attribute :>> title = "Sample · Clinical PCA Setup (Operational)";
+        attribute :>> shortDescription = "Operational activity across clinical roles with concurrent preparation and a composite therapy step.";
+        attribute :>> viewKind = DiagramViewKind::actionflow;
+        attribute :>> diagramType = "ofd";
+        part :>> viewpointDefinition = operationalViewpoint;
+    }
+}

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

@@ -0,0 +1,13 @@
+format: memo.viewlayout/v1
+viewSource: model/catalog/viewpoints/unassigned/views/operational_behaviour_view.sysml
+layouts:
+  diag-sample-opSetupView:
+    nodes: {}
+    edges: {}
+    canvas:
+      autoLayout: true
+      zoom: 0.3666153460391409
+      pan:
+        x: 359.78478424853927
+        y: 41.19938625300375
+      coordinateSpace: context-child-v1

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

@@ -1,13 +1,14 @@
 // 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.
-package memo_examples_sysml_diagram_samples_model_samples_requirements_view {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_requirements_view {
     private import ScalarValues::*;
 
     private import memo_assurance_requirements_needs::*;
     private import memo_assurance_requirements::*;
     private import memo_core_relationships::*;
     private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_requirements_requirements_viewpoint::*;
     private import memo_core_enumerations::*;
 
     requirement needSafeTherapy : Need {
@@ -45,19 +46,17 @@ package memo_examples_sysml_diagram_samples_model_samples_requirements_view {
     view sampleRequirementsView : MemoDiagramView {
         expose needSafeTherapy::**;
         expose needTimelyAlarms::**;
+        expose reqDoseLimit;
+        expose reqOcclusionAlarm;
+        expose reqAlarmLoudness;
         attribute depth = 1;
         attribute :>> title = "Sample · Requirements";
         attribute :>> shortDescription = "Stakeholder needs deriving into system requirements, wired by DerivesFrom trace edges.";
         attribute :>> viewKind = DiagramViewKind::general;
         attribute :>> diagramType = "req";
+        part :>> viewpointDefinition = requirementsViewpoint;
         part :>> selectionQuery {
             attribute :>> includeRelationshipKinds = ("DerivesFrom");
         }
     }
-
-    connection : IncludedIn connect sourceElement ::> needSafeTherapy to targetView ::> sampleRequirementsView;
-    connection : IncludedIn connect sourceElement ::> needTimelyAlarms to targetView ::> sampleRequirementsView;
-    connection : IncludedIn connect sourceElement ::> reqDoseLimit to targetView ::> sampleRequirementsView;
-    connection : IncludedIn connect sourceElement ::> reqOcclusionAlarm to targetView ::> sampleRequirementsView;
-    connection : IncludedIn connect sourceElement ::> reqAlarmLoudness to targetView ::> sampleRequirementsView;
 }

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

@@ -0,0 +1,33 @@
+// Standard SysML v2 activity sample (actionflow view kind, `afd` diagram type).
+//
+// The view over `activity_example::CustomerProcess`, the standard-SysML activity
+// fixture in `model/sysml_v2_activity_example.sysml`. It exists because the
+// fixture's whole point is the node types `action_flow_view.sysml` does not
+// have — decision, merge, fork, join, accept, send, terminate, and guarded
+// successions. Without a view exposing it the fixture parses into the model and
+// is never drawn, which is indistinguishable from a renderer that cannot draw
+// decisions.
+//
+// Nothing here specializes a MEMO kind: the fixture is plain standard SysML,
+// and that is the property under test. The renderer classifies its nodes from
+// the metamodel (`activity-notation.ts`), not from an ontology kind.
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_standard_activity_view {
+    private import ScalarValues::*;
+
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_functional_functional_viewpoint::*;
+    private import memo_core_enumerations::*;
+
+    private import activity_example::*;
+
+    view standardActivityView : MemoDiagramView {
+        expose CustomerProcess::**;
+        attribute depth = 2;
+        attribute :>> title = "Sample · Customer Purchase Process";
+        attribute :>> shortDescription = "Customer login, guarded validation, shopping loop, checkout, credit approval, and explicit completion outcomes.";
+        attribute :>> viewKind = DiagramViewKind::actionflow;
+        attribute :>> diagramType = "afd";
+        part :>> viewpointDefinition = functionalViewpoint;
+    }
+}

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

@@ -0,0 +1,80 @@
+// 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.
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_state_transition_view {
+    private import ScalarValues::*;
+
+    private import memo_architecture_functional_behavior::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_functional_functional_viewpoint::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_common::*;
+
+    state pumpModes : StateMachine {
+        attribute :>> name = "Pump Operating Modes";
+
+        state idle : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Idle"; }
+
+        // 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)"; }
+
+            transition tPrimed first priming then delivering {
+                @TransitionRecord { :>> name = "primed"; :>> trigger = "primeComplete"; }
+            }
+            transition tKvo first delivering then holding {
+                @TransitionRecord { :>> name = "keepVeinOpen"; :>> trigger = "doseComplete"; }
+            }
+            transition tResumeDose first holding then delivering {
+                @TransitionRecord { :>> name = "resumeDose"; :>> trigger = "doseScheduled"; }
+            }
+        }
+
+        state paused : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Paused"; }
+        state alarm : MemoState { attribute :>> stateKind = StateKind::mode; attribute :>> name = "Alarm"; }
+
+        transition tStart first idle then infusing {
+            @TransitionRecord { :>> name = "start"; :>> trigger = "startInfusion"; }
+        }
+        transition tPause first infusing then paused {
+            @TransitionRecord { :>> name = "pause"; :>> trigger = "pauseRequested"; }
+        }
+        transition tResume first paused then infusing {
+            @TransitionRecord { :>> name = "resume"; :>> trigger = "resumeRequested"; }
+        }
+        transition tFault first infusing then alarm {
+            @TransitionRecord { :>> name = "fault"; :>> trigger = "occlusionDetected"; }
+        }
+        transition tRecover first alarm then idle {
+            @TransitionRecord { :>> name = "acknowledge"; :>> trigger = "alarmCleared"; }
+        }
+        transition tStop first infusing then idle {
+            @TransitionRecord { :>> name = "stop"; :>> trigger = "stopInfusion"; }
+        }
+    }
+
+    view sampleStateTransitionView : MemoDiagramView {
+        expose pumpModes::**;
+        attribute depth = 2;
+        attribute :>> title = "Sample · State Transition";
+        attribute :>> 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";
+        part :>> viewpointDefinition = functionalViewpoint;
+        part :>> selectionQuery {
+            attribute :>> includeElementKinds = ("StateMachine", "MemoState");
+        }
+    }
+
+    // The machine is one containment tree, so exposing its root reaches every
+    // state and transition; the former per-element IncludedIn list restated
+    // that tree a second time and is gone with it.
+}

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

@@ -0,0 +1,48 @@
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_tree_view {
+    private import ScalarValues::*;
+    private import memo_architecture_implementation_hardware_structure::*;
+
+    private import memo_architecture_realization_physical::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_physical_physical_viewpoint::*;
+    private import memo_core_enumerations::*;
+
+    part rootA : HardwareAssembly {
+        attribute :>> name = "Root A";
+        part branchA1 : HardwareAssembly {
+            attribute :>> name = "Branch A.1";
+            part leafA11 : HardwareAssembly {
+                attribute :>> name = "Leaf A.1.1";
+                attribute :>> partNumber = "PN-001";
+            }
+            part leafA12 : HardwareAssembly { attribute :>> name = "Leaf A.1.2"; }
+        }
+        part branchA2 : HardwareAssembly {
+            attribute :>> name = "Branch A.2 With A Deliberately Long Label";
+            part leafA21 : HardwareAssembly { attribute :>> name = "Leaf A.2.1"; }
+        }
+        part rootB : HardwareAssembly {
+            attribute :>> name = "Root B";
+            part branchB1 : HardwareAssembly {
+                attribute :>> name = "Branch B.1";
+                part leafB11 : HardwareAssembly { attribute :>> name = "Leaf B.1.1"; }
+            }
+        }
+    }
+
+    view sampleTreeView : MemoDiagramView {
+        expose rootA::**;
+        attribute depth = 2;
+        attribute :>> title = "Sample · Tree";
+        attribute :>> shortDescription = "One connected dummy hierarchy with varied branch depths for tree layout development.";
+        attribute :>> viewKind = DiagramViewKind::general;
+        attribute :>> diagramType = "bdd";
+        part :>> viewpointDefinition = physicalViewpoint;
+        attribute :>> layoutHint = "tree";
+        attribute :>> styleHint = "expanded:rootA,rootB,branchA1,branchB1";
+        part :>> selectionQuery {
+            attribute :>> includeRelationshipKinds = ("Composes");
+        }
+    }
+}

package/examples/sysml-diagram-samples/model/{samples → catalog/viewpoints/unassigned/views}/use_case_view.sysml

@@ -1,9 +1,10 @@
-package memo_examples_sysml_diagram_samples_model_samples_use_case_view {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_use_case_view {
     private import ScalarValues::*;
     private import memo_architecture_operational_context_actors::*;
     private import memo_architecture_operational_use_cases::*;
     private import memo_core_relationships::*;
     private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_operational_operational_viewpoint::*;
     private import memo_core_enumerations::*;
 
     // Product-neutral fixture for the UML-style use-case presentation.
@@ -24,16 +25,25 @@ package memo_examples_sysml_diagram_samples_model_samples_use_case_view {
         attribute :>> id = "UC-SAMPLE-001";
         attribute :>> name = "Review Device Status";
         attribute :>> useCaseKind = UseCaseKind::clinical;
+        include validateTherapySettings;
+        subject supportingSystem;
+        actor patientActor = patient;
     }
     use case configureTherapy : UseCase {
         attribute :>> id = "UC-SAMPLE-002";
         attribute :>> name = "Configure Therapy";
         attribute :>> useCaseKind = UseCaseKind::clinical;
+        include reviewStatus;
+        subject supportingSystem;
+        actor clinicianInitiator = clinician;
+        actor patientActor = patient;
     }
     use case maintainDevice : UseCase {
         attribute :>> id = "UC-SAMPLE-003";
         attribute :>> name = "Maintain Device";
         attribute :>> useCaseKind = UseCaseKind::service;
+        subject supportingSystem;
+        actor serviceTechnicianActor = serviceTechnician;
     }
 
     use case documentTreatment : UseCase {
@@ -47,15 +57,10 @@ package memo_examples_sysml_diagram_samples_model_samples_use_case_view {
         attribute :>> id = "UC-SAMPLE-005";
         attribute :>> name = "Validate Therapy Settings";
         attribute :>> useCaseKind = UseCaseKind::clinical;
+        subject supportingSystem;
+        actor clinicianActor = clinician;
     }
 
-    connection : Initiates connect initiatingUser ::> clinician to initiatedUseCase ::> configureTherapy;
-    connection : ParticipatesIn connect participatingActor ::> patient to useCase ::> reviewStatus;
-    connection : ParticipatesIn connect participatingActor ::> patient to useCase ::> configureTherapy;
-    connection : ParticipatesIn connect participatingActor ::> serviceTechnician to useCase ::> maintainDevice;
-    connection : ParticipatesIn connect participatingActor ::> clinician to useCase ::> validateTherapySettings;
-    connection : Includes connect includingUseCase ::> configureTherapy to includedUseCase ::> reviewStatus;
-    connection : Includes connect includingUseCase ::> reviewStatus to includedUseCase ::> validateTherapySettings;
     connection : Extends connect extendingUseCase ::> documentTreatment to extendedUseCase ::> reviewStatus;
 
     view sampleUseCaseView : MemoDiagramView {
@@ -71,9 +76,10 @@ package memo_examples_sysml_diagram_samples_model_samples_use_case_view {
         attribute :>> shortDescription = "Actors outside a device boundary with include, extend, hierarchy-level, and orthogonal-routing presentation.";
         attribute :>> viewKind = DiagramViewKind::general;
         attribute :>> diagramType = "ucd";
+        part :>> viewpointDefinition = operationalViewpoint;
         part :>> selectionQuery {
             attribute :>> includeElementKinds = ("User", "UseCase");
-            attribute :>> includeRelationshipKinds = ("Initiates", "ParticipatesIn", "Includes", "Extends");
+            attribute :>> includeRelationshipKinds = ("ParticipatesIn", "IncludesStep", "Extends");
         }
         // Presentation is owned by the model view, rather than a canvas control.
         attribute :>> layoutHint = "usecase:level=all;edge=rounded";

package/examples/sysml-diagram-samples/model/sysml_v2_activity_example.sysml

@@ -0,0 +1,93 @@
+// Runnable standard SysML v2 action-flow sample.
+package activity_example {
+    private import ScalarValues::*;
+
+    item def Order;
+    item def Receipt;
+    part def Customer;
+    action def ProcessOrder;
+
+    action def FulfillOrder {
+        part customer : Customer;
+        action receiveOrder accept order : Order;
+        action validateOrder { in order : Order; }
+        decide routeOrder;
+        action processOrder : ProcessOrder;
+        action rejectOrder;
+        merge afterDecision;
+        fork parallelWork;
+        action prepareShipment;
+        action createInvoice;
+        join readyToNotify;
+        action notifyCustomer { out receipt : Receipt; }
+        then action sendReceipt send notifyCustomer.receipt to customer;
+        then terminate;
+
+        succession first start then receiveOrder;
+        succession first receiveOrder then validateOrder;
+        flow of Order from receiveOrder.order to validateOrder.order;
+        succession first validateOrder then routeOrder;
+        succession first routeOrder if true then processOrder;
+        succession first routeOrder if false then rejectOrder;
+        succession first processOrder then afterDecision;
+        succession first rejectOrder then afterDecision;
+        succession first afterDecision then parallelWork;
+        succession first parallelWork then prepareShipment;
+        succession first parallelWork then createInvoice;
+        succession first prepareShipment then readyToNotify;
+        succession first createInvoice then readyToNotify;
+        succession first readyToNotify then notifyCustomer;
+    }
+
+    // Customer purchase behavior encoded from the reference activity diagram.
+    // The source picture draws two outgoing paths directly from
+    // viewShoppingBasket. In the semantic model that choice is made explicit
+    // with shoppingDecision; browseCatalog is the merge required to re-enter
+    // the browsing loop without making viewBookStore wait for both inputs.
+    action def CustomerProcess {
+        attribute validUser : Boolean;
+        attribute continueShopping : Boolean;
+        attribute creditOK : Boolean;
+
+        action customerLogsIn;
+        decide validUserDecision;
+        action rejected terminate;
+
+        merge browseCatalog;
+        action viewBookStore;
+        action selectBookForPurchase;
+        action addToShoppingBasket;
+        action viewShoppingBasket;
+        decide shoppingDecision;
+
+        action commitOrder;
+        action supplyCreditCardDetails;
+        decide creditDecision;
+        action rejectCreditCard;
+        action closeOrder terminate;
+        action confirmPurchase;
+        action itemsDelivered;
+        action orderComplete terminate;
+
+        succession first start then customerLogsIn;
+        succession first customerLogsIn then validUserDecision;
+        succession first validUserDecision if validUser == true then browseCatalog;
+        succession first validUserDecision if validUser == false then rejected;
+
+        succession first browseCatalog then viewBookStore;
+        succession first viewBookStore then selectBookForPurchase;
+        succession first selectBookForPurchase then addToShoppingBasket;
+        succession first addToShoppingBasket then viewShoppingBasket;
+        succession first viewShoppingBasket then shoppingDecision;
+        succession first shoppingDecision if continueShopping == true then browseCatalog;
+        succession first shoppingDecision if continueShopping == false then commitOrder;
+
+        succession first commitOrder then supplyCreditCardDetails;
+        succession first supplyCreditCardDetails then creditDecision;
+        succession first creditDecision if creditOK == false then rejectCreditCard;
+        succession first rejectCreditCard then closeOrder;
+        succession first creditDecision if creditOK == true then confirmPurchase;
+        succession first confirmPurchase then itemsDelivered;
+        succession first itemsDelivered then orderComplete;
+    }
+}

package/examples/temperature-alarm/model/catalog/project.sysml

@@ -0,0 +1,24 @@
+// Temperature Alarm — 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_temperature_alarm_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_temperature_alarm_viewpoints_unassigned::*;
+    private import memo_examples_temperature_alarm_viewpoints_unassigned_views_temperature_alarm_overview::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-TEMPERATURE-ALARM-001";
+        attribute :>> name = "TemperatureAlarmProjectMethodBinding";
+        attribute :>> projectName = "Temperature Alarm";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}