@memoarchitect/ontology 0.4.4

package/src/core/relationships/memo_relationships.sysml

@@ -0,0 +1,230 @@
+package memo_core_relationships {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    // All MEMO relations are native SysML v2 `connection def`s (each is a
+    // Connection/Association), specializing the SemanticLink base. The
+    // relationship name is the verb; the RelationshipRegistry derives the
+    // navigable type as camelCase(name) and navigation is bidirectional.
+    abstract connection def SemanticLink { attribute linkStatus : LinkStatusKind; }
+
+    connection def DerivesFrom :> SemanticLink {
+        // Drivers include needs and hazards (ISO 14971: hazards drive
+        // requirements), so the source stays at TraceableElement
+        end sourceDriver : TraceableElement;
+        end targetRequirement : VerifiableElement;
+    }
+    connection def SatisfiedBy :> SemanticLink {
+        end requiredElement : VerifiableElement;
+        end satisfyingElement : ArchitectureElement;
+    }
+    connection def MitigatesHazard :> SemanticLink {
+        end riskControl : VerifiableElement;
+        end mitigatedHazard : TraceableElement;
+    }
+    connection def AllocatedTo :> SemanticLink {
+        end function : ArchitectureElement;
+        end allocatedElement : ArchitectureElement;
+    }
+    connection def RealizesInterface :> SemanticLink {
+        end logicalInterface : InterfaceElement;
+        end physicalInterface : InterfaceElement;
+    }
+    connection def VerifiedBy :> SemanticLink {
+        // Requirements, risk controls, and architecture components are
+        // all legitimate verification targets
+        end verificationTarget : TraceableElement;
+        end verificationCase : VerifiableElement;
+    }
+    connection def ProducesEvidence :> SemanticLink {
+        end producer : VerifiableElement;
+        end producedEvidence : EvidenceElement;
+    }
+    connection def IncludedIn :> SemanticLink {
+        end sourceElement : TraceableElement;
+        end targetView : TraceableElement;
+    }
+    connection def Precedes :> SemanticLink {
+        attribute sameStepRequired : Boolean;
+        attribute precedenceRationale : String;
+        end predecessor : ArchitectureElement;
+        end successor : ArchitectureElement;
+    }
+    connection def ResolvesToMethodology :> SemanticLink {
+        end boundModelElement : TraceableElement;
+        end resolvedMethodology : TraceableElement;
+    }
+
+    // ISO 14971 risk chain — distinct sequence-of-events relations over risk elements.
+    connection def TracesRisk :> SemanticLink {
+        end sourceRiskElement : TraceableElement;
+        end targetRiskElement : TraceableElement;
+    }
+    connection def AssessedAgainst :> SemanticLink {
+        end risk : TraceableElement;
+        end riskMatrix : TraceableElement;
+    }
+
+    connection def ThreatenedBy :> SemanticLink {
+        attribute threatRole : String;
+        end protectedAsset : ArchitectureElement;
+        end realizedThreat : RequirementDriver;
+    }
+    connection def Exploits :> SemanticLink {
+        end realizedThreat : RequirementDriver;
+        end enablingVulnerability : TraceableElement;
+    }
+    connection def RealizedByScenario :> SemanticLink {
+        end realizedThreat : RequirementDriver;
+        end scenario : TraceableElement;
+    }
+    connection def MitigatesVulnerability :> SemanticLink {
+        end enablingVulnerability : TraceableElement;
+        end mitigation : VerifiableElement;
+    }
+    connection def DerivesCyberRequirement :> SemanticLink {
+        end sourceThreatOrRisk : RequirementDriver;
+        end targetRequirement : VerifiableElement;
+    }
+    connection def ImpactsSafety :> SemanticLink {
+        attribute tracePurpose : String;
+        end cyberElement : TraceableElement;
+        end safetyElement : TraceableElement;
+    }
+    connection def CrossesTrustBoundary :> SemanticLink {
+        attribute crossingKind : InterfaceKind;
+        end boundary : InterfaceElement;
+        end crossingItem : TraceableElement;
+    }
+
+    connection def DerivesInto :> SemanticLink {
+        end parentRequirement : VerifiableElement;
+        end childRequirement : VerifiableElement;
+    }
+    connection def DeploysOnto :> SemanticLink {
+        attribute deploymentKind : DeploymentKind;
+        end softwareComponent : ArchitectureElement;
+        end hostAssembly : ArchitectureElement;
+    }
+    connection def Validates :> SemanticLink {
+        end validationTarget : VerifiableElement;
+        end validationCase : VerifiableElement;
+    }
+    connection def DependsOnSoup :> SemanticLink {
+        end component : ArchitectureElement;
+        end soupItem : TraceableElement;
+    }
+
+    // Performs, ContributesToCapability, SequencesStep, DerivesSystemNeed
+    // (operational-entity ends) and RealizesCapability, InvolvesFunction,
+    // RealizesScenario (functional-chain ends) live in their owning
+    // architecture layer packages — memo::architecture::operational and
+    // memo::architecture::system respectively — because core must not
+    // depend on architecture-layer types. See memo_operational.sysml and
+    // memo_system_analysis.sysml.
+
+    connection def HostedBy :> SemanticLink {
+        end processingNode : ArchitectureElement;
+        end hostAssembly : ArchitectureElement;
+    }
+    connection def RealizesComponentExchange :> SemanticLink {
+        end physicalLink : ArchitectureElement;
+        end componentExchange : ArchitectureElement;
+    }
+
+    connection def HasFailureMode :> SemanticLink {
+        end element : ArchitectureElement;
+        end failureMode : TraceableElement;
+    }
+    connection def CausesEffect :> SemanticLink {
+        end failureMode : TraceableElement;
+        end failureEffect : TraceableElement;
+    }
+    connection def CausedBy :> SemanticLink {
+        end failureMode : TraceableElement;
+        end failureCause : TraceableElement;
+    }
+    connection def DetectedBy :> SemanticLink {
+        end failureMode : TraceableElement;
+        end detectionMethod : TraceableElement;
+    }
+    connection def AddressedByAction :> SemanticLink {
+        end failureMode : TraceableElement;
+        end fmeaAction : VerifiableElement;
+    }
+
+    connection def InputToGate :> SemanticLink {
+        end input : TraceableElement;
+        end gate : TraceableElement;
+    }
+    connection def ProducesEvent :> SemanticLink {
+        end gate : TraceableElement;
+        end eventElement : TraceableElement;
+    }
+    connection def OriginatesFrom :> SemanticLink {
+        end eventElement : TraceableElement;
+        end origin : ArchitectureElement;
+    }
+    connection def ContainsEvent :> SemanticLink {
+        end cutSet : TraceableElement;
+        end eventElement : TraceableElement;
+    }
+
+    connection def Decides :> SemanticLink {
+        end decision : TraceableElement;
+        end affectedElement : TraceableElement;
+    }
+
+    connection def Composes :> SemanticLink {
+        end parent : ArchitectureElement;
+        end child : ArchitectureElement;
+    }
+    connection def AllocatesExchange :> SemanticLink {
+        end functionalFlow : ArchitectureElement;
+        end componentExchange : ArchitectureElement;
+    }
+
+    connection def ContributesToHazard :> SemanticLink {
+        end failureMode : TraceableElement;
+        end hazard : TraceableElement;
+    }
+    connection def LeadsToHazard :> SemanticLink {
+        end topEvent : TraceableElement;
+        end hazard : TraceableElement;
+    }
+    connection def IdentifiesHazard :> SemanticLink {
+        end deviation : TraceableElement;
+        end hazard : TraceableElement;
+    }
+    connection def AnalyzedBy :> SemanticLink {
+        end element : ArchitectureElement;
+        end analysisArtifact : TraceableElement;
+    }
+    connection def MitigatedByControl :> SemanticLink {
+        end failureMode : TraceableElement;
+        end riskControl : VerifiableElement;
+    }
+    connection def BrokenByControl :> SemanticLink {
+        end cutSet : TraceableElement;
+        end riskControl : VerifiableElement;
+    }
+
+    connection def Changes :> SemanticLink {
+        end changeRequest : TraceableElement;
+        end changedElement : TraceableElement;
+    }
+    connection def TestedByUsability :> SemanticLink {
+        end uiElementOrTask : TraceableElement;
+        end usabilityTest : VerifiableElement;
+    }
+    connection def FeedsBackTo :> SemanticLink {
+        end feedbackItem : TraceableElement;
+        end designElement : TraceableElement;
+    }
+    connection def BindsToInterface :> SemanticLink {
+        end portElement : InterfaceElement;
+        end boundInterface : InterfaceElement;
+    }
+}

package/src/core/semantics/semantics.sysml

@@ -0,0 +1,20 @@
+// Semantic-metadata definitions (SysML v2 `metadata def`) — the standard, portable
+// mechanism for extending the MEMO ontology with domain semantics. Downstream models
+// extend MEMO by importing the ontology library and either specializing its kinds or
+// applying these metadata defs with `@Name` — never by adding new grammar.
+package memo_core_semantics {
+    private import ScalarValues::*;
+
+    // Tags an element with the regulatory standard it derives from
+    // (e.g. ISO 14971, IEC 62304, ISO/IEC/IEEE 42010).
+    metadata def StandardReference {
+        attribute standardReference : String;
+        attribute clause : String;
+    }
+
+    // Marks an element as the rationale/provenance carrier for a decision.
+    metadata def Provenance {
+        attribute source : String;
+        attribute rationale : String;
+    }
+}

package/src/core/stdlib/collections.sysml

@@ -0,0 +1,6 @@
+// Re-export-only wrapper per ADR-1-13. No new types.
+package memo_core_stdlib_collections {
+    private import ScalarValues::*;
+
+    public import Collections::*;
+}

package/src/core/stdlib/functions.sysml

@@ -0,0 +1,6 @@
+// Re-export-only wrapper per ADR-1-13. No new types.
+package memo_core_stdlib_functions {
+    private import ScalarValues::*;
+
+    public import BaseFunctions::*;
+}

package/src/core/stdlib/scalars.sysml

@@ -0,0 +1,6 @@
+// Re-export-only wrapper per ADR-1-13. No new types.
+package memo_core_stdlib_scalars {
+    private import ScalarValues::*;
+
+    public import ScalarValues::*;
+}

package/src/core/stdlib/time.sysml

@@ -0,0 +1,6 @@
+// Re-export-only wrapper per ADR-1-13. No new types.
+package memo_core_stdlib_time {
+    private import ScalarValues::*;
+
+    public import Time::*;
+}

package/src/medical_device_library.sysml

@@ -0,0 +1,100 @@
+package memo_medical_device_library {
+    private import ScalarValues::*;
+
+    public import memo_core_enumerations::*;
+    public import memo_core_common::*;
+    public import memo_core_relationships::*;
+
+    public import memo_architecture_context::*;
+    public import memo_architecture_operational::*;
+    public import memo_architecture_system::*;
+    public import memo_architecture_requirements::*;
+    public import memo_architecture_functions::*;
+    public import memo_architecture_logical_structure::*;
+    public import memo_architecture_interfaces::*;
+    public import memo_architecture_behavior::*;
+    public import memo_architecture_software_structure::*;
+    public import memo_architecture_hardware_structure::*;
+    public import memo_architecture_constraints::*;
+    public import memo_architecture_risk_risk::*;
+    public import memo_architecture_cybersecurity::*;
+    public import memo_architecture_assurance::*;
+    public import memo_architecture_physical::*;
+    public import memo_architecture_analysis::*;
+    public import memo_architecture_decisions::*;
+
+    public import memo_viewpoints_definitions::*;
+
+    public import memo_viewpoints_context_context_viewpoint::*;
+    public import memo_viewpoints_context_system_context_view::*;
+
+    public import memo_viewpoints_operational_operational_viewpoint::*;
+    public import memo_viewpoints_operational_use_case_view::*;
+
+    public import memo_viewpoints_requirements_requirements_viewpoint::*;
+    public import memo_viewpoints_requirements_requirements_traceability_view::*;
+
+    public import memo_viewpoints_functional_functional_viewpoint::*;
+    public import memo_viewpoints_functional_system_functional_tree_view::*;
+    public import memo_viewpoints_functional_function_allocation_view::*;
+
+    public import memo_viewpoints_logical_logical_viewpoint::*;
+    public import memo_viewpoints_logical_logical_architecture_view::*;
+
+    public import memo_viewpoints_software_software_viewpoint::*;
+    public import memo_viewpoints_software_software_architecture_view::*;
+
+    public import memo_viewpoints_physical_physical_viewpoint::*;
+    public import memo_viewpoints_physical_physical_bom_view::*;
+    public import memo_viewpoints_physical_network_topology_view::*;
+
+    public import memo_viewpoints_risk_risk_viewpoint::*;
+    public import memo_viewpoints_risk_risk_chain_view::*;
+
+    public import memo_viewpoints_verification_verification_viewpoint::*;
+    public import memo_viewpoints_verification_verification_coverage_view::*;
+
+    public import memo_viewpoints_cybersecurity_cybersecurity_viewpoint::*;
+    public import memo_viewpoints_cybersecurity_threat_model_view::*;
+    public import memo_viewpoints_cybersecurity_cybersecurity_assessment_view::*;
+
+    public import memo_viewpoints_clinical_clinical_viewpoint::*;
+    public import memo_viewpoints_clinical_clinical_evidence_view::*;
+
+    public import memo_viewpoints_usability_usability_viewpoint::*;
+    public import memo_viewpoints_usability_usability_engineering_view::*;
+
+    public import memo_artifacts_definitions::*;
+    public import memo_artifacts_risk_management_plan::*;
+    public import memo_artifacts_requirements_specification::*;
+    public import memo_artifacts_system_architecture_description::*;
+    public import memo_artifacts_software_design_description::*;
+    public import memo_artifacts_hazard_analysis_report::*;
+    public import memo_artifacts_requirements_traceability_matrix::*;
+    public import memo_artifacts_test_protocol::*;
+    public import memo_artifacts_test_report::*;
+    public import memo_artifacts_evidence_record::*;
+    public import memo_artifacts_cybersecurity_assessment_report::*;
+    public import memo_artifacts_threat_model_report::*;
+    public import memo_artifacts_usability_engineering_report::*;
+    public import memo_artifacts_clinical_safety_report::*;
+    public import memo_artifacts_failure_mode_effects_analysis::*;
+    public import memo_artifacts_soup_list::*;
+    public import memo_artifacts_design_input_plan::*;
+    public import memo_artifacts_design_output_plan::*;
+    public import memo_artifacts_software_development_plan::*;
+    public import memo_artifacts_labeling_specification::*;
+    public import memo_artifacts_design_history_file_index::*;
+    public import memo_artifacts_design_change_log::*;
+    public import memo_compliance_artifacts::*;
+    public import memo_compliance_change::*;
+    public import memo_compliance_postmarket::*;
+
+    public import memo_methodology_core::*;
+    public import memo_methodology_viewpoints::*;
+    public import memo_methodology_rules::*;
+    public import memo_methodology_patterns::*;
+    public import memo_methodology_workflow::*;
+    public import memo_methodology_gates::*;
+    public import memo_methodology_profiles::*;
+}