@memoarchitect/ontology 0.12.1 → 0.15.0

package/extensions/README.md

@@ -1,31 +1,80 @@
 # Extensions
 
 An extension is a **way to model**, not a sample. It is a reusable ontology
-package that specializes the base and is selected by a methodology or a project
-binding — so extensions live here, beside `src/`, and not under `examples/`.
+package that specializes the base and is brought into a project by importing
+it — so extensions live here, beside `src/`, and not under `examples/`.
 Examples *use* extensions; `examples/ros-mobile-robot` demonstrates one.
 
-MEMO defines no extension metaclass. An extension is a plain SysML package:
+MEMO defines no extension metaclass and no extension methodology. An extension
+is plain SysML packages:
 
 - outside `src/` and outside the `memo::` namespace;
 - with a `memo.package.yaml` carrying identity and `sysmlDir` only (the semantic
   fields `type` / `extends` / `usage` / `ontologies` / `methodology` / `modules`
   are rejected);
 - whose SysML **specializes** base types;
-- plus a `MethodologyDefinition` naming `baseMethodology`, `scopeMode`, and its
-  own `includedModule`.
+- with one **facade** package, `memo_extension_<directory>`, that publicly
+  imports every other package the extension ships and every extension it builds
+  on.
 
-`template/` is the skeleton. The build round-trips every extension into its own
-KPAR and resolves it with `syside check`, exactly as it does the base.
-
-## Composition happens at the project binding
+The facade **is** the extension as the model sees it: a project imports it,
+another extension imports it, and nothing else identifies an extension.
 
-`MethodologyDefinition.baseMethodology` is `[0..1]` — single inheritance, and
-deliberate. Extensions therefore **do not chain**. Both
-`MethodologyDefinition.includedModule` and `ProjectMethodBinding.includedModule`
-are `String[0..*]`, so a project combines any number of independent extensions
-by listing their modules in its own binding. That is *the* composition
-mechanism; nothing else is supported.
+`template/` is the skeleton. The build round-trips every extension into its own
+KPAR (`memo-extension-<directory>`) and resolves the whole tree with `syside check`,
+exactly as it does the base.
+
+## Each extension is its own package
+
+An extension is built, versioned and depended on by itself. Its KPAR declares
+what it uses: the base ontology and default methodology, the SysML libraries,
+and **every other extension its source imports** (`import memo_extension_<name>`
+is read from the files, not listed twice). `ros` therefore declares
+`memo-extension-messaging` and `memo-extension-container`; `clinical` declares
+neither. Add an `import` of another extension and the next build records the
+dependency; remove it and the dependency goes.
+
+## One import brings an extension in
+
+```sysml
+package memo_examples_ros_mobile_robot_project {
+    public import memo_extension_ros::*;
+
+    part projectBinding : ModelMethodBinding {
+        ref :>> selectedMethodology = mdDefaultDefinition;
+    }
+}
+```
+
+A methodology selects the packages that the package declaring it **publicly
+imports**, followed through their public imports in turn; a project adds to that
+selection the same way, from the package that declares its binding. That is
+SysML's own meaning of a public import — it passes the imported members on to
+whoever imports the importing package — so there is no list of package names
+beside it, and a misspelled package is an import the compiler rejects. A
+private import makes the names visible to the importing package and selects
+nothing: the ROS package privately imports the architecture packages it
+specializes, and selecting ROS does not select them.
+
+So an extension's facade publicly imports what selecting the extension has to
+select:
+
+- **its own packages.** `aadl`'s facade publicly imports
+  `memo_extension_aadl_runtime` and `memo_extension_aadl_correspondence`, the
+  packages that declare its definitions and rules. A facade that left one out
+  would leave it out of every project that imports the extension.
+- **the extensions it builds on.** `ros` publicly imports `memo_extension_messaging`
+  and `memo_extension_container`. The dependency is declared once, by that
+  import, and it is the same line the KPAR build reads to record the dependency,
+  so the two cannot disagree.
+
+A test holds each facade's public imports equal to the packages the directory
+declares plus the extensions it imports, and checks that every example using an
+extension's definitions publicly imports its facade from the entrypoint, or one
+whose facade imports it.
+
+A project's or a supplier's own packages outside MEMO are added the same way: a
+public import in the binding's package.
 
 ## Rule 1 — use native mechanisms first; extension relations specialize base ones
 
@@ -71,7 +120,7 @@ the prefix is what makes that check something an author can satisfy by
 construction rather than by luck.
 
 Enumeration literals are not definitions and are not prefixed —
-`RosReliabilityKind::reliable`, not `RosReliabilityKind::rosReliable`.
+`RosDurabilityKind::transientLocal`, not `RosDurabilityKind::rosTransientLocal`.
 
 ## What an extension must not do
 

package/extensions/aadl/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/extension-aadl'
-version: 0.12.1
+version: 0.15.0
 description: AADL (SAE AS5506) correspondence profile and runtime component families
 license: MIT
 tags:

package/extensions/aadl/src/aadl_extension.sysml

@@ -1,5 +1,8 @@
-// The AADL extension's public facade. A project includes the module
-// `memo_extension_aadl` in its binding and imports this package.
+// The AADL extension's public facade. It publicly imports every package the
+// extension ships, so one import brings the extension into a project: a
+// project that imports it sees the definitions, and one that imports it
+// publicly from its entrypoint package (or a methodology that does) selects
+// every package below.
 package memo_extension_aadl {
     public import memo_extension_aadl_runtime::*;
     public import memo_extension_aadl_correspondence::*;

package/extensions/aadl/src/correspondence/memo_aadl_correspondence.sysml

@@ -23,127 +23,106 @@ package memo_extension_aadl_correspondence {
     private import memo_core_common::MemoIdentity;
     // ── Component categories ────────────────────────────────────────────
     part aadlCorrProcess : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-001"; }
-        attribute :>> name = "ProcessCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-001"; :>> label = "ProcessCorrespondence"; }
         attribute :>> ruleExpression = "memo_extension_aadl_runtime::AadlProcess <-> AADL component category `process`";
-        attribute :>> description = "A MEMO SoftwareComponent with runtimeKind = process, carrying addressSpaceIsolated.";
+        doc /* A MEMO SoftwareComponent with runtimeKind = process, carrying addressSpaceIsolated. */
     }
     part aadlCorrThread : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-002"; }
-        attribute :>> name = "ThreadCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-002"; :>> label = "ThreadCorrespondence"; }
         attribute :>> ruleExpression = "memo_extension_aadl_runtime::AadlThread <-> AADL component category `thread`";
-        attribute :>> description = "Schedulable unit inside one process; owningProcessName names the containing process.";
+        doc /* Schedulable unit inside one process; owningProcessName names the containing process. */
     }
     part aadlCorrVirtualProcessor : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-003"; }
-        attribute :>> name = "VirtualProcessorCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-003"; :>> label = "VirtualProcessorCorrespondence"; }
         attribute :>> ruleExpression = "memo_extension_aadl_runtime::AadlVirtualProcessor <-> AADL component category `virtual processor`";
-        attribute :>> description = "An ARINC 653 partition. partitionBudget is the guaranteed time and memory; isolationMechanism is what enforces it.";
+        doc /* An ARINC 653 partition. partitionBudget is the guaranteed time and memory; isolationMechanism is what enforces it. */
     }
     part aadlCorrProcessor : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-004"; }
-        attribute :>> name = "ProcessorCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-004"; :>> label = "ProcessorCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_realization_physical::ProcessingNode <-> AADL component category `processor`";
     }
     part aadlCorrMemory : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-005"; }
-        attribute :>> name = "MemoryCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-005"; :>> label = "MemoryCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_realization_physical::MemoryDevice <-> AADL component category `memory`";
     }
     part aadlCorrBus : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-006"; }
-        attribute :>> name = "BusCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-006"; :>> label = "BusCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_implementation_hardware_electrical::NetworkMedium <-> AADL component category `bus`";
     }
     part aadlCorrSystem : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-007"; }
-        attribute :>> name = "SystemCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-007"; :>> label = "SystemCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_logical_structure::System <-> AADL component category `system`";
-        attribute :>> description = "AADL's system is the composition unit, which is MEMO's logical System rather than any runtime element.";
+        doc /* AADL's system is the composition unit, which is MEMO's logical System rather than any runtime element. */
     }
 
     // ── Bindings. AADL's analytic power is that everything is bound to
     // something, and the binding is where latency, bandwidth, and fault
     // propagation accrue. MEMO has all three (plan C1). ────────────────────
     part aadlCorrProcessorBinding : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-010"; }
-        attribute :>> name = "ActualProcessorBindingCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-010"; :>> label = "ActualProcessorBindingCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_realization_deployment::DeploysTo <-> AADL property `Actual_Processor_Binding`";
     }
     part aadlCorrMemoryBinding : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-011"; }
-        attribute :>> name = "ActualMemoryBindingCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-011"; :>> label = "ActualMemoryBindingCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_realization_deployment::MemoryBinding <-> AADL property `Actual_Memory_Binding`";
     }
     part aadlCorrConnectionBinding : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-012"; }
-        attribute :>> name = "ActualConnectionBindingCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-012"; :>> label = "ActualConnectionBindingCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_realization_deployment::ConnectionBinding <-> AADL property `Actual_Connection_Binding`";
-        attribute :>> description = "The bound element is the ComponentExchange, because the exchange is what owns the budget the medium spends.";
+        doc /* The bound element is the ComponentExchange, because the exchange is what owns the budget the medium spends. */
     }
 
     // ── Ports and flows ─────────────────────────────────────────────────
     part aadlCorrPortCategory : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-020"; }
-        attribute :>> name = "PortCategoryCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-020"; :>> label = "PortCategoryCorrespondence"; }
         attribute :>> ruleExpression = "memo_core_enumerations::PortCategoryKind (data | 'event' | eventData) <-> AADL `data port` | `event port` | `event data port`";
-        attribute :>> description = "Determines whether a missed deadline loses a sample or grows a queue — two failure modes with two mitigations.";
+        doc /* Determines whether a missed deadline loses a sample or grows a queue — two failure modes with two mitigations. */
     }
     part aadlCorrFlowSpec : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-021"; }
-        attribute :>> name = "FlowSpecificationCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-021"; :>> label = "FlowSpecificationCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_realization_deployment::FlowSpecification (FlowSpecKind source | sink | path) <-> AADL `flow source` | `flow sink` | `flow path`";
     }
     part aadlCorrEndToEndFlow : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-022"; }
-        attribute :>> name = "EndToEndFlowCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-022"; :>> label = "EndToEndFlowCorrespondence"; }
         attribute :>> ruleExpression = "memo_architecture_realization_deployment::EndToEndFlow <-> AADL `end to end flow`";
     }
 
     // ── Properties. AADL's property sets are the technology-specific half of
     // the language; these are the ones MEMO already carries by another name.
     part aadlCorrPeriod : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-030"; }
-        attribute :>> name = "PeriodCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-030"; :>> label = "PeriodCorrespondence"; }
         attribute :>> ruleExpression = "SoftwareComponent.periodMs <-> AADL `Timing_Properties::Period` (ms)";
     }
     part aadlCorrDeadline : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-031"; }
-        attribute :>> name = "DeadlineCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-031"; :>> label = "DeadlineCorrespondence"; }
         attribute :>> ruleExpression = "SoftwareComponent.deadlineMs <-> AADL `Timing_Properties::Deadline` (ms)";
     }
     part aadlCorrComputeExecutionTime : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-032"; }
-        attribute :>> name = "ComputeExecutionTimeCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-032"; :>> label = "ComputeExecutionTimeCorrespondence"; }
         attribute :>> ruleExpression = "SoftwareComponent.wcetMs <-> upper bound of AADL `Timing_Properties::Compute_Execution_Time` (ms)";
-        attribute :>> description = "AADL records a range; MEMO records the worst case, which is the bound a schedulability argument uses.";
+        doc /* AADL records a range; MEMO records the worst case, which is the bound a schedulability argument uses. */
     }
     part aadlCorrPriority : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-033"; }
-        attribute :>> name = "PriorityCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-033"; :>> label = "PriorityCorrespondence"; }
         attribute :>> ruleExpression = "SoftwareComponent.priority <-> AADL `Thread_Properties::Priority`";
     }
     part aadlCorrSchedulingProtocol : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-034"; }
-        attribute :>> name = "SchedulingProtocolCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-034"; :>> label = "SchedulingProtocolCorrespondence"; }
         attribute :>> ruleExpression = "SoftwareComponent.schedulingPolicy <-> AADL `Deployment_Properties::Scheduling_Protocol`";
     }
     part aadlCorrLatency : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-035"; }
-        attribute :>> name = "LatencyCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-035"; :>> label = "LatencyCorrespondence"; }
         attribute :>> ruleExpression = "EndToEndFlow.latencyBudgetMs <-> AADL `Communication_Properties::Latency` upper bound (ms)";
     }
     part aadlCorrBandwidth : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-036"; }
-        attribute :>> name = "BandwidthCorrespondence";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-036"; :>> label = "BandwidthCorrespondence"; }
         attribute :>> ruleExpression = "ConnectionBinding.allocatedBandwidth <-> AADL `Communication_Properties::Bandwidth_Budget`";
     }
 
     // ── Where the correspondence stops ──────────────────────────────────
     part aadlCorrNoCounterpart : CorrespondenceRule {
-        @MemoIdentity { :>> providedId = "EXT-AADL-C-090"; }
-        attribute :>> name = "NoCounterpartNote";
+        @MemoIdentity { :>> providedId = "EXT-AADL-C-090"; :>> label = "NoCounterpartNote"; }
         attribute :>> ruleExpression = "no correspondence: AADL `subprogram`, `device`, `abstract`; MEMO's five assurance disciplines";
-        attribute :>> description = "Recorded so the gap is a stated boundary of the profile rather than an omission a reader has to discover.";
+        doc /* Recorded so the gap is a stated boundary of the profile rather than an omission a reader has to discover. */
     }
 }

package/extensions/clinical/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/example-extension-clinical'
-version: 0.6.1
+version: 0.15.0
 description: Example methodology extension for clinical-procedure vocabulary
 license: MIT
 tags:

package/extensions/clinical/src/clinical_extension.sysml

@@ -1,3 +1,5 @@
+// The clinical extension's public facade: it publicly imports every package
+// the extension ships, so importing it brings in the whole extension.
 package memo_extension_clinical {
     public import memo_extension_clinical_procedures::*;
 }

package/extensions/cloud/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/extension-cloud'
-version: 0.12.1
+version: 0.15.0
 description: Networked services and managed data stores
 license: MIT
 tags:

package/extensions/container/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/extension-container'
-version: 0.12.1
+version: 0.15.0
 description: OCI container images and container runtimes as deployment content
 license: MIT
 tags:

package/extensions/messaging/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/extension-messaging'
-version: 0.12.1
+version: 0.15.0
 description: Publish/subscribe messaging — topics, brokers, and delivery semantics
 license: MIT
 tags:

package/extensions/messaging/src/messaging_extension.sysml

@@ -28,7 +28,7 @@ package memo_extension_messaging {
     // Message/payload definition. A named topic is an item usage of a concrete
     // message definition; the definition states the schema, while the usage
     // supplies the deployed topic identity.
-    item def MessagingMessage specializes SoftwareItem {
+    item def MessagingMessage specializes DataItem {
         attribute messageSchema : String;
     }
 
@@ -52,7 +52,7 @@ package memo_extension_messaging {
     interface def MessagingTopicInterface specializes SoftwareInterface {
         end publisher : MessagingPublisher :>> source;
         end subscriber : MessagingSubscriber :>> target;
-        flow of MessagingMessage from publisher.payload to subscriber.payload;
+        flow messagingMessageFlow of MessagingMessage from publisher.payload to subscriber.payload;
     }
 
     part def MessagingBroker specializes SoftwareComponent {

package/extensions/ros/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/extension-ros'
-version: 0.12.1
+version: 0.15.0
 description: ROS 2 nodes, messages, topic/service/action interfaces, QoS, and containerized deployment
 license: MIT
 tags:

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.12.1
+version: 0.15.0
 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.12.1
+version: 0.15.0
 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.12.1
+version: 0.15.0
 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.12.1",
+  "version": "0.15.0",
   "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.12.1
+version: 0.15.0
 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;