@memoarchitect/ontology 0.6.5 → 0.8.22

package/examples/nested-architecture-dsm/model/catalog/assurance/requirements/needs.sysml

@@ -0,0 +1,53 @@
+// Stakeholder needs — the outermost row of a full trace chain.
+//
+// Need → Requirement → Function → VerificationCase is the chain the
+// traceability view is meant to walk one hop at a time.
+package memo_examples_nested_architecture_dsm_assurance_requirements_needs {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_assurance_requirements_needs::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+
+    requirement needAccurateTherapy : Need {
+        attribute :>> id = "NDS-NEED-001"; attribute :>> name = "AccurateTherapyDelivery";
+        attribute :>> needKind = NeedKind::'stakeholder';
+        attribute :>> statement = "Clinicians need the delivered dose to match the prescription closely enough to be clinically safe.";
+        attribute :>> priority = "high";
+    }
+    requirement needProtectionFromHarm : Need {
+        attribute :>> id = "NDS-NEED-002"; attribute :>> name = "ProtectionFromDeliveryFaults";
+        attribute :>> needKind = NeedKind::'stakeholder';
+        attribute :>> statement = "Patients need delivery to stop before a line fault or air bolus reaches them.";
+        attribute :>> priority = "high";
+    }
+    requirement needUninterruptedTherapy : Need {
+        attribute :>> id = "NDS-NEED-003"; attribute :>> name = "UninterruptedTherapy";
+        attribute :>> needKind = NeedKind::operational;
+        attribute :>> statement = "Wards need therapy to continue through transport and mains interruptions.";
+        attribute :>> priority = "medium";
+        attribute :>> operationalContextReference = "intra-hospital transport, up to four hours off mains";
+    }
+    requirement needLegibleStatus : Need {
+        attribute :>> id = "NDS-NEED-004"; attribute :>> name = "LegibleTherapyStatus";
+        attribute :>> needKind = NeedKind::'stakeholder';
+        attribute :>> statement = "Clinicians need to read therapy state and alarms correctly from the bedside.";
+        attribute :>> priority = "high";
+        attribute :>> userPopulationReference = "ward nurses, including those wearing corrective lenses";
+    }
+
+    // Need → Requirement.
+    connection derAccuracy : DerivesFrom connect sourceDriver ::> needAccurateTherapy to targetRequirement ::> reqDoseAccuracy;
+    connection derOcclusion : DerivesFrom connect sourceDriver ::> needProtectionFromHarm to targetRequirement ::> reqOcclusionDetection;
+    connection derAirInLine : DerivesFrom connect sourceDriver ::> needProtectionFromHarm to targetRequirement ::> reqAirInLine;
+    connection derAlarm : DerivesFrom connect sourceDriver ::> needLegibleStatus to targetRequirement ::> reqAlarmAnnunciation;
+    connection derBattery : DerivesFrom connect sourceDriver ::> needUninterruptedTherapy to targetRequirement ::> reqBatteryEndurance;
+    connection derConfirmation : DerivesFrom connect sourceDriver ::> needLegibleStatus to targetRequirement ::> reqPrescriptionConfirmation;
+    connection derStatus : DerivesFrom connect sourceDriver ::> needLegibleStatus to targetRequirement ::> reqStatusVisibility;
+
+    // Software requirements derive from the system requirement they refine
+    // (IEC 62304), which is a second, requirement-to-requirement trace axis.
+    connection derAlarmFromSystem : DerivesFrom connect sourceDriver ::> reqOcclusionDetection to targetRequirement ::> reqAlarmAnnunciation;
+    connection derConfirmationFromSystem : DerivesFrom connect sourceDriver ::> reqDoseAccuracy to targetRequirement ::> reqPrescriptionConfirmation;
+}

package/examples/nested-architecture-dsm/model/catalog/assurance/requirements/requirements.sysml

@@ -0,0 +1,89 @@
+// Requirements — the row axis of the traceability matrix.
+//
+// StatusVisibility is deliberately left untraced, so the coverage figure is
+// under 100% and there is an empty row to author a trace into from the
+// traceability view.
+package memo_examples_nested_architecture_dsm_assurance_requirements {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_assurance_requirements::*;
+
+    requirement reqDoseAccuracy : Requirement {
+        attribute :>> id = "NDS-REQ-001"; attribute :>> name = "DoseAccuracy";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "The pump shall deliver the prescribed volume within ±5% over any 60-minute window.";
+        attribute :>> notation = RequirementNotationKind::sophist;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> systemResponse = "deliver the prescribed volume within ±5% over any 60-minute window";
+        attribute :>> concernKind = ConcernKind::clinical;
+    }
+    requirement reqOcclusionDetection : Requirement {
+        attribute :>> id = "NDS-REQ-002"; attribute :>> name = "OcclusionDetection";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "When line pressure exceeds the occlusion threshold, the pump shall stop delivery within 2 seconds.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "When line pressure exceeds the occlusion threshold";
+        attribute :>> systemResponse = "stop delivery within 2 seconds";
+        attribute :>> concernKind = ConcernKind::safety;
+    }
+    requirement reqAirInLine : Requirement {
+        attribute :>> id = "NDS-REQ-003"; attribute :>> name = "AirInLineProtection";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "When an air bolus above 0.1 mL is detected, the pump shall stop delivery and raise a high-priority alarm.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "When an air bolus above 0.1 mL is detected";
+        attribute :>> systemResponse = "stop delivery and raise a high-priority alarm";
+        attribute :>> concernKind = ConcernKind::safety;
+    }
+    requirement reqAlarmAnnunciation : Requirement {
+        attribute :>> id = "NDS-REQ-004"; attribute :>> name = "AlarmAnnunciation";
+        attribute :>> requirementKind = RequirementKind::software;
+        attribute :>> statement = "While any alarm condition is active, the pump shall present its IEC 60601-1-8 signal until the condition clears or is acknowledged.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::stateDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "While any alarm condition is active";
+        attribute :>> systemResponse = "present its IEC 60601-1-8 signal until the condition clears or is acknowledged";
+        attribute :>> concernKind = ConcernKind::safety;
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+    requirement reqBatteryEndurance : Requirement {
+        attribute :>> id = "NDS-REQ-005"; attribute :>> name = "BatteryEndurance";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "On loss of mains power, the pump shall continue delivery for at least 4 hours at 25 mL/h.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "On loss of mains power";
+        attribute :>> systemResponse = "continue delivery for at least 4 hours at 25 mL/h";
+        attribute :>> concernKind = ConcernKind::reliability;
+    }
+    requirement reqPrescriptionConfirmation : Requirement {
+        attribute :>> id = "NDS-REQ-006"; attribute :>> name = "PrescriptionConfirmation";
+        attribute :>> requirementKind = RequirementKind::software;
+        attribute :>> statement = "When the clinician changes the infusion rate, the pump shall require explicit confirmation before applying it.";
+        attribute :>> notation = RequirementNotationKind::ears;
+        attribute :>> earsPattern = EarsPatternKind::eventDriven;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> conditionClause = "When the clinician changes the infusion rate";
+        attribute :>> systemResponse = "require explicit confirmation before applying it";
+        attribute :>> concernKind = ConcernKind::usability;
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+    // Untraced on purpose — the gap the traceability view is meant to find.
+    requirement reqStatusVisibility : Requirement {
+        attribute :>> id = "NDS-REQ-007"; attribute :>> name = "StatusVisibility";
+        attribute :>> requirementKind = RequirementKind::system;
+        attribute :>> statement = "The pump shall display the active rate and volume delivered legibly at 1 m.";
+        attribute :>> notation = RequirementNotationKind::sophist;
+        attribute :>> obligation = ObligationKind::shall;
+        attribute :>> systemResponse = "display the active rate and volume delivered legibly at 1 m";
+        attribute :>> concernKind = ConcernKind::usability;
+    }
+}

package/examples/nested-architecture-dsm/model/catalog/assurance/verification_validation/verification_validation.sysml

@@ -0,0 +1,113 @@
+// Verification cases — the far end of the trace chain, and a third axis for
+// the traceability matrix (function → verification case).
+package memo_examples_nested_architecture_dsm_assurance_verification_validation {
+    private import ScalarValues::*;
+    private import memo_core_dimensions::*;   // ElementStatusKind
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_assurance_verification_validation::*;
+    private import memo_examples_nested_architecture_dsm_architecture_functional_functions::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+
+    verification vcDoseAccuracy : VerificationCase {
+        attribute :>> id = "NDS-VER-001"; attribute :>> name = "VerifyDoseAccuracy";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Gravimetric delivery over 60 minutes is within ±5% of the prescribed volume at 1, 25 and 999 mL/h.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        objective { verify reqDoseAccuracy; }
+        subject verified : Base::Anything[*] = (fnDeliverTherapy, fnDeliverTherapy.fnMeterFluid, fnDeliverTherapy.fnMeterFluid.fnDriveActuator, fnDeliverTherapy.fnMeterFluid.fnMeasureDelivered, fnDeliverTherapy.fnControlDose, fnDeliverTherapy.fnControlDose.fnComputeRate);
+    }
+    verification vcOcclusionResponse : VerificationCase {
+        attribute :>> id = "NDS-VER-002"; attribute :>> name = "VerifyOcclusionResponse";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Delivery stops within 2 s of the occlusion threshold being crossed, at every supported rate.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        objective { verify reqOcclusionDetection; }
+        subject verified : Base::Anything[*] = (fnEnsureSafety, fnEnsureSafety.fnDetectOcclusion, fnEnsureSafety.fnEnforceDoseLimits);
+    }
+    verification vcAirInLineResponse : VerificationCase {
+        attribute :>> id = "NDS-VER-003"; attribute :>> name = "VerifyAirInLineResponse";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "A 0.1 mL air bolus stops delivery and raises a high-priority alarm.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        objective { verify reqAirInLine; }
+        subject verified : Base::Anything[*] = (fnEnsureSafety.fnDetectAirInLine);
+    }
+    verification vcAlarmSignals : VerificationCase {
+        attribute :>> id = "NDS-VER-004"; attribute :>> name = "VerifyAlarmSignals";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Alarm signals conform to IEC 60601-1-8 for every priority, and persist until cleared or acknowledged.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        objective { verify reqAlarmAnnunciation; }
+        subject verified : Base::Anything[*] = (fnInformUser.fnAnnunciateAlarm);
+    }
+    verification vcBatteryEndurance : VerificationCase {
+        attribute :>> id = "NDS-VER-005"; attribute :>> name = "VerifyBatteryEndurance";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Delivery continues for at least 4 hours at 25 mL/h from a fully charged battery after mains loss.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        objective { verify reqBatteryEndurance; }
+        subject verified : Base::Anything[*] = (fnManagePower, fnManagePower.fnMonitorBattery);
+    }
+    verification vcConfirmationFlow : VerificationCase {
+        attribute :>> id = "NDS-VER-006"; attribute :>> name = "VerifyConfirmationFlow";
+        attribute :>> methodKind = VerificationMethodKind::demonstration;
+        attribute :>> acceptanceCriteria = "No rate change reaches the controller without an explicit confirmation step.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        objective { verify reqPrescriptionConfirmation; }
+        subject verified : Base::Anything[*] = (fnDeliverTherapy.fnControlDose.fnValidatePrescription, fnInformUser.fnAcceptInput);
+    }
+    verification vcStatusLegibility : VerificationCase {
+        attribute :>> id = "NDS-VER-007"; attribute :>> name = "VerifyStatusLegibility";
+        attribute :>> methodKind = VerificationMethodKind::inspection;
+        attribute :>> acceptanceCriteria = "Rate and volume delivered are readable at 1 m under 100–1000 lux.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        objective { verify reqStatusVisibility; }
+        subject verified : Base::Anything[*] = (fnInformUser, fnInformUser.fnRenderStatus);
+    }
+    verification vcPowerSourceSwitch : VerificationCase {
+        attribute :>> id = "NDS-VER-008"; attribute :>> name = "VerifyPowerSourceSwitch";
+        attribute :>> methodKind = VerificationMethodKind::test;
+        attribute :>> acceptanceCriteria = "Rail brownout switches source without interrupting delivery.";
+        attribute :>> status = ElementStatusKind::approved;
+
+        subject verified : Base::Anything[*] = (fnManagePower.fnSelectPowerSource);
+    }
+
+    // Requirement → verification case.
+
+
+
+
+
+
+
+    // Function → verification case, so safety-critical functions carry their
+    // own verification rather than inheriting it through a requirement.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}

package/examples/nested-architecture-dsm/model/catalog/project.sysml

@@ -0,0 +1,28 @@
+// Nested architecture DSM — project identity and method binding.
+//
+// The native entrypoint. The imports name what this project contains and the
+// binding names the methodology governing it. No YAML file participates.
+package memo_examples_nested_architecture_dsm_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_nested_architecture_dsm_architecture_logical_structure::*;
+    private import memo_examples_nested_architecture_dsm_architecture_functional_functions::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements_needs::*;
+    private import memo_examples_nested_architecture_dsm_assurance_verification_validation::*;
+    private import memo_examples_nested_architecture_dsm_traces::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-NESTED-DSM-001";
+        attribute :>> name = "NestedArchitectureDsmProjectMethodBinding";
+        attribute :>> projectName = "Nested Architecture DSM";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}

package/examples/nested-architecture-dsm/model/catalog/traces.sysml

@@ -0,0 +1,48 @@
+// Cross-axis links: allocation and satisfaction.
+//
+// These are what make the two matrices show different things over the same
+// model. The DSM reads allocation as a dependency between a function and the
+// block that carries it; the traceability view reads satisfaction as coverage
+// of a requirement. Keeping both in one file makes the cross-axis story easy
+// to read, and easy to extend from the traceability view's editor.
+package memo_examples_nested_architecture_dsm_traces {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_examples_nested_architecture_dsm_architecture_functional_functions::*;
+    private import memo_examples_nested_architecture_dsm_architecture_logical_structure::*;
+    private import memo_examples_nested_architecture_dsm_assurance_requirements::*;
+
+    // ── Function → block allocation ──────────────────────────────
+    allocate fnDeliverTherapy.fnMeterFluid.fnDriveActuator to sysTherapyDelivery.subFluidPath.lcPumpMechanism;
+    allocate fnDeliverTherapy.fnMeterFluid.fnMeasureDelivered to sysTherapyDelivery.subFluidPath.lcPumpMechanism;
+    allocate fnDeliverTherapy.fnControlDose.fnComputeRate to sysTherapyDelivery.subControl.lcDoseController;
+    allocate fnDeliverTherapy.fnControlDose.fnValidatePrescription to sysTherapyDelivery.subControl.lcDoseController;
+    allocate fnEnsureSafety.fnDetectOcclusion to sysTherapyDelivery.subFluidPath.lcOcclusionChannel;
+    allocate fnEnsureSafety.fnDetectAirInLine to sysTherapyDelivery.subFluidPath.lcOcclusionChannel;
+    // Two channels carry the same protective function — the redundancy shows
+    // up in the matrix as two marks on one row.
+    allocate fnEnsureSafety.fnEnforceDoseLimits to sysTherapyDelivery.subControl.subSafetyMonitor.lcWatchdogChannel;
+    allocate fnEnsureSafety.fnEnforceDoseLimits to sysTherapyDelivery.subControl.subSafetyMonitor.lcPressureIntegrityChannel;
+    allocate fnInformUser.fnRenderStatus to sysTherapyDelivery.subUserInterface.lcDisplayManager;
+    allocate fnInformUser.fnAnnunciateAlarm to sysTherapyDelivery.subUserInterface.lcAlarmAnnunciator;
+    allocate fnInformUser.fnAcceptInput to sysTherapyDelivery.subUserInterface.lcKeypadHandler;
+    allocate fnManagePower.fnMonitorBattery to sysTherapyDelivery.subPower.lcBatteryManager;
+    allocate fnManagePower.fnSelectPowerSource to sysTherapyDelivery.subPower.lcPowerRailMonitor;
+    // A capability allocated at subsystem level rather than to one component:
+    // collapsed, it lands in the same cell as its children's allocations.
+    allocate fnDeliverTherapy.fnMeterFluid to sysTherapyDelivery.subFluidPath;
+    // ── Requirement → function satisfaction ──────────────────────
+
+
+
+
+
+
+
+
+
+
+
+}

package/examples/reusable-instrument/model/catalog/project.sysml

@@ -0,0 +1,24 @@
+// Reusable Instrument — 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_reusable_instrument_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_reusable_instrument_viewpoints_unassigned::*;
+    private import memo_examples_reusable_instrument_viewpoints_unassigned_views_reusable_instrument_overview::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-REUSABLE-INSTRUMENT-001";
+        attribute :>> name = "ReusableInstrumentProjectMethodBinding";
+        attribute :>> projectName = "Reusable Instrument";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}

package/examples/reusable-instrument/model/catalog/reusable_instrument.sysml

@@ -5,6 +5,7 @@ package memo_examples_reusable_instrument {
     private import ScalarValues::*;
 
     private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
     private import memo_architecture_operational_context_actors::*;
     private import memo_architecture_operational_use_cases::*;
     private import memo_architecture_operational_activities::*;
@@ -23,8 +24,9 @@ package memo_examples_reusable_instrument {
         attribute :>> goalStatement = "Return a used instrument to sterile, functional condition for the next case.";
         attribute :>> preCondition = "instrument collected from the OR; gross soil removed at point of use";
         attribute :>> successOutcome = "instrument cleaned, inspected, sterilized, and released to sterile storage";
+        subject supportingSystem;
+        actor sterileProcessingTechActor = sterileProcessingTech;
     }
-    connection : Initiates connect initiatingUser ::> sterileProcessingTech to initiatedUseCase ::> ucSterilize;
 
     // Reprocessing workflow: exists independently of any single instrument.
     action wfReprocess : OperationalWorkflow {
@@ -32,6 +34,9 @@ package memo_examples_reusable_instrument {
         attribute :>> workflowState = WorkflowStateKind::asIs;
         attribute :>> entryCondition = "used instrument received in decontamination";
         attribute :>> completionCondition = "sterile pack released to storage";
+
+        action wsClean : WorkflowStep { ref :>> performedActivity = actClean; }
+        first wsClean then wsInspect;
     }
     action actClean : OperationalActivity {
         attribute :>> id = "RI-ACT-001"; attribute :>> name = "CleanAndDisinfect";
@@ -45,16 +50,14 @@ package memo_examples_reusable_instrument {
         attribute :>> id = "RI-ACT-003"; attribute :>> name = "PackAndAutoclave";
         attribute :>> criticality = CriticalityKind::high;
     }
-    action wsClean : WorkflowStep { attribute :>> stepOrder = 1; ref :>> performedActivity = actClean; }
-    action wsInspect : WorkflowStep { attribute :>> stepOrder = 2; ref :>> performedActivity = actInspect; }
-    action wsSterilize : WorkflowStep { attribute :>> stepOrder = 3; ref :>> performedActivity = actSterilizeLoad; }
-    connection : Composes connect parent ::> wfReprocess to child ::> wsClean;
-    connection : StepPrecedes connect predecessor ::> wsClean to successor ::> wsInspect;
-    connection : StepPrecedes connect predecessor ::> wsInspect to successor ::> wsSterilize;
+    action wsInspect : WorkflowStep { ref :>> performedActivity = actInspect; }
+    action wsSterilize : WorkflowStep { ref :>> performedActivity = actSterilizeLoad; }
+    first wsInspect then wsSterilize;
     connection : Supports { attribute :>> supportKind = SupportKind::useCase; connect supporter ::> wfReprocess to supported ::> ucSterilize; }
 
-    part scNominalCycle : OperativeScenario {
+    action scNominalCycle : MemoScenario {
         attribute :>> id = "RI-SC-001"; attribute :>> name = "NominalReprocessingCycle";
+        attribute :>> scenarioKind = ScenarioKind::operative;
         attribute :>> variantKind = ScenarioVariantKind::nominal;
         attribute :>> operationalCondition = OperationalConditionKind::normal;
         ref :>> parentWorkflow = wfReprocess;

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

@@ -0,0 +1,9 @@
+// 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_reusable_instrument_viewpoints_unassigned {
+    // The reusable package declaring unassigned could not be resolved during
+    // conversion. Import it here so the views beneath this viewpoint resolve.
+}

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

@@ -1,4 +1,4 @@
-package memo_examples_reusable_instrument_viewpoints {
+package memo_examples_reusable_instrument_viewpoints_unassigned_views_reusable_instrument_overview {
     private import memo_examples_reusable_instrument::*;
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;

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/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"
+        );
+    }
+}