@memoarchitect/ontology 0.4.6 → 0.6.0

package/src/architecture/decisions/memo_decisions.sysml

@@ -3,7 +3,7 @@ package memo_architecture_decisions {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    part def DesignDecision specializes TraceableElement {
+    part def DesignDecision specializes MemoPart {
         attribute decisionKind : String;
         attribute alternatives : String;
         attribute selectedOption : String;

package/src/architecture/{behavior → functional/behavior}/memo_behavior.sysml

@@ -1,13 +1,18 @@
-package memo_architecture_behavior {
+package memo_architecture_functional_behavior {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
-    part def BehaviorMachine specializes ArchitectureElement {
+    // State machines and their mode states are SysML v2 states (behaviours), so
+    // they derive from the MemoState foundation, not the part-based
+    // ArchitectureElement. Transitions stay part-based (below) to keep their
+    // traceable safety attributes.
+    // State-machine vocabulary. ModeState denotes a state owned by this model.
+    state def StateMachine :> MemoState {
         attribute machineKind : String;
         attribute executionSemantics : String;
     }
-    part def ModeState specializes ArchitectureElement {
+    state def ModeState :> MemoState {
         attribute modeKind : String;
         attribute entryCondition : String;
         attribute exitCondition : String;
@@ -21,13 +26,13 @@ package memo_architecture_behavior {
         attribute sourceState : String;
         attribute targetState : String;
     }
+    // A verifiable behavioural constraint, such as an invariant, transition
+    // rule, temporal claim, assumption, or guarantee.
     part def BehaviorProperty specializes VerifiableElement {
         attribute propertyKind : BehaviorPropertyKind;
         attribute languageKind : PropertyLanguageKind;
         attribute formalExpression : String;
     }
-    part def AssumeProperty specializes BehaviorProperty;
-    part def GuaranteeProperty specializes BehaviorProperty;
     part def Contract specializes VerifiableElement { attribute contractScope : String; }
     part def PropertySet specializes VerifiableElement { attribute propertySetScope : String; }
     part def ActivityAction specializes ArchitectureElement {
@@ -42,12 +47,8 @@ package memo_architecture_behavior {
         attribute guardCondition : String;
         attribute weight : String;
     }
-    part def InteractionScenario specializes TraceableElement {
-        attribute scenarioKind : ScenarioKind;
-        attribute relatedCapability : String;
-        attribute diagramReference : String;
-    }
-    part def InteractionMessage specializes TraceableElement {
+    // UIScenario now lives in memo_architecture_implementation_ui (:> MemoScenario).
+    part def InteractionMessage specializes MemoPart {
         attribute messageKind : MessageKind;
         attribute sequenceOrder : Integer;
         attribute senderComponent : String;

package/src/architecture/{constraints → functional/constraints}/memo_constraints.sysml

@@ -1,7 +1,7 @@
-package memo_architecture_constraints {
+package memo_architecture_functional_constraints {
     private import ScalarValues::*;
 
-    doc /* archLayer: constraints */
+    doc /* Reusable quantitative constraint definitions. */
 
     constraint def MaxResponseTimeConstraint {
         attribute responseTimeMs : Real;

package/src/architecture/functional/functions/memo_functions.sysml

@@ -0,0 +1,81 @@
+// Functional architecture (§9). A SystemFunction is a technology-independent
+// responsibility of the system; a SystemAction is executable behavior realizing
+// a function; a FunctionalExchange is a typed transfer between functions. A
+// function may be realized by human action, mechanical design, electrical
+// hardware, software, or a combination — allocation is optional and never
+// assumes software.
+package memo_architecture_functional_functions {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_architecture_operational_scenarios::*;
+
+    part def SystemFunction specializes ArchitectureElement {
+        attribute functionCategory : String;
+        attribute trigger : String;
+        attribute outputSummary : String;
+        attribute concernKind : ConcernKind;
+        attribute criticality : CriticalityKind;
+    }
+
+    // Executable behavior realizing a system function.
+    action def SystemAction specializes MemoAction {
+        attribute actionKind : ActionKind;
+        attribute executionSummary : String;
+        ref performedFunction : SystemFunction[0..1];
+    }
+
+    // Typed transfer of information/command/status/etc. between functions
+    // (renamed from LogicalFlow — it belongs to the functional perspective).
+    part def FunctionalExchange specializes ArchitectureElement {
+        attribute flowKind : FlowKind;
+        attribute direction : DirectionKind;
+        attribute latencyBudgetMs : Real;
+        attribute staleAfterMs : Real;
+        attribute integrityLevel : String;
+        ref sourceFunction : SystemFunction[0..1];
+        ref targetFunction : SystemFunction[0..1];
+    }
+
+    // A system function enables operational work; it does not perform it.
+
+    // A reusable functional route through system responsibilities. Functional
+    // flows are part of functional architecture, never logical structure.
+    part def FunctionalFlow specializes ArchitectureElement {
+        attribute flowCategory : FunctionalFlowKind;
+        ref startFunction : SystemFunction[0..1];
+        ref endFunction : SystemFunction[0..1];
+        attribute endToEndLatencyBudgetMs : String;
+        attribute safetyRelevant : Boolean;
+        attribute securityRelevant : Boolean;
+        ref includedFunctions : SystemFunction[0..*];
+    }
+    part def FunctionalFlowStep specializes MemoPart {
+        attribute stepOrder : String;
+        ref function : SystemFunction[0..1];
+        ref exchange : FunctionalExchange[0..1];
+        ref item exchangedItem : MemoExchangeItem[0..1];
+    }
+
+    // The functional-layer scenario selects one functional route and realizes
+    // an operative scenario. It is the "what the system does" path, not a
+    // logical component interaction.
+    part def FunctionalScenario specializes MemoScenario {
+        ref functionSequence : SystemFunction[0..*];
+        ref functionalFlows : FunctionalExchange[0..*];
+        attribute sequenceDiagramRef : String;
+        ref selectedFlow : FunctionalFlow[0..1];
+    }
+    connection def IncludesStep :> MemoRelationship {
+        end functionalFlow : FunctionalFlow;
+        end step : FunctionalFlowStep;
+    }
+    connection def InvolvesFunction :> MemoRelationship {
+        end functionalFlow : FunctionalFlow;
+        end function : SystemFunction;
+    }
+    // Compatibility spelling used by existing models.
+}

package/src/architecture/implementation/hardware/common/memo_hardware_common.sysml

@@ -0,0 +1,46 @@
+// Physical realization taxonomy (§12) — shared roots. "Physical" encompasses
+// hardware, mechanical, fluidic, pneumatic, optical, acoustic, and thermal
+// realization — not only electronics. Assemblies compose components; patient-
+// contacting parts must declare contact characteristics (ISO 10993-1;
+// rules/crosslayer). Technology-domain subgroups (electrical, mechanical,
+// fluidic, optical, sensing) nest in sibling packages and specialize the roots
+// declared here; acoustic and thermal parts have no dedicated subgroup and stay
+// with the roots.
+package memo_architecture_implementation_hardware_common {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+
+    part def PhysicalAssembly specializes ArchitectureElement {
+        attribute responsibility : String;
+        attribute safetyRole : String;
+        attribute partNumber : String;
+        attribute mtbfHours : String;
+        attribute protectionClass : String;
+        attribute ipRating : String;
+    }
+    part def PhysicalSubassembly specializes PhysicalAssembly;
+    // Retained name from 0.4; an electronics-centred assembly.
+    part def HardwareAssembly specializes PhysicalAssembly;
+
+    part def PhysicalComponent specializes ArchitectureElement {
+        attribute partNumber : String;
+        attribute materialSummary : String;
+        // ISO 10993-1 contact characterization; required when true.
+        attribute patientContact : Boolean;
+        attribute contactNature : String;
+        attribute contactDuration : String;
+    }
+
+    part def HardwareComponent specializes PhysicalComponent;
+
+    part def AcousticComponent specializes PhysicalComponent {
+        attribute acousticFunction : String;
+    }
+    part def ThermalComponent specializes PhysicalComponent {
+        attribute thermalFunction : String;
+        attribute operatingRange : String;
+    }
+}

package/src/architecture/implementation/hardware/electrical/memo_hardware_electrical.sysml

@@ -0,0 +1,36 @@
+// Electrical / electronic realization subgroup (§12). Electrical power and
+// signal parts, plus cabling and connectivity media, specialize the physical
+// roots in memo_architecture_implementation_hardware_common.
+package memo_architecture_implementation_hardware_electrical {
+    private import ScalarValues::*;
+    private import memo_architecture_implementation_hardware_common::*;
+
+    part def ElectricalComponent specializes PhysicalComponent {
+        attribute ratedVoltageV : String;
+        attribute ratedCurrentA : String;
+    }
+    part def ElectronicComponent specializes PhysicalComponent {
+        attribute componentFamily : String;
+    }
+    part def PowerSupply specializes ElectricalComponent {
+        attribute inputRange : String;
+        attribute outputRails : String;
+    }
+    part def Battery specializes ElectricalComponent {
+        attribute chemistry : String;
+        attribute capacity : String;
+        attribute rechargeable : Boolean;
+    }
+    part def Cable specializes PhysicalComponent {
+        attribute conductorCount : String;
+        attribute shielding : String;
+    }
+    part def PhysicalConnectorPart specializes PhysicalComponent {
+        attribute connectorStandard : String;
+        attribute matingCycles : String;
+    }
+    part def NetworkMedium specializes PhysicalComponent {
+        attribute mediumKind : String;
+        attribute bandwidthSummary : String;
+    }
+}

package/src/architecture/implementation/hardware/fluidic/memo_hardware_fluidic.sysml

@@ -0,0 +1,14 @@
+// Fluidic / pneumatic realization subgroup (§12). Fluid- and gas-path parts
+// specialize the physical roots in memo_architecture_implementation_hardware_common.
+package memo_architecture_implementation_hardware_fluidic {
+    private import ScalarValues::*;
+    private import memo_architecture_implementation_hardware_common::*;
+
+    part def FluidicComponent specializes PhysicalComponent {
+        attribute fluidPathRole : String;
+        attribute pressureRating : String;
+    }
+    part def PneumaticComponent specializes PhysicalComponent {
+        attribute pneumaticRole : String;
+    }
+}

package/src/architecture/implementation/hardware/mechanical/memo_hardware_mechanical.sysml

@@ -0,0 +1,14 @@
+// Mechanical realization subgroup (§12). Structural and housing parts
+// specialize the physical roots in memo_architecture_implementation_hardware_common.
+package memo_architecture_implementation_hardware_mechanical {
+    private import ScalarValues::*;
+    private import memo_architecture_implementation_hardware_common::*;
+
+    part def MechanicalPart specializes PhysicalComponent {
+        attribute mechanicalFunction : String;
+    }
+    part def Enclosure specializes MechanicalPart {
+        attribute ingressProtection : String;
+        attribute cleanability : String;
+    }
+}

package/src/architecture/implementation/hardware/optical/memo_hardware_optical.sysml

@@ -0,0 +1,11 @@
+// Optical realization subgroup (§12). Light-path parts specialize the physical
+// roots in memo_architecture_implementation_hardware_common.
+package memo_architecture_implementation_hardware_optical {
+    private import ScalarValues::*;
+    private import memo_architecture_implementation_hardware_common::*;
+
+    part def OpticalComponent specializes PhysicalComponent {
+        attribute opticalFunction : String;
+        attribute wavelengthRange : String;
+    }
+}

package/src/architecture/implementation/hardware/sensing/memo_hardware_sensing.sysml

@@ -0,0 +1,17 @@
+// Sensing / actuation realization subgroup (§12). Transducers that measure or
+// act on the physical world specialize the physical roots in
+// memo_architecture_implementation_hardware_common.
+package memo_architecture_implementation_hardware_sensing {
+    private import ScalarValues::*;
+    private import memo_architecture_implementation_hardware_common::*;
+
+    part def Sensor specializes PhysicalComponent {
+        attribute measurand : String;
+        attribute rangeSummary : String;
+        attribute accuracySummary : String;
+    }
+    part def Actuator specializes PhysicalComponent {
+        attribute actuationKind : String;
+        attribute outputRange : String;
+    }
+}

package/src/architecture/implementation/hardware/structure/memo_hardware_structure.sysml

@@ -0,0 +1,12 @@
+// Physical realization taxonomy (§12) — aggregator. The hardware subgroup is
+// split by technology domain into nested packages; this package re-exports the
+// shared roots plus every domain subgroup under the historical name
+// `memo_architecture_implementation_hardware_structure`, so importers see one flat surface.
+package memo_architecture_implementation_hardware_structure {
+    public import memo_architecture_implementation_hardware_common::*;
+    public import memo_architecture_implementation_hardware_electrical::*;
+    public import memo_architecture_implementation_hardware_mechanical::*;
+    public import memo_architecture_implementation_hardware_fluidic::*;
+    public import memo_architecture_implementation_hardware_optical::*;
+    public import memo_architecture_implementation_hardware_sensing::*;
+}

package/src/architecture/implementation/software/runtime/memo_software_runtime.sysml

@@ -0,0 +1,70 @@
+// Software runtime (component-and-connector) view (§11). Runtime structure
+// with concurrency, scheduling, health monitoring, fault containment, and
+// update/rollback semantics. Module structure lives in
+// memo_architecture_implementation_software_structure; allocation in
+// memo_architecture_realization_deployment. Detailed AADL categories stay in the AADL
+// correspondence profile (examples/aadl-mapping).
+package memo_architecture_implementation_software_runtime {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_implementation_software_structure::*;
+
+    // process / thread / task / service / container / partition /
+    // dataStore / messageBroker.
+    enum def RuntimeKind {
+        enum process;
+        enum thread;
+        enum task;
+        enum service;
+        enum container;
+        enum partition;
+        enum dataStore;
+        enum messageBroker;
+    }
+
+    part def SoftwareComponent specializes ArchitectureElement {
+        attribute runtimeKind : RuntimeKind;
+        attribute responsibility : String;
+        attribute safetyClass : SafetyClassKind;
+        attribute complexity : ComplexityKind;
+        attribute periodMs : Real;
+        attribute deadlineMs : Real;
+        attribute wcetMs : Real;
+        attribute schedulingPolicy : SchedulingPolicyKind;
+        attribute priority : Integer;
+        attribute activation : String;
+        attribute synchronizationMechanism : String;
+        attribute sharedResources : String;
+        attribute memoryBudget : String;
+        attribute healthMonitoring : String;
+        attribute restartPolicy : String;
+        attribute faultContainment : String;
+        attribute version : String;
+        attribute cybersecurityCriticality : CriticalityKind;
+        attribute auditable : Boolean;
+        attribute updatePolicy : String;
+        attribute rollbackPolicy : String;
+        // runtime-kind-specific detail (set only for the relevant runtimeKind)
+        attribute addressSpaceIsolated : Boolean[0..1];
+        attribute owningProcessName : String[0..1];
+        attribute serviceContract : String[0..1];
+        attribute discoveryMechanism : String[0..1];
+        attribute imageReference : String[0..1];
+        attribute orchestrationPlatform : String[0..1];
+        attribute partitionBudget : String[0..1];
+        attribute isolationMechanism : String[0..1];
+        attribute storageKind : String[0..1];
+        attribute retentionPolicy : String[0..1];
+        attribute deliverySemantics : String[0..1];
+        attribute topicStructure : String[0..1];
+    }
+
+    connection def ComponentConnects :> MemoRelationship {
+        attribute protocolSummary : String;
+        end sourceComponent : SoftwareComponent;
+        end targetComponent : SoftwareComponent;
+    }
+}

package/src/architecture/implementation/software/structure/memo_software_structure.sysml

@@ -0,0 +1,80 @@
+// Software module view (§11; IEC 62304 5.3-5.4). Code/module structure only:
+// runtime structure lives in memo_architecture_implementation_software_runtime and
+// allocation in memo_architecture_realization_deployment.
+package memo_architecture_implementation_software_structure {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_logical_structure::*;
+
+    part def SoftwareSystem specializes ArchitectureElement {
+        attribute version : String;
+        attribute safetyClass : SafetyClassKind;
+        attribute complexity : ComplexityKind;
+        attribute operatingSystem : String;
+    }
+
+    // Module-view element (design responsibility). Runtime properties
+    // (period, WCET, scheduling) moved to SoftwareComponent.
+    // item / unit / package / library / code / firmware / soup (IEC 62304).
+    enum def ModuleKind {
+        enum item;
+        enum unit;
+        enum package;
+        enum library;
+        enum code;
+        enum firmware;
+        enum soup;
+    }
+
+    part def SoftwareModule specializes ArchitectureElement {
+        attribute moduleKind : ModuleKind;
+        attribute responsibility : String;
+        attribute safetyClass : SafetyClassKind;
+        attribute complexity : ComplexityKind;
+        // module-kind-specific detail (set only for the relevant moduleKind)
+        attribute iec62304Role : String[0..1];
+        attribute implementationLanguage : String[0..1];
+        attribute namespacePath : String[0..1];
+        attribute libraryVersion : String[0..1];
+        attribute internallyDeveloped : Boolean[0..1];
+        attribute firmwareTarget : String[0..1];
+        attribute updateMechanism : String[0..1];
+        // SOUP (IEC 62304 §8) — set only when moduleKind = soup
+        attribute soupVersion : String[0..1];
+        attribute soupVendor : String[0..1];
+        attribute knownAnomalies : String[0..1];
+        attribute riskAcceptance : String[0..1];
+        attribute soupClassification : SOUPClassificationKind[0..1];
+    }
+
+    part def Algorithm specializes ArchitectureElement {
+        attribute algorithmKind : String;
+        attribute inputSummary : String;
+        attribute outputSummary : String;
+        attribute clinicalPerformanceClaim : String;
+    }
+    part def DataModel specializes ArchitectureElement {
+        attribute schemaReference : String;
+        attribute persistenceScope : String;
+    }
+    part def ConfigurationArtifact specializes ArchitectureElement {
+        attribute configurationScope : String;
+        attribute version : String;
+    }
+
+    item def SBOMEntry specializes MemoExchangeItem {
+        attribute componentName : String;
+        attribute version : String;
+        attribute supplier : String;
+        attribute license : String;
+        attribute hash : String;
+    }
+
+    connection def ModuleUses :> MemoRelationship {
+        end usingModule : SoftwareModule;
+        end usedModule : SoftwareModule;
+    }
+}

package/src/architecture/implementation/ui/memo_ui.sysml

@@ -0,0 +1,159 @@
+// User interface and interaction (§18). A small semantic hierarchy: concrete
+// widget forms (button, knob, chart …) are enum classifications, not classes.
+// UI state is distinct from system state (memo_architecture_functional_behavior) and
+// from device modes (memo_architecture_logical_structure::LogicalMode).
+// UI is an implementation concern (rendered UI is software; physical controls
+// are hardware), so it lives in the implementation layer, not operational.
+package memo_architecture_implementation_ui {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_architecture_operational_scenarios::*;
+    private import memo_architecture_operational_use_cases::*;
+    private import memo_architecture_functional_functions::*;
+    private import memo_assurance_human_factors::*;
+
+    enum def UIElementFormKind {
+        enum button;
+        enum field;
+        enum selector;
+        enum knob;
+        enum switchControl;
+        enum slider;
+        enum table;
+        enum chart;
+        enum icon;
+        enum indicatorLamp;
+        enum audibleIndicator;
+        enum hapticIndicator;
+        enum textMessage;
+    }
+
+    // The interaction intents a step or action can carry (§18).
+    enum def InteractionIntentKind {
+        enum userInput;
+        enum feedback;
+        enum navigation;
+        enum confirmation;
+        enum inputValidation;
+        enum errorMessage;
+        enum alarmAnnunciation;
+        enum acknowledgement;
+        enum cancellation;
+        enum timeout;
+        enum lockout;
+        enum correction;
+        enum recovery;
+    }
+
+    part def UserInterface specializes ArchitectureElement {
+        attribute modality : String;
+        attribute uiTechnology : String;
+    }
+
+    part def UIContainer specializes ArchitectureElement {
+        attribute containerKind : String;
+        attribute navigationRole : String;
+    }
+
+    // One UIElement. The widget form — screen (field/table/chart) or physical
+    // (knob/switch/indicatorLamp/haptic) — is the `formKind` enum, not a
+    // subclass. Input/output/navigation/alarm/display/physical-control
+    // descriptors are optional attributes; a physical control's mechanical
+    // realization is a hardware part linked by ControlImplementedBy.
+    part def UIElement specializes ArchitectureElement {
+        attribute formKind : UIElementFormKind;
+        attribute labelText : String;
+        attribute accessibilitySummary : String;
+        // input descriptors (optional)
+        attribute inputConstraints : String;
+        attribute defaultValue : String;
+        // output / display descriptors (optional)
+        attribute updateRate : String;
+        attribute unitsDisplayed : String;
+        attribute informationContent : String;
+        // navigation (optional)
+        attribute navigationTarget : String;
+        // alarm annunciation (optional)
+        attribute alarmPriority : NotificationPriorityKind[0..1];
+        attribute annunciationModality : String;
+        attribute silenceable : Boolean;
+        // physical control (optional)
+        attribute actuationForce : String;
+        attribute guardedAgainstInadvertentActuation : Boolean;
+    }
+
+    // UI state is presentation state — distinct from system/device state.
+    part def UIState specializes ArchitectureElement {
+        attribute displayedInformation : String;
+        attribute availableActions : String;
+    }
+    part def UIEvent specializes ArchitectureElement {
+        attribute eventSource : String;
+        attribute intent : InteractionIntentKind;
+    }
+
+    action def UIAction specializes MemoAction {
+        attribute intent : InteractionIntentKind;
+        attribute feedbackProvided : String;
+        attribute confirmationRequired : Boolean;
+    }
+
+    // A reusable dialogue structure through the UI; a selected path through
+    // it is an UIScenario.
+    action def InteractionFlow specializes MemoAction {
+        attribute entryPoint : String;
+        attribute exitPoint : String;
+    }
+
+    part def UIScenario specializes MemoScenario {
+        ref parentFlow : InteractionFlow[0..1];
+    }
+
+    connection def UITransition :> MemoRelationship {
+        attribute triggeringEvent : String;
+        attribute guardCondition : String;
+        end sourceState : UIState;
+        end targetState : UIState;
+    }
+    connection def DataBinding :> MemoRelationship {
+        attribute bindingExpression : String;
+        attribute refreshPolicy : String;
+        end boundElement : UIElement;
+        end dataSource : MemoPart;
+    }
+    connection def PresentsState :> MemoRelationship {
+        end userInterface : UserInterface;
+        end state : UIState;
+    }
+
+    // ── §18 traceability ─────────────────────────────────────────
+    connection def ElementTriggersAction :> MemoRelationship {
+        end element : UIElement;
+        end triggeredAction : UIAction;
+    }
+    connection def ActionInvokesFunction :> MemoRelationship {
+        end uiAction : UIAction;
+        end systemFunction : SystemFunction;
+    }
+    connection def FlowServesUseCase :> MemoRelationship {
+        end interactionFlow : InteractionFlow;
+        end useCase : UseCase;
+    }
+    // The UI-layer scenario realizes exactly one FunctionalScenario one layer
+    // up (the interaction sequence that carries out the function sequence),
+    // completing the OperativeScenario → FunctionalScenario → UIScenario chain.
+    connection def ErrorAtElement :> MemoRelationship {
+        end useError : UseError;
+        end element : UIElement;
+    }
+    // A risk control implemented by a UI element or by task design
+    // (confirmation dialog, lockout, guarded control).
+    connection def ControlImplementedBy :> MemoRelationship {
+        end riskControl : VerifiableElement;
+        end implementingElement : ArchitectureElement;
+    }
+}