@memoarchitect/ontology 0.12.1 → 0.15.0

package/src/architecture/operational/scenarios/memo_scenarios.sysml

@@ -1,8 +1,8 @@
-// Scenario foundation. A scenario is a selected path through a
-// workflow (or functional flow), classified by its kind plus three independent
-// dimensions — variant, operational condition, and purpose. An occurrence is an actual or hypothetical execution
-// of a scenario. Alternate scenarios reference their base scenario and
-// variation point instead of duplicating the workflow.
+// Scenario foundation. A scenario is a selected path through a workflow,
+// classified by its kind (nominal or alternate). It is nested in the workflow
+// it is a path through, so a nominal scenario and its alternates are siblings
+// there. An actual or hypothetical execution is a native usage of the
+// scenario, not a separate element.
 package memo_architecture_operational_scenarios {
     private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
@@ -32,9 +32,10 @@ package memo_architecture_operational_scenarios {
         attribute postCondition : String;
         attribute pathSummary : String;
 
-        // The workflow this scenario belongs to is expressed by the workflow
-        // (HasScenario); a nominal/alternate pair are scenarios of the same
-        // workflow, distinguished by scenarioKind — no baseScenario back-ref.
+        // The workflow this scenario belongs to is the one it is nested in
+        // (a `HasScenario` relation was removed for that reason); a
+        // nominal/alternate pair are scenarios of the same workflow,
+        // distinguished by scenarioKind — no baseScenario back-ref.
         // Actors are derived from `perform` on the nested steps, not listed.
         ref useContext : UseContext[0..1];
         // threat scenario

package/src/architecture/operational/structure/memo_operational.sysml

@@ -11,8 +11,11 @@ package memo_architecture_operational_structure {
     // purpose and the root of the operational spine. A MemoMission, because
     // "mission" has no medical-device meaning — intended use is what a device
     // exists to do. Was in memo_assurance_requirements; moved here as the
-    // operational-world root.
-    part def IntendedUse specializes MemoMission {
+    // operational-world root. It is a `requirement def`: the intended use is
+    // the top obligation the device's design inputs derive from, and ISO 14971
+    // 5.2 asks for it to be documented as the starting point of risk analysis.
+    // It was a `part def`, which made it a structural thing.
+    requirement def IntendedUse :> MemoMission {
         attribute indication : String;
         attribute contraindication : String;
         attribute patientPopulation : String;

package/src/architecture/operational/use_cases/memo_use_cases.sysml

@@ -35,17 +35,24 @@ package memo_architecture_operational_use_cases {
         attribute postCondition : String;
         // clinical / service / manufacturing / development
         attribute useCaseKind : UseCaseKind;
+        // A system use case that no clinical use case includes is a finding (rule CR-ONT-086)
+        // unless it says so: set this for a use case that is deliberately carried out alone,
+        // such as a service procedure. It is not a second kind of use case.
+        attribute standalone : Boolean;
 
         // The device or system under consideration supports the goal. Native
-        // `subject`, not `ref` (R10-S6): SysIDE requires an explicit subject
-        // before a use case can declare `actor` — `case-usage-subject-
-        // parameter-position` — and "the device/system under consideration"
+        // `subject`, not `ref` (R10-S6): a use case needs an explicit subject
+        // before it can declare `actor` (the subject parameter comes first),
+        // and "the device/system under consideration"
         // is exactly what a case's subject means, so this was a duplicate
         // waiting to surface once `actor` needed a subject to attach to.
         subject supportingSystem : MemoPart[0..1];
-        ref primaryUser : User[0..1];
-        ref supportingActors : OperationalParticipant[0..*];
         ref useContext : UseContext[0..1];
+        // Who takes part is native `actor` (`actor <role> = <participant>;`),
+        // inherited from `UseCases::UseCase`. `primaryUser` and
+        // `supportingActors` refs stood here as a second way of saying the
+        // same thing and were removed; which actor initiates is carried by
+        // the actor's name, as the note on `Initiates` below says.
     }
 
     connection def Motivates :> MemoRelationship {
@@ -65,7 +72,8 @@ package memo_architecture_operational_use_cases {
     // named on the use case, not in a relationship type. Write
     // `actor <role> = <existingElement>;` inside the use case instead.
     // UML use-case decomposition (`Includes`) is native `include use case` /
-    // `include` (R10-S6); write that instead of a connection here. `extends`
-    // has 0 hits in the corpus for a use-case `extend` production, so it stays
-    // a MEMO construct: a cross-cutting relationship that is always presented.
+    // `include` (R10-S6); write that instead of a connection here. SysML v2
+    // has no use-case `extend` (the textual BNF defines IncludeUseCaseUsage
+    // and nothing for extend), and MEMO does not add one: an optional path
+    // through a use case is an alternate scenario, not a second use case.
 }

package/src/architecture/realization/deployment/memo_deployment.sysml

@@ -20,7 +20,7 @@ package memo_architecture_realization_deployment {
     private import memo_core_relationships::*;
     private import memo_architecture_implementation_software_structure::*;
     private import memo_architecture_implementation_software_runtime::*;
-    private import memo_architecture_implementation_hardware_electrical::*;   // NetworkMedium
+    private import memo_architecture_implementation_hardware_common::PhysicalComponent;
     private import memo_architecture_realization_physical::*;
     private import memo_architecture_functional_functions::*;
     private import memo_architecture_logical_structure::*;
@@ -52,6 +52,24 @@ package memo_architecture_realization_deployment {
         :> annotatedElement : SysML::AllocationDefinition;
         :> annotatedElement : SysML::AllocationUsage;
         :>> baseType = buildsIntoLinks meta SysML::Usage;
+    }
+    // A logical component is REALIZED BY the hardware or software that implements it. The
+    // logical and the implementation architectures are separate structures and stay
+    // separate: nothing is nested (a logical component never contains software or a
+    // physical part, CR-ONT-078); the two are joined by an allocation, as the language
+    // joins structures across domains (SysML-textual-bnf.kebnf:792-801, AllocationDefinition and AllocationUsage) and as SYSMOD
+    // does with its `logical2product` allocation, logical architecture to product
+    // architecture, logical as the source. The target is any part, as HostedBy's ends are:
+    // a hardware assembly and a software system are both MemoParts.
+    allocation def RealizedBy :> MemoRelationship, Allocations::Allocation {
+        end logicalComponent : LogicalComponent :>> source;
+        end realization : MemoPart :>> target;
+    }
+    abstract connection realizedByLinks : RealizedBy[*];
+    metadata def <realizedBy> RealizedByMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::AllocationDefinition;
+        :> annotatedElement : SysML::AllocationUsage;
+        :>> baseType = realizedByLinks meta SysML::Usage;
     }
         // Every usage of this already writes `allocation x : DeploysTo allocate a
     // to b;` -- the declaration was the only part still saying `connection`.
@@ -92,7 +110,7 @@ package memo_architecture_realization_deployment {
     // language says so. The double specialization keeps MEMO's identification
     // core from `MemoRelationship` while adding the standard's allocation
     // semantics; both root on `Connections::BinaryConnection`, so this is a
-    // diamond and not a conflict. Verified under `syside check` against a
+    // diamond and not a conflict. Verified with a SysML v2 compiler against a
     // negative control (a non-existent supertype is reported), so the clean
     // result is the checker agreeing rather than the checker skipping.
 
@@ -111,17 +129,19 @@ package memo_architecture_realization_deployment {
         :>> baseType = memoryBindingLinks meta SysML::Usage;
     }
 
-    // AADL `actual_connection_binding`. Which physical medium carries a
-    // component exchange. The source is the ComponentExchange rather than the
-    // `ComponentConnects` link, because the exchange is the ELEMENT that owns
-    // the budget (§19.3) and a link instance is not something the graph can
-    // bind to; it is also exactly where the latency the medium contributes has
-    // to be accounted.
+    // AADL `actual_connection_binding`. Which physical thing carries an
+    // interface: a network medium under a component exchange, a cable or
+    // harness under a hardware `Interface`, a connector, a tube. The source is
+    // the interface usage rather than a link, because the interface is the
+    // ELEMENT that owns the budget (§19.3) and a link instance is not
+    // something the graph can bind to; it is also exactly where the latency
+    // the medium contributes has to be accounted. Ends are the two bases
+    // (MemoInterface, PhysicalComponent) so one binding serves every layer.
     allocation def ConnectionBinding :> MemoRelationship, Allocations::Allocation {
         attribute allocatedBandwidth : String;
         attribute mediumLatencyMs : Real;
-        end boundExchange : ComponentExchange :>> source;
-        end medium : NetworkMedium :>> target;
+        end boundExchange : MemoInterface :>> source;
+        end medium : PhysicalComponent :>> target;
     }
     abstract connection connectionBindingLinks : ConnectionBinding[*];
     metadata def <connectionBinding> ConnectionBindingMetadata :> SemanticMetadata {

package/src/architecture/realization/memo_architecture_realization.sysml

@@ -0,0 +1,13 @@
+// The realization (deployment and physical) layer as one package.
+//
+// A layer is a namespace of packages: every package whose name begins
+// `memo_architecture_realization_`. This package publicly imports each of them, so
+// `public import memo_architecture_realization::*;` in a methodology's package selects the whole
+// layer, and the same import in any package makes the layer's definitions
+// visible. It declares nothing of its own. test/package.test.mjs holds the list
+// to exactly the packages in the namespace, so a package added to the layer is
+// selected with it.
+package memo_architecture_realization {
+    public import memo_architecture_realization_deployment::*;
+    public import memo_architecture_realization_physical::*;
+}

package/src/architecture/realization/physical/memo_physical_architecture.sysml

@@ -6,6 +6,7 @@ package memo_architecture_realization_physical {
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
+    private import memo_architecture_logical_interfaces::Interface;
     // For PhysicalElement: a processing node and a memory device ARE physical
     // things — a board and a chip — and specialized MemoPart directly only
     // because the physical family had no shared root until CR-ONT-079 needed
@@ -58,4 +59,64 @@ package memo_architecture_realization_physical {
         attribute portCategory : PortCategoryKind;
         attribute connectorType : String;
     }
+
+    // ─── Connecting hardware ─────────────────────────────────────────────
+    //
+    // Hardware is parts with ports. A port on one part is joined to a port on
+    // another by a PhysicalInterface, and what crosses it is a PhysicalFlow.
+    // They are the hardware-layer counterparts of LogicalInterface and
+    // LogicalExchange, and of SoftwareInterface: the same shape, but each
+    // states only what its layer can, so a hardware interface is never
+    // described in terms of a software API or a logical content kind.
+    //
+    // The interface is the CONTRACT (an `interface` usage joins two specific
+    // ports; the def says what kind of link it is). The plug, cable, header
+    // or tube that physically carries it is a part of its own (Cable,
+    // PhysicalConnectorPart, ...), related to the interface by a
+    // ConnectionBinding allocation. PhysicalPort.connectorType names what a
+    // port exposes.
+    //
+    //     part pump {
+    //         out port pMotorDrive : PhysicalPort { out item drive; }
+    //     }
+    //     part driver {
+    //         in port pMotorIn : PhysicalPort { in item drive; }
+    //     }
+    //     part motorHarness : Cable;
+    //     interface cnMotorDrive : PhysicalInterface
+    //         connect pump.pMotorDrive to driver.pMotorIn {
+    //         attribute :>> signalingKind = SignalingKind::pulse;
+    //         attribute :>> nominalVoltageV = 3.3;
+    //     }
+    //     flow flMotorDrive : PhysicalFlow
+    //         from pump.pMotorDrive.drive to driver.pMotorIn.drive {
+    //         attribute :>> quantity = "step pulses";
+    //     }
+    //     allocation cbMotorDrive : ConnectionBinding
+    //         allocate cnMotorDrive to motorHarness;
+    interface def PhysicalInterface specializes Interface {
+        // analog, digital, discrete, pulse or power transfer. Fill in the
+        // descriptors that kind needs: a range for analog, a bit rate and
+        // protocol for digital, a frequency for pulse.
+        attribute signalingKind : SignalingKind;
+        attribute mediumKind : PhysicalMediumKind;
+        attribute electricalStandard : String;
+        attribute nominalVoltageV : Real[0..1];
+        attribute nominalCurrentA : Real[0..1];
+        attribute bitRateBps : String;
+        attribute signalRange : String;
+        attribute connectorStandard : String;
+        end sourcePort : PhysicalPort;
+        end targetPort : PhysicalPort;
+    }
+
+    // What crosses a physical interface, as a quantity: a voltage, a
+    // current, a pressure, a force, a flow of fluid.
+    abstract flow def PhysicalFlow {
+        attribute quantity : String;
+        attribute unit : String;
+        attribute nominalValue : String;
+        attribute minValue : String;
+        attribute maxValue : String;
+    }
 }

package/src/architecture/variability/memo_variability.sysml

@@ -0,0 +1,87 @@
+// Features and design options.
+//
+// A design option is native SysML: a `variation` (a definition or a usage whose
+// body holds only `variant` members; SysML-textual-bnf.kebnf:224 for the definition
+// prefix, :282 for the usage prefix, :254-256 the variant member). MEMO adds
+// nothing to how one is written. What SysML has no word for is WHY a variant exists
+// and WHICH ones go together: that is a product feature.
+//
+//   part featEuMarket : ProductFeature;                    // the market EU releases target
+//   variation part energyOutput : LogicalComponent {
+//       variant part euOutput : LogicalComponent;          // a variant, for the EU
+//       variant part usOutput : LogicalComponent;
+//   }
+//   #RealizesFeature dependency from energyOutput::euOutput to featEuMarket;
+//   connection : RequiresFeature connect ...               // one feature needs another
+//
+// A release selects features (`#SelectsFeature`), and through them the variants it
+// contains; a rule counts one variant per variation point from that. A feature is
+// a usage like any other part, named by the family, and a platform package may
+// declare the family's features once.
+//
+// A variation point cannot own attributes: SysIDE rejects an owned feature in a
+// variation (`usage-variation-owned-feature-membership`). Identity metadata is an
+// annotation and is allowed (measured on E0, 2026-10-13); `status` and anything else
+// a variation point would carry goes on its variants.
+package memo_architecture_variability {
+    private import Metaobjects::SemanticMetadata;
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+
+    // Named ProductFeature, not Feature: `Feature` is the KerML metaclass, and the
+    // builder falls back to a metaclass name for a kind it cannot place.
+    //
+    // A feature's page is what is said about it: its prose is the element's `doc`, and
+    // the analysis is these four statements, each optional until someone has an answer.
+    // What the feature shows is curated: `#ShowsView` below names its views.
+    part def ProductFeature specializes MemoPart {
+        /** What the feature gives the people who use the product, in a sentence or two. */
+        attribute valueProposition : String[0..1];
+        /** Who it is for: the roles or segments that gain from it. */
+        attribute targetUsers : String[0..1];
+        /** How anyone will know it worked: the measure, and the level that counts as success. */
+        attribute successMeasure : String[0..1];
+        /** What has to hold for the value to be real, and what is not yet known. */
+        attribute assumptions : String[0..1];
+    }
+
+    // `Requires` is taken by the native `require` relation, so these say what they join.
+    connection def RequiresFeature :> MemoRelationship {
+        doc /* Selecting the source feature needs the target feature selected too. */
+        end dependentFeature : ProductFeature :>> source;
+        end requiredFeature : ProductFeature :>> target;
+    }
+    abstract connection requiresFeatureLinks : RequiresFeature[*];
+    metadata def <requiresFeature> RequiresFeatureMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = requiresFeatureLinks meta SysML::Usage;
+    }
+
+    connection def ExcludesFeature :> MemoRelationship {
+        doc /* The two features cannot be selected together. Symmetric: either end may be written first. */
+        end firstFeature : ProductFeature :>> source;
+        end secondFeature : ProductFeature :>> target;
+    }
+    abstract connection excludesFeatureLinks : ExcludesFeature[*];
+    metadata def <excludesFeature> ExcludesFeatureMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = excludesFeatureLinks meta SysML::Usage;
+    }
+
+    // Typed dependencies (memo_core_relationships::MemoTypedDependency): the variant
+    // is nested in its variation, so it is a dependency's client by qualified name.
+    metadata def RealizesFeature :> MemoTypedDependency {
+        doc /* `#RealizesFeature dependency from <variant> to <feature>;` The variant exists to give the family this feature. */
+    }
+    metadata def SelectsFeature :> MemoTypedDependency {
+        doc /* `#SelectsFeature dependency from <release> to <feature>, <feature>;` The release contains the variants that realize these features. */
+    }
+    metadata def ShowsView :> MemoTypedDependency {
+        doc /* `#ShowsView dependency from <feature> to <view>, <view>;` The views the feature's viewpoint lists: chosen for what the feature demonstrates, not found by a rule. */
+    }
+}

package/src/artifacts/configuration_management/memo_configuration_management.sysml

@@ -10,15 +10,107 @@ package memo_artifacts_configuration_management {
         attribute changeType : ChangeTypeKind;
         attribute impactAssessment : String;
         attribute approvalStatus : String;
-        attribute affectedBaseline : String;
+        // The release a change affects is `#AffectsRelease dependency from <request> to <record>;`
+        // (below), not a string naming a baseline.
     }
 
     part def ConfigurationItem :> MemoPart {
-        attribute version : String;
-        attribute baseline : String;
+        // No version and no baseline: both belong to a release of the item, not to the item
+        // (plan O2). A `ReleaseRecord` whose `#ReleaseOf` is this item carries them.
         attribute controlLevel : String;
     }
 
+    // A release record is one release of one item: rev D and rev E of a part, or its EU and its US
+    // release, are separate records, each with its own part number and revision (plan O2). The
+    // definition of the item is held once and carries no revision. The record is an element with a
+    // status (inherited from MemoPart: proposed, draft, ... released), so a release moves through
+    // the lifecycle the way any element does.
+    //
+    //   part relPumpD : ReleaseRecord {
+    //       :>> partNumber = "PN-1001"; :>> revision = "D"; :>> modelCommit = "9f2c...";
+    //   }
+    //   #ReleaseOf dependency from relPumpD to PumpSystem;
+    //
+    // `softwareVersion` and `codeTag` are for an item that is software; a record of anything else
+    // leaves them out. The links are typed dependencies, because a record's item is a definition and
+    // a `ref` cannot point at one: a Dependency's client and supplier are any element
+    // (SysML-textual-bnf.kebnf:51-59), and the metadata prefix names the kind (`:52`).
+    //
+    // A release of a system of systems is the same record with a system of systems for its item. It
+    // `#Contains` the records of the system releases it pins, and is the validated configuration:
+    // `#VerifiedByCase` names the verification cases that validated it.
+    part def ReleaseRecord :> MemoPart {
+        attribute partNumber : String[1];
+        attribute revision : String[1];
+        attribute softwareVersion : String[0..1];
+        attribute codeTag : String[0..1];
+        // The commit of the model this release was built from. A record cannot hold the hash of the
+        // commit that adds it, so it is written after the commit it pins and is always found in a
+        // folder that is not itself pinned (`sos/`).
+        attribute modelCommit : String[1];
+    }
+
+    metadata def ReleaseOf :> MemoTypedDependency {
+        doc /* `#ReleaseOf dependency from <record> to <item definition>;` The record is a release of this item. One record, one item. */
+    }
+    metadata def Contains :> MemoTypedDependency {
+        doc /* `#Contains dependency from <record> to <record>, <record>;` The release pins these releases: a system of systems version its systems, a system release its components. */
+    }
+    metadata def Implements :> MemoTypedDependency {
+        doc /* `#Implements dependency from <record> to <interface record>;` The release implements this revision of an interface. */
+    }
+    metadata def VerifiedByCase :> MemoTypedDependency {
+        doc /* `#VerifiedByCase dependency from <record> to <verification case>;` The case that verified, or for a system of systems version validated, this release. `verifiedBy` is taken by the native relation from a requirement to its case. */
+    }
+    metadata def AffectsRelease :> MemoTypedDependency {
+        doc /* `#AffectsRelease dependency from <change request> to <record>;` The release a change request is raised against. */
+    }
+
+    // A regulated device is one approval in one jurisdiction (plan O6): the thing a regulator is asked to
+    // clear. It is not an item and not a release: it COVERS the system releases the approval names, so two
+    // markets can ship different releases of one system, each with its own design history and risk file.
+    //
+    //   part deviceFda : RegulatedDevice {
+    //       attribute :>> jurisdiction = RegulatoryRegimeKind::FDA_510k;
+    //       attribute :>> submissionId = "K123456";
+    //   }
+    //   #Covers dependency from deviceFda to relPumpD;
+    //
+    // The jurisdiction is a `RegulatoryRegimeKind`, the same enum the standards library and the document
+    // templates (`required_for`) are written against, so a device selects the standards it must meet and the
+    // documents it must have. It replaces `ModelMethodBinding.regulatoryRegime`, which stated one regime set
+    // for a whole model and is read only when the model declares no device.
+    //
+    // `IntendedUseOf` and `UsedWith` (plan O6) are not declared: the plan names no end for either, and an end
+    // is not invented to fill a name. `Covers` is the link every part of M5 needs.
+    part def RegulatedDevice :> MemoPart {
+        attribute jurisdiction : RegulatoryRegimeKind[1];
+        attribute submissionId : String[0..1];
+    }
+
+    metadata def Covers :> MemoTypedDependency {
+        doc /* `#Covers dependency from <device>, to <record>, <record>;` The approval covers these system releases. */
+    }
+
+    // A project is a change set in an iteration (plan O7): the work that produces releases. It holds a link to
+    // where the work is tracked and nothing else; the merge request is the approval. It FEEDS the release records
+    // it contributes to, and a variant records the project that introduced it, so "which work gave us this
+    // option, and which releases did it reach" is two links.
+    //
+    //   part prjIrrigatedTip : Project { attribute :>> trackerLink = "https://tracker.example/PRJ-12"; }
+    //   #Feeds dependency from prjIrrigatedTip to relGeneratorEu, relGeneratorUs;
+    //   #IntroducedBy dependency from outputStage::usOutput to prjIrrigatedTip;
+    part def Project :> MemoPart {
+        attribute trackerLink : String[0..1];
+    }
+
+    metadata def Feeds :> MemoTypedDependency {
+        doc /* `#Feeds dependency from <project> to <record>, <record>;` The project's work is in these releases. */
+    }
+    metadata def IntroducedBy :> MemoTypedDependency {
+        doc /* `#IntroducedBy dependency from <variant> to <project>;` The project that introduced this variant. */
+    }
+
     // ── Relations owned by this package ─────────────────────────────
     // Moved out of memo_core_relationships: their ends are typed against
     // types declared here, and core must not depend on a domain package.

package/src/artifacts/core/memo_controlled_artifacts.sysml

@@ -4,9 +4,11 @@ package memo_artifacts_core {
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
 
-    abstract item def MemoArtifactItem :> MemoItem;
+    // An artifact is a part: a document, a standard, a clause of one. A
+    // relationship end typed MemoArtifact (TracesToDocument) takes all of them.
+    abstract part def MemoArtifact :> MemoPart;
 
-    item def ControlledArtifact :> MemoArtifactItem {
+    part def ControlledArtifact :> MemoArtifact {
         attribute version : String;
         attribute artifactKind : ArtifactKind;
         attribute owner : String;

package/src/artifacts/standards/cfr_21_820.sysml

@@ -17,84 +17,72 @@ package memo_artifacts_standards_cfr_21_820 {
 
     private import memo_core_common::*;
     private import memo_core_common::MemoIdentity;
-    item cfr21Part820 : RegulatoryStandard {
+    part cfr21Part820 : RegulatoryStandard {
         @MemoIdentity { :>> providedId = "STD-21-CFR-820"; }
-        attribute :>> name = "CFR21Part820";
         attribute :>> designation = "21 CFR Part 820";
         attribute :>> issuer = "FDA";
         attribute :>> appliesToRegime = (RegulatoryRegimeKind::FDA_510k, RegulatoryRegimeKind::FDA_PMA);
-        item cfr820_30 : StandardClause {
+        part cfr820_30 : StandardClause {
             @MemoIdentity { :>> providedId = "STD-21-CFR-820-30"; }
-            attribute :>> name = "CFR820_30";
             attribute :>> clauseNumber = "820.30";
             attribute :>> title = "design controls";
             attribute :>> normativeStrength = "shall";
-            item cfr820_30a : StandardClause {
+            part cfr820_30a : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-A"; }
-                attribute :>> name = "CFR820_30a";
                 attribute :>> clauseNumber = "820.30(a)";
                 attribute :>> title = "general design control applicability";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30b : StandardClause {
+            part cfr820_30b : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-B"; }
-                attribute :>> name = "CFR820_30b";
                 attribute :>> clauseNumber = "820.30(b)";
                 attribute :>> title = "design and development planning";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30c : StandardClause {
+            part cfr820_30c : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-C"; }
-                attribute :>> name = "CFR820_30c";
                 attribute :>> clauseNumber = "820.30(c)";
                 attribute :>> title = "design input";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30d : StandardClause {
+            part cfr820_30d : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-D"; }
-                attribute :>> name = "CFR820_30d";
                 attribute :>> clauseNumber = "820.30(d)";
                 attribute :>> title = "design output";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30e : StandardClause {
+            part cfr820_30e : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-E"; }
-                attribute :>> name = "CFR820_30e";
                 attribute :>> clauseNumber = "820.30(e)";
                 attribute :>> title = "design review";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30f : StandardClause {
+            part cfr820_30f : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-F"; }
-                attribute :>> name = "CFR820_30f";
                 attribute :>> clauseNumber = "820.30(f)";
                 attribute :>> title = "design verification";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30g : StandardClause {
+            part cfr820_30g : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-G"; }
-                attribute :>> name = "CFR820_30g";
                 attribute :>> clauseNumber = "820.30(g)";
                 attribute :>> title = "design validation";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30h : StandardClause {
+            part cfr820_30h : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-H"; }
-                attribute :>> name = "CFR820_30h";
                 attribute :>> clauseNumber = "820.30(h)";
                 attribute :>> title = "design transfer";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30i : StandardClause {
+            part cfr820_30i : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-I"; }
-                attribute :>> name = "CFR820_30i";
                 attribute :>> clauseNumber = "820.30(i)";
                 attribute :>> title = "design changes";
                 attribute :>> normativeStrength = "shall";
             }
-            item cfr820_30j : StandardClause {
+            part cfr820_30j : StandardClause {
                 @MemoIdentity { :>> providedId = "STD-21-CFR-820-30-J"; }
-                attribute :>> name = "CFR820_30j";
                 attribute :>> clauseNumber = "820.30(j)";
                 attribute :>> title = "design history file";
                 attribute :>> normativeStrength = "shall";

package/src/artifacts/standards/fda_cybersecurity_2023.sysml

@@ -20,51 +20,44 @@ package memo_artifacts_standards_fda_cybersecurity_2023 {
 
     private import memo_core_common::*;
     private import memo_core_common::MemoIdentity;
-    item fdaCybersecurity2023 : RegulatoryStandard {
+    part fdaCybersecurity2023 : RegulatoryStandard {
         @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023"; }
-        attribute :>> name = "FDACybersecurity2023";
         attribute :>> designation = "FDA Cybersecurity Guidance 2023";
         attribute :>> edition = "2023-09";
         attribute :>> issuer = "FDA";
         attribute :>> appliesToRegime = (RegulatoryRegimeKind::FDA_510k, RegulatoryRegimeKind::FDA_PMA);
-        item fdaCyberSection4 : StandardClause {
-            @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-IV"; }
-            attribute :>> name = "FDACyberSectionIV";
+        part fdaCyberSection4 : StandardClause {
+            @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-IV"; :>> label = "FDACyberSectionIV"; }
             attribute :>> clauseNumber = "IV";
             attribute :>> title = "general cybersecurity principles";
             attribute :>> normativeStrength = "informative";
         }
-        item fdaCyberSection5 : StandardClause {
-            @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V"; }
-            attribute :>> name = "FDACyberSectionV";
+        part fdaCyberSection5 : StandardClause {
+            @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V"; :>> label = "FDACyberSectionV"; }
             attribute :>> clauseNumber = "V";
             attribute :>> title = "secure product development framework";
             attribute :>> normativeStrength = "informative";
-            item fdaCyberSection5A : StandardClause {
-                @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V-A"; }
-                attribute :>> name = "FDACyberSectionVA";
+            part fdaCyberSection5A : StandardClause {
+                @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V-A"; :>> label = "FDACyberSectionVA"; }
                 attribute :>> clauseNumber = "V.A";
                 attribute :>> title = "security risk management";
                 attribute :>> normativeStrength = "informative";
             }
-            item fdaCyberSection5B : StandardClause {
-                @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V-B"; }
-                attribute :>> name = "FDACyberSectionVB";
+            part fdaCyberSection5B : StandardClause {
+                @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V-B"; :>> label = "FDACyberSectionVB"; }
                 attribute :>> clauseNumber = "V.B";
                 attribute :>> title = "security architecture";
                 attribute :>> normativeStrength = "informative";
             }
-            item fdaCyberSection5C : StandardClause {
-                @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V-C"; }
-                attribute :>> name = "FDACyberSectionVC";
+            part fdaCyberSection5C : StandardClause {
+                @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-V-C"; :>> label = "FDACyberSectionVC"; }
                 attribute :>> clauseNumber = "V.C";
                 attribute :>> title = "cybersecurity testing";
                 attribute :>> normativeStrength = "informative";
             }
         }
-        item fdaCyberSection6 : StandardClause {
-            @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-VI"; }
-            attribute :>> name = "FDACyberSectionVI";
+        part fdaCyberSection6 : StandardClause {
+            @MemoIdentity { :>> providedId = "STD-FDA-CYBER-2023-VI"; :>> label = "FDACyberSectionVI"; }
             attribute :>> clauseNumber = "VI";
             attribute :>> title = "cybersecurity transparency and vulnerability management";
             attribute :>> normativeStrength = "informative";