@memoarchitect/ontology 0.13.2 → 0.15.1

package/extensions/ros/src/ros_extension.sysml

@@ -7,21 +7,24 @@
 // relation. `BuildsInto`, `DeploysTo`, and `ProvidesEnvironment` are reused
 // exactly as the base declares them.
 //
-// Composition is by MODULE LIST, not by chaining. `baseMethodology` is [0..1],
-// but `includedModule` is [0..*], so this extension's methodology names
-// `memo_extension_messaging` and `memo_extension_container` alongside its own
-// module. ROS communication specializes native MEMO item, port, and interface
-// families; it does not invent publish/subscribe relations.
+// Composition is by import. ROS builds on the messaging and container
+// extensions and imports them PUBLICLY, so a project that imports
+// `memo_extension_ros` has all three: their definitions are visible and their
+// packages are selected. The dependency is stated once, here, and the KPAR
+// build reads the same lines to record it. ROS communication specializes
+// native MEMO item, port, and interface families; it does not invent
+// publish/subscribe relations.
 package memo_extension_ros {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
+    private import memo_core_enumerations::*;
     private import memo_architecture_functional_behavior::*;
     private import memo_architecture_logical_interfaces::*;
     private import memo_architecture_implementation_software_structure::*;
     private import memo_architecture_implementation_software_runtime::*;
-    private import memo_extension_messaging::*;
-    private import memo_extension_container::*;
+    public import memo_extension_messaging::*;
+    public import memo_extension_container::*;
 
     // ── Quality of service ──────────────────────────────────────────────
     //
@@ -33,13 +36,6 @@ package memo_extension_ros {
     // between a publisher and a subscriber, and read by a tool; a property bag
     // cannot. `PropertySet` is deleted in this session for that reason.
 
-    // ROS 2 RELIABLE resends until delivery; BEST_EFFORT does not. This is
-    // the delivery guarantee, so it maps onto MessagingDeliveryKind:
-    // bestEffort is atMostOnce, reliable is atLeastOnce.
-    enum def RosReliabilityKind {
-        enum bestEffort;
-        enum reliable;
-    }
     // TRANSIENT_LOCAL replays the last samples to a late-joining subscriber;
     // VOLATILE does not. The difference decides whether a node that restarts
     // sees the current state or waits for the next publication — which is a
@@ -49,8 +45,12 @@ package memo_extension_ros {
         enum transientLocal;
     }
 
+    // RELIABILITY is not in the profile. ROS 2 RELIABLE resends until delivery
+    // and BEST_EFFORT does not, which is the delivery guarantee the port
+    // already states as `deliverySemantics`: bestEffort is atMostOnce and
+    // reliable is atLeastOnce. Stating it a second time here let one port
+    // say both and disagree.
     attribute def RosQosProfile {
-        attribute reliability : RosReliabilityKind;
         attribute durability : RosDurabilityKind;
         // The QoS contract: a sample is expected at least this often.
         attribute deadlineMs : Real;
@@ -96,6 +96,8 @@ package memo_extension_ros {
     interface def RosTopicInterface specializes MessagingTopicInterface {
         end rosPublisher : RosPublisher :>> publisher;
         end rosSubscriber : RosSubscriber :>> subscriber;
+        // A topic goes publisher to subscriber, always.
+        attribute :>> direction default DirectionKind::output;
     }
 
     // ── Services: one correlated request/reply contract ────────────────
@@ -106,7 +108,6 @@ package memo_extension_ros {
         out item request : RosServiceRequest;
         in item response : RosServiceResponse;
         attribute serviceName : String;
-        attribute timeoutMs : Real;
     }
 
     port def RosServiceServer specializes SoftwarePort {
@@ -118,8 +119,8 @@ package memo_extension_ros {
     interface def RosServiceInterface specializes SoftwareInterface {
         end client : RosServiceClient :>> source;
         end server : RosServiceServer :>> target;
-        flow of RosServiceRequest from client.request to server.request;
-        flow of RosServiceResponse from server.response to client.response;
+        flow rosServiceRequestFlow of RosServiceRequest from client.request to server.request;
+        flow rosServiceResponseFlow of RosServiceResponse from server.response to client.response;
     }
 
     // ── Actions: long-running goal protocol ─────────────────────────────
@@ -156,12 +157,12 @@ package memo_extension_ros {
     interface def RosActionInterface specializes SoftwareInterface {
         end client : RosActionClient :>> source;
         end server : RosActionServer :>> target;
-        flow of RosActionGoal from client.goal to server.goal;
-        flow of RosActionAcceptance from server.acceptance to client.acceptance;
-        flow of RosActionFeedback from server.feedback to client.feedback;
-        flow of RosActionCancel from client.cancel to server.cancel;
-        flow of RosActionResult from server.result to client.result;
-        flow of RosActionStatus from server.actionStatus to client.actionStatus;
+        flow rosActionGoalFlow of RosActionGoal from client.goal to server.goal;
+        flow rosActionAcceptanceFlow of RosActionAcceptance from server.acceptance to client.acceptance;
+        flow rosActionFeedbackFlow of RosActionFeedback from server.feedback to client.feedback;
+        flow rosActionCancelFlow of RosActionCancel from client.cancel to server.cancel;
+        flow rosActionResultFlow of RosActionResult from server.result to client.result;
+        flow rosActionStatusFlow of RosActionStatus from server.actionStatus to client.actionStatus;
     }
 
     abstract state def RosActionExecution specializes MemoState;

package/extensions/template/memo.package.yaml

@@ -14,4 +14,4 @@ tags:
 - memo
 - methodology
 - extension
-sysmlDir: ./src
+sysmlDir: ./model

package/extensions/template/model/extension.sysml

@@ -0,0 +1,25 @@
+// Skeleton for a new MEMO extension. Copy the directory, rename the packages,
+// and replace the prefix.
+//
+// Two conventions this file follows and every extension must (extensions/README.md):
+//
+//   1. Every definition an extension declares is prefixed with the PascalCase
+//      form of the extension's directory name — `template/` gives `Template`.
+//      Extension names share one flat namespace with the base and with each
+//      other, so the prefix is what keeps two independent extensions from both
+//      declaring `Node`.
+//   2. A relation an extension declares specializes a base relation. It never
+//      roots independently.
+//
+//   3. This package is the extension's facade: the one package a project
+//      imports. It publicly imports every other package the extension ships
+//      (`public import memo_extension_template_<sub>::*;`) and every extension
+//      it builds on (`public import memo_extension_<other>::*;`). A public
+//      import is what passes those packages on, so importing this one selects
+//      the whole extension, and the KPAR build reads the same imports to
+//      record the dependency. There is no list of package names to keep
+//      beside it.
+package memo_extension_template {
+    // Definitions go here, each prefixed `Template`; sub-packages and the
+    // extensions this one builds on are publicly imported here.
+}

package/memo.manifest.yaml

@@ -7,13 +7,7 @@ packages:
 init:
   defaultExtends: "@memoarchitect/methodology-default"
   rootImport: "memo"
-  defaultTemplate: default
-templates:
-  default: ./templates/default
-  samd: ./templates/samd
-  connected-device: ./templates/connected-device
-  monitoring-device: ./templates/monitoring-device
-  infusion-pump: ./templates/infusion-pump
+  template: ./templates/default
 examples:
   gpca: ./examples/gpca-pump
   standard-sysml-diagrams: ./examples/sysml-diagram-samples

package/methodologies/default/memo.package.yaml

@@ -7,7 +7,7 @@
 # (`type`, `extends`, `usage`, `ontologies`, `methodology`, `modules`) were
 # removed at the native semantic flip and are now rejected if present.
 name: '@memoarchitect/methodology-default'
-version: 0.13.2
+version: 0.15.1
 description: "MEMO default medical-device methodology \u2014 selects viewpoints/views/DHF documents from @memoarchitect/ontology and adds rules, gates, patterns, profiles, and workflow."
 license: MIT
 tags:

package/methodologies/gpca/memo.package.yaml

@@ -7,7 +7,7 @@
 # (`type`, `extends`, `usage`, `ontologies`, `methodology`, `modules`) were
 # removed at the native semantic flip and are now rejected if present.
 name: '@memoarchitect/methodology-gpca'
-version: 0.13.2
+version: 0.15.1
 description: "GPCA infusion pump methodology \u2014 subtraction-based tailoring of @memoarchitect/methodology-default for the non-networked prototype variant. Excludes cybersecurity and SOUP."
 license: MIT
 tags:

package/ontology/memo.package.yaml

@@ -7,7 +7,7 @@
 # (`type`, `extends`, `usage`, `ontologies`, `methodology`, `modules`) were
 # removed at the native semantic flip and are now rejected if present.
 name: '@memoarchitect/ontology'
-version: 0.13.2
+version: 0.15.1
 description: "MEMO \u2014 the single canonical medical-device ontology: core semantics, the Arcadia-inspired architecture layers (context, requirements, behavior, structure, interfaces, risk, cybersecurity,\
   \ assurance, \u2026), compliance, viewpoints, views, and invariant rules. One namespace (memo::), one src/ tree."
 license: MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoarchitect/ontology",
-  "version": "0.13.2",
+  "version": "0.15.1",
   "packageManager": "pnpm@9.15.0",
   "description": "MEMO — Medical Engineering Modelling Ontology. Pure SysML v2 medical-device ontology with native constraints, portable to any conformant SysML v2 tool (SysIDE, SysON, sysand).",
   "scripts": {
@@ -9,9 +9,10 @@
     "lint": "node ../memo-tools/packages/tools/lib/bin/memo.js dhf lint",
     "test": "node --test test/package.test.mjs",
     "docs:api": "node scripts/generate-sysml-api.mjs",
+    "docs:figures": "node scripts/generate-ontology-figures.mjs",
     "docs:diagrams": "node scripts/generate-reference-diagrams.mjs",
-    "docs:serve": "node scripts/generate-reference-diagrams.mjs && node scripts/generate-sysml-api.mjs && node scripts/check-reference-coverage.mjs && python3 -m mkdocs serve",
-    "docs:build": "node scripts/generate-reference-diagrams.mjs && node scripts/generate-sysml-api.mjs && node scripts/check-reference-coverage.mjs && python3 -m mkdocs build --strict",
+    "docs:serve": "node scripts/generate-reference-diagrams.mjs && node scripts/generate-sysml-api.mjs && node scripts/generate-ontology-figures.mjs && node scripts/check-reference-coverage.mjs && python3 -m mkdocs serve",
+    "docs:build": "node scripts/generate-reference-diagrams.mjs && node scripts/generate-sysml-api.mjs && node scripts/generate-ontology-figures.mjs && node scripts/check-reference-coverage.mjs && python3 -m mkdocs build --strict",
     "docs:check-reference": "node scripts/check-reference-coverage.mjs",
     "version:sync": "node scripts/sync-version.mjs",
     "version:check": "node scripts/sync-version.mjs --check"
@@ -71,6 +72,7 @@
     "src/memo_namespaces.sysml",
     "templates/",
     "examples/",
-    "extensions/"
+    "extensions/",
+    "stage1/"
   ]
 }

package/profile/memo.package.yaml

@@ -7,7 +7,7 @@
 # (`type`, `extends`, `usage`, `ontologies`, `methodology`, `modules`) were
 # removed at the native semantic flip and are now rejected if present.
 name: '@memoarchitect/medical-modeling-profile'
-version: 0.13.2
+version: 0.15.1
 description: Closure rules and viewpoints for medical device modeling
 license: MIT
 tags:

package/src/architecture/decisions/memo_decisions.sysml

@@ -8,11 +8,18 @@ package memo_architecture_decisions {
     private import memo_artifacts_core::*;
     part def DesignDecision specializes MemoPart {
         attribute decisionKind : String;
-        attribute alternatives : String;
-        attribute selectedOption : String;
         attribute decisionStatus : DesignDecisionStatusKind;
     }
 
+    // The options a decision weighs and the one it chose are links to variants, not
+    // strings: `#Alternative dependency from <decision> to <variant>, <variant>;` and
+    // `#Selected dependency from <decision> to <variant>;`. A variant is a SysML
+    // `variant` (SysML-textual-bnf.kebnf:254-256) of a variation point, so a trade
+    // study points at the thing that is being traded. Both are typed dependencies
+    // (memo_core_relationships::MemoTypedDependency).
+    metadata def Alternative :> MemoTypedDependency;
+    metadata def Selected :> MemoTypedDependency;
+
     connection def DecisionRecordedInADR :> MemoRelationship {
         end decision : DesignDecision :>> source;
         end adr : ADRArtifact :>> target;

package/src/architecture/functional/behavior/memo_behavior.sysml

@@ -40,21 +40,34 @@ package memo_architecture_functional_behavior {
     // records so the two are not confused.
     metadata def TransitionRecord {
         attribute id : String;
-        attribute name : String;
         attribute trigger : String;
         attribute guardSummary : String;
         attribute effectSummary : String;
         attribute sourceReference : String;
     }
 
-    // A verifiable behavioural constraint, such as an invariant, transition
-    // rule, temporal claim, assumption, or guarantee.
-    part def BehaviorProperty specializes VerifiableElement {
+    // A behavioural obligation, such as an invariant, transition rule,
+    // temporal claim, assumption, or guarantee. It is a `requirement def`
+    // because that is what it is: a claim the design must meet and a
+    // verification case can `verify`. It was a `part def` under
+    // VerifiableElement, which made a property a structural thing and left
+    // native `verify` unable to name it.
+    requirement def BehaviorProperty :> MemoRequirementElement {
         attribute propertyKind : BehaviorPropertyKind;
         attribute languageKind : PropertyLanguageKind;
         attribute formalExpression : String;
     }
-    part def Contract specializes VerifiableElement { attribute contractScope : String; }
+    // An assume/guarantee contract on one component, AGREE's shape one to one:
+    // the component is the `subject`, each assumption an `assume` member and
+    // each guarantee a `require` member naming a BehaviorProperty. The subject
+    // replaces `contractScope : String`, which named the component in prose
+    // and could not be navigated.
+    //
+    // This is not the procurement contract of a deliverable; that is a
+    // different definition.
+    requirement def Contract :> MemoRequirementElement {
+        subject component : MemoPart;
+    }
     // `part def PropertySet specializes VerifiableElement { attribute
     // propertySetScope : String; }` stood here and is DELETED (plan C3,
     // open question §14.6). It was AADL's property-set idea imported as a
@@ -70,7 +83,12 @@ package memo_architecture_functional_behavior {
     // annotate a BASE element rather than declare its own type, the SysML-
     // native answer is `metadata def` + `Metaobjects::SemanticMetadata`, which
     // is what every MEMO relation already carries since A4.
-    part def ActivityAction specializes MemoPart {
+    // An `action def`: every field it carries — what it does, what goes in and
+    // out, its worst-case execution time — describes behaviour. It was a
+    // `part def specializes MemoPart`, the same A0 residue `FunctionalFlow`
+    // carried, and a behaviour cannot specialize a structure, so nothing could
+    // have performed one.
+    action def ActivityAction specializes FunctionalAction {
         attribute actionKind : ActionKind;
         attribute inputSummary : String;
         attribute outputSummary : String;
@@ -84,7 +102,9 @@ package memo_architecture_functional_behavior {
     }
     // UI scenarios are OperativeScenario usages with scenarioKind `ui`.
 
-    part def TimingConstraint specializes VerifiableElement {
+    // A timing budget is an obligation on what it measures, so it is a
+    // requirement like BehaviorProperty.
+    requirement def TimingConstraint :> MemoRequirementElement {
         attribute constraintKind : TimingConstraintKind;
         attribute minMs : String;
         attribute maxMs : String;

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

@@ -27,6 +27,23 @@
 // project argues in — therapy, alarm, platform, protection. A function can be
 // `sense` in the `protection` category, and a safety case reasons about both.
 //
+// ─── A functional exchange is a flow ─────────────────────────────────────
+//
+// `FunctionalExchange` is an `abstract flow def`, and an exchange is a typed
+// named `flow` between function parameters: the edge IS the exchange. It was
+// a `part def` beside a separate `flow`, with its ends stored as
+// `sourceFunction`/`targetFunction` refs, because a flow could not be the
+// target of an allocation or a trace. A named flow now carries a qualified id
+// that `allocate`, `satisfy` and the rest resolve, so the part reached no
+// rule, query or diagram and existed only to be kept in step with its edge.
+//
+// It is `abstract` because a flow definition specializes the association
+// `Flows::MessageAction`, and a concrete association must declare its two
+// ends (`association-related-types`); here the ends are the usage's
+// parameters. A usage says what it carries through the item type of those
+// parameters, not with `of`: `of` and `: FunctionalExchange` together declare
+// a second `payload`, and a SysML v2 compiler rejects the pair.
+//
 // ─── System function vs. component function ──────────────────────────────
 //
 // ARCADIA's functional chain does not stop at the system boundary: system
@@ -80,34 +97,20 @@ package memo_architecture_functional_functions {
     // component is a responsibility nobody has accepted.
     action def ComponentFunction specializes MemoFunction;
 
-    // Named traceable route between functions. Native `flow of` usages carry
-    // the transported item; this element exists for the budgets and assurance
-    // attributes below.
-    //
-    // The reason is MEMO's grammar, NOT the language — the earlier wording here
-    // said "attributes that a flow usage cannot own", and that was a false
-    // claim about SysML v2. The standard's `FlowUsage` is
-    // `OccurrenceUsagePrefix 'flow' FlowDeclaration DefinitionBody`
-    // (SysML-textual-bnf.kebnf:829), so a conforming flow usage takes a name
-    // from its `UsageDeclaration` and owns attributes in its body like any
-    // other usage. MEMO's own production is
-    // `'flow' 'of' itemType 'from' … 'to' … ';'` — no name, no body — so a
-    // MEMO flow can carry neither an `id` nor a latency budget, and nothing
-    // can refer to it. Every MEMO element rests on the identification core in
-    // memo_core_common, and an anonymous attribute-less edge cannot join it.
+    // A transfer between two functions, carrying the budgets and assurance
+    // attributes a reader needs on the transfer itself. Authored as a typed
+    // named flow from an `out` parameter of one function to an `in` parameter
+    // of another:
     //
-    // So this part def is a workaround for a MEMO gap, not a design MEMO is
-    // entitled to. Restoring the two dropped clauses is what would let it
-    // collapse into the flow it stands in for.
-    part def FunctionalExchange specializes MemoPart {
+    //     flow lfFlowCommand : FunctionalExchange
+    //         from fnManageInfusion.flowCommandOut to fnCommandPump.flowCommandIn {
+    //         attribute :>> latencyBudgetMs = 20.0;
+    //     }
+    abstract flow def FunctionalExchange {
         attribute flowKind : FlowKind;
         attribute latencyBudgetMs : Real;
         attribute staleAfterMs : Real;
         attribute integrityLevel : String;
-        // MemoFunction, not SystemFunction: an exchange between two component
-        // functions is the ordinary case once the chain is decomposed.
-        ref sourceFunction : MemoFunction[0..1];
-        ref targetFunction : MemoFunction[0..1];
     }
 
     // A system function enables operational work; it does not perform it.
@@ -132,14 +135,25 @@ package memo_architecture_functional_functions {
         attribute safetyRelevant : Boolean;
         attribute securityRelevant : Boolean;
     }
-    action def FunctionalFlowStep specializes MemoAction {
-        ref function : MemoFunction[0..1];
-        ref exchange : FunctionalExchange[0..1];
-        ref item exchangedItem : MemoItem[0..1];
-    }
+    // A step is not a definition. `action def FunctionalFlowStep` stood here
+    // with `ref function`, `ref exchange` and `ref item exchangedItem`: a
+    // wrapper that pointed at the function it stood for. A step is that
+    // function performed at one position in the flow, which SysML says
+    // directly as an action usage nested in the flow that subsets it:
+    //
+    //   action fcPatientBolus : FunctionalFlow {
+    //       action fcsBolusCommand :> fnManageInfusion { out item flowCommand :> cdFlowCommand; }
+    //       action fcsBolusActuate :> fnCommandPump { in item flowCommand :> cdFlowCommand; }
+    //       first fcsBolusCommand then fcsBolusActuate;
+    //       flow from fcsBolusCommand.flowCommand to fcsBolusActuate.flowCommand;
+    //   }
+    //
+    // Each position keeps its own identity and evidence scope. The exchanged
+    // item is a directed parameter of the step, and the exchange a `flow`
+    // between two steps' parameters. A step's parameters redefine its
+    // function's by position.
 
     // `InvolvesFunction` is native `perform` (R10-S6): a `FunctionalFlow`
-    // already names its functions via its step chain
-    // (`perform <step>;` + the step's own `ref function`), and a flow with no
-    // step chain performs its functions directly.
+    // performs the function each of its steps subsets, and a flow with no
+    // steps performs its functions directly.
 }

package/src/architecture/functional/memo_architecture_functional.sysml

@@ -0,0 +1,14 @@
+// The functional (system) analysis layer as one package.
+//
+// A layer is a namespace of packages: every package whose name begins
+// `memo_architecture_functional_`. This package publicly imports each of them, so
+// `public import memo_architecture_functional::*;` 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_functional {
+    public import memo_architecture_functional_behavior::*;
+    public import memo_architecture_functional_constraints::*;
+    public import memo_architecture_functional_functions::*;
+}

package/src/architecture/implementation/memo_architecture_implementation.sysml

@@ -0,0 +1,21 @@
+// The implementation (software, hardware, user interface) layer as one package.
+//
+// A layer is a namespace of packages: every package whose name begins
+// `memo_architecture_implementation_`. This package publicly imports each of them, so
+// `public import memo_architecture_implementation::*;` 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_implementation {
+    public import memo_architecture_implementation_hardware_common::*;
+    public import memo_architecture_implementation_hardware_electrical::*;
+    public import memo_architecture_implementation_hardware_fluidic::*;
+    public import memo_architecture_implementation_hardware_mechanical::*;
+    public import memo_architecture_implementation_hardware_optical::*;
+    public import memo_architecture_implementation_hardware_sensing::*;
+    public import memo_architecture_implementation_hardware_structure::*;
+    public import memo_architecture_implementation_software_runtime::*;
+    public import memo_architecture_implementation_software_structure::*;
+    public import memo_architecture_implementation_ui::*;
+}

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

@@ -78,4 +78,11 @@ package memo_architecture_implementation_software_runtime {
         // a component belongs to without claiming to describe it.
     }
 
+    // A runtime service or process that exists only because an OTS module is
+    // deployed. Optional: a library the product links normally needs only the
+    // module.
+    part def OTSSoftwareComponent specializes SoftwareComponent {
+        ref sourceModule : OTSSoftwareModule[0..1];
+    }
+
 }

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

@@ -24,10 +24,9 @@ package memo_architecture_implementation_software_structure {
     // software view inherits it rather than re-declaring it: the code view
     // (SoftwareModule), the runtime view (SoftwareComponent), the system, and
     // the user interface (memo_architecture_implementation_ui::UIElement).
-    // Structural software decomposition is part-native. IEC 62304 also uses
-    // the term "software item" for this concept, but reserving SoftwareItem
-    // for the native SysML item family keeps structural parts and exchanged
-    // values unambiguous in the model.
+    // Structural software decomposition is part-native. The standard's
+    // "software item" is this part, not an `item def`: exchanged or stored
+    // values are DataItem, below.
     abstract part def SoftwareElement specializes MemoPart {
         attribute safetyClass : SafetyClassKind;
         attribute complexity : ComplexityKind;
@@ -40,7 +39,8 @@ package memo_architecture_implementation_software_structure {
 
     // Module-view element (design responsibility). Runtime properties
     // (period, WCET, scheduling) moved to SoftwareComponent.
-    // item / unit / package / library / code / firmware / soup (IEC 62304).
+    // item / unit / package / library / code / firmware (IEC 62304). SOUP is
+    // a type (SOUPSoftwareModule), not a value here.
     enum def ModuleKind {
         enum 'item';
         enum unit;
@@ -48,7 +48,6 @@ package memo_architecture_implementation_software_structure {
         enum 'library';
         enum code;
         enum firmware;
-        enum soup;
     }
 
     part def SoftwareModule specializes SoftwareElement {
@@ -62,12 +61,6 @@ package memo_architecture_implementation_software_structure {
         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 MemoPart {
@@ -85,20 +78,68 @@ package memo_architecture_implementation_software_structure {
         attribute version : String;
     }
 
-    // Software data/content that may be stored or exchanged through ports.
-    abstract item def SoftwareItem specializes MemoItem {
+    // Data content that may be stored or exchanged through ports. Named
+    // DataItem, not SoftwareItem: IEC 62304 uses "software item" for a
+    // structural part of a program (a SoftwareElement here), and the item
+    // family is the exchanged or stored value.
+    abstract item def DataItem specializes MemoItem {
         attribute schemaIdentifier : String;
         attribute schemaVersion : String;
         attribute :>> encoding : String;
         attribute :>> timestampRequired : Boolean;
     }
 
-    item def SBOMEntry specializes SoftwareItem {
+    // SOUP and OTS (IEC 62304 §3.29). The standard's SOUP definition covers
+    // off-the-shelf software and also previously developed software that
+    // lacks development records, so OTS is the narrower type: every OTS
+    // module is SOUP, and SOUP also covers legacy in-house code with no
+    // supplier, license or package to record. SOUP is a type, not a
+    // module-kind value; the CR-MED-015..017 closure rules apply to it and so
+    // to OTS.
+    //
+    // §8.1.2 (SOUP identification: supplier, version) and §7.1.3 (published
+    // anomaly lists) are SOUP obligations, so those attributes sit here; the
+    // acquisition identity of a bought or downloaded package sits on
+    // OTSSoftwareModule.
+    part def SOUPSoftwareModule specializes SoftwareModule {
+        attribute supplier : String[0..1];
+        attribute version : String[0..1];
+        attribute knownAnomalies : String[0..1];
+        attribute riskAcceptance : String[0..1];
+        attribute soupClassification : SOUPClassificationKind[0..1];
+    }
+    part def OTSSoftwareModule specializes SOUPSoftwareModule {
+        attribute licenseExpression : String;
+        attribute packageUrl : String;
+        attribute checksum : String;
+    }
+
+    enum def SbomFormatKind {
+        enum spdx;
+        enum cycloneDx;
+        enum other;
+    }
+
+    // An SBOM is a document; its entries are inventory records. An entry
+    // names one software element and says what is known about it as shipped.
+    // Vulnerabilities, anomalies and risks are separate objects that point at
+    // the entry; they are not attributes of the document.
+    part def SBOMEntry specializes MemoPart {
         attribute componentName : String;
         attribute version : String;
         attribute supplier : String;
-        attribute license : String;
-        attribute hash : String;
+        attribute licenseExpression : String;
+        attribute checksum : String;
+        attribute packageUrl : String;
+        attribute bomReference : String;
+        ref inventoriedElement : SoftwareElement[0..1];
+    }
+    part def SoftwareBillOfMaterials specializes MemoPart {
+        attribute sbomFormat : SbomFormatKind;
+        attribute specVersion : String;
+        attribute generationTool : String;
+        attribute generatedOn : String;
+        part sbomEntry : SBOMEntry[0..*];
     }
 
     // `ModuleUses` is native `dependency` (R10-S6): write

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

@@ -299,7 +299,7 @@ package memo_architecture_implementation_ui {
     // `PresentsState` had zero usages anywhere in the tree (R10-S6). Its
     // audited native form, `exhibit state`, does not actually fit: `UIState`
     // is a `part def` with plain string attributes, not a `state def`, and
-    // SysIDE rejects `exhibit` referencing anything that does not conform to
+    // a SysML v2 compiler rejects `exhibit` referencing anything that does not conform to
     // `States::StateAction` ("An exhibit state must reference another
     // state"). Free deletion rather than a migration — nothing referenced
     // it, so nothing to preserve. If `UIState` is ever restructured onto a