@memoarchitect/ontology 0.6.5 → 0.8.22

package/examples/surgical-robot/model/catalog/project.sysml

@@ -0,0 +1,24 @@
+// Surgical Robot — project identity and method binding.
+//
+// The native entrypoint. The imports name what this project contains and the
+// binding names the methodology it is governed by. No YAML file participates.
+package memo_examples_surgical_robot_project {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_methodology_core::*;
+    private import memo_methodology_profiles::*;
+
+    // The project's own content, imported so the catalog is one reachable
+    // closure from a single entrypoint.
+    private import memo_examples_surgical_robot_viewpoints_unassigned::*;
+    private import memo_examples_surgical_robot_viewpoints_unassigned_views_surgical_robot_overview::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-SURGICAL-ROBOT-001";
+        attribute :>> name = "SurgicalRobotProjectMethodBinding";
+        attribute :>> projectName = "Surgical Robot";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}

package/examples/surgical-robot/model/catalog/surgical_robot.sysml

@@ -23,7 +23,7 @@ package memo_examples_surgical_robot {
     connection : IndependentOf connect channel ::> chMotionMonitor to otherChannel ::> chMotionPrimary {
         attribute :>> independenceBasis = "separate sensing, power, and processing; common-cause analysis SR-CCA-01";
     }
-    connection : MonitorsChannel connect monitorChannel ::> chMotionMonitor to monitoredComponent ::> chMotionPrimary;
+    dependency chMotionMonitor to chMotionPrimary;
 
     // Interlock: instrument exchange blocked while arm is in motion.
     part chExchangeInterlock : LogicalComponent {
@@ -49,10 +49,12 @@ package memo_examples_surgical_robot {
         attribute :>> contactDuration = "limited (<24 h)";
     }
 
-    // Surgeon console: haptic feedback element.
-    part elHapticGrip : UIElement {
+    // Surgeon console: haptic feedback element. The grip is hardware the
+    // surgeon holds, so it is an OperatorInterfaceElement (a PhysicalComponent)
+    // rather than a UIElement — UIElement is software.
+    part elHapticGrip : OperatorInterfaceElement {
         attribute :>> id = "SR-UI-001"; attribute :>> name = "HapticMasterGrip";
-        attribute :>> formKind = UIElementFormKind::hapticIndicator;
+        attribute :>> formKind = OperatorInterfaceFormKind::hapticIndicator;
         attribute :>> guardedAgainstInadvertentActuation = true;
     }
 }

package/examples/surgical-robot/model/catalog/viewpoints/unassigned/viewpoint.sysml

@@ -0,0 +1,9 @@
+// unassigned viewpoint.
+//
+// This project does not define its own viewpoint here; it binds the reusable
+// MEMO viewpoint that frames these concerns. The views it governs sit beneath
+// `views/`.
+package memo_examples_surgical_robot_viewpoints_unassigned {
+    // The reusable package declaring unassigned could not be resolved during
+    // conversion. Import it here so the views beneath this viewpoint resolve.
+}

package/examples/surgical-robot/model/{viewpoints → catalog/viewpoints/unassigned/views}/surgical_robot_overview.sysml

@@ -1,4 +1,4 @@
-package memo_examples_surgical_robot_viewpoints {
+package memo_examples_surgical_robot_viewpoints_unassigned_views_surgical_robot_overview {
     private import memo_examples_surgical_robot::*;
     private import memo_viewpoints_definitions::*;
     private import memo_core_enumerations::*;

package/examples/sysml-diagram-samples/README.md

@@ -15,11 +15,18 @@ Each view is a `MemoDiagramView` declared in `model/samples/`, exposing its own
 dummy elements. The Architect explorer groups each authored view by the layer
 of its model content.
 
+`model/sysml_v2_activity_example.sysml` is the SysML v2 activity-diagram
+acceptance fixture, and is the single copy — it sits with the rest of the
+model's SysML rather than in a parallel `reference/` tree. The bundled parser
+accepts its decision, merge, accept/send, termination and guard syntax, and
+`standard_activity_view.sysml` is the view that draws it.
+
 | View | Diagram type | View kind | Renders |
 | --- | --- | --- | --- |
 | `tree_view.sysml` | `bdd` | general | Block Definition Diagram — a decomposition hierarchy. |
 | `interconnection_view.sysml` | `ibd` | interconnection | Internal Block Diagram — nested parts, boundary ports, typed connectors. |
 | `action_flow_view.sysml` | `afd` | actionflow | Activity / action flow — actions, item flows, successions. |
+| `standard_activity_view.sysml` | `afd` | actionflow | Standard SysML v2 activity — decision, merge, fork, join, accept, send, terminate, guarded successions. |
 | `functional_flow_view.sysml` | `ffd` | actionflow | Functional flow — swimlanes per realising component, typed data/energy flows. |
 | `operational_behaviour_view.sysml` | `ofd` | actionflow | Operational flow — clinical-role swimlanes, concurrent preparation, and a composite therapy step. |
 | `context_view.sysml` | `context` | general | Operational system context — a black-box system of interest inside an explicit boundary, with actors, peer systems, environment, and typed interactions outside it. |

package/examples/sysml-diagram-samples/dhf/documents/DOC-HAR-001.md

@@ -0,0 +1,11 @@
+---
+id: DOC-HAR-001
+title: Hazard Analysis Report
+template: iso-14971/har
+group: Risk Management
+created: 1785896600558
+---
+
+# Hazard Analysis Report
+
+_[TODO: Add content]_

package/examples/sysml-diagram-samples/memo.package.yaml

@@ -1,5 +1,11 @@
-name: "sysml-diagram-samples"
-version: "0.1.0"
-type: device
-extends: "@memoarchitect/medical-modeling-profile"
-description: "MEMO Architect diagram rendering samples — one openable view per standard SysML v2 diagram type. Open with: memo-architect --example standard-sysml-diagrams"
+# Application/distribution descriptor for this MEMO package.
+#
+# Identity and location only. It records what this package is called, what
+# version it is, and where its SysML source sits so a resolver can find it.
+# It does not select model content: the project's native SysML imports and its
+# ProjectMethodBinding decide what is in the model. Semantic fields
+# (`type`, `extends`, `usage`, `ontologies`, `methodology`, `modules`) were
+# removed at the native semantic flip and are now rejected if present.
+name: sysml-diagram-samples
+version: 0.1.0
+description: "MEMO Architect diagram rendering samples \u2014 one openable view per standard SysML v2 diagram type. Open with: memo-architect --example standard-sysml-diagrams"

package/examples/sysml-diagram-samples/model/catalog/project.sysml

@@ -0,0 +1,33 @@
+// Sysml Diagram Samples — project identity and method binding.
+//
+// The native entrypoint. The imports name what this project contains and the
+// binding names the methodology it is governed by. No YAML file participates.
+package memo_examples_sysml_diagram_samples_project {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_methodology_core::*;
+    private import memo_methodology_profiles::*;
+
+    // The project's own content, imported so the catalog is one reachable
+    // closure from a single entrypoint.
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_action_flow_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_context_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_functional_flow_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_interconnection_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_operational_behaviour_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_requirements_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_standard_activity_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_state_transition_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_tree_view::*;
+    private import memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_use_case_view::*;
+
+    part projectBinding : ProjectMethodBinding {
+        attribute :>> id = "PMB-DIAGRAM-SAMPLES-001";
+        attribute :>> name = "SysmlDiagramSamplesProjectMethodBinding";
+        attribute :>> projectName = "Sysml Diagram Samples";
+        ref :>> selectedMethodology = mdDefaultDefinition;
+        attribute :>> scopeMode = ScopeModeKind::explicit;
+    }
+}

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/viewpoint.sysml

@@ -0,0 +1,9 @@
+// unassigned viewpoint.
+//
+// This project does not define its own viewpoint here; it binds the reusable
+// MEMO viewpoint that frames these concerns. The views it governs sit beneath
+// `views/`.
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned {
+    // The reusable package declaring unassigned could not be resolved during
+    // conversion. Import it here so the views beneath this viewpoint resolve.
+}

package/examples/sysml-diagram-samples/model/{samples → catalog/viewpoints/unassigned/views}/action_flow_view.sysml

@@ -1,10 +1,13 @@
-package memo_examples_sysml_diagram_samples_model_samples_action_flow_view {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_action_flow_view {
     private import ScalarValues::*;
     private import memo_core_relationships::*;
+    private import ModelingMetadata::*;
 
     private import memo_architecture_logical_structure::*;
     private import memo_architecture_logical_interfaces::*;
+    private import memo_architecture_functional_functions::*;
     private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_functional_functional_viewpoint::*;
     private import memo_core_enumerations::*;
 
     item def DataPacket specializes InterfaceItem {
@@ -17,15 +20,15 @@ package memo_examples_sysml_diagram_samples_model_samples_action_flow_view {
         attribute :>> itemKind = InterfaceItemKind::material;
     }
 
-    action def ReceiveInput { out received : DataPacket; }
-    action def ValidateInput { in received : DataPacket; out validated : EnergyToken; }
-    action def ProcessInput { in validated : EnergyToken; out result : MaterialBatch; }
-    action def RecordResult { in result : MaterialBatch; }
+    action def ReceiveInput specializes SystemFunction { out item received : DataPacket; }
+    action def ValidateInput specializes SystemFunction { in item received : DataPacket; out item validated : EnergyToken; }
+    action def ProcessInput specializes SystemFunction { in item validated : EnergyToken; out item result : MaterialBatch; }
+    action def RecordResult specializes SystemFunction { in item result : MaterialBatch; }
 
     part laneA : LogicalComponent { attribute :>> name = "Lane A"; }
     part laneB : LogicalComponent { attribute :>> name = "Lane B"; }
 
-    action sampleActionFlow {
+    action sampleActionFlow : SystemFunction {
         action receive : ReceiveInput;
         action validate : ValidateInput;
         action process : ProcessInput {
@@ -60,13 +63,20 @@ package memo_examples_sysml_diagram_samples_model_samples_action_flow_view {
 
     // MemoLink sample — the universal relation, exercised where nothing else
     // reaches. laneB is a `part` (LogicalComponent :> ArchitectureElement) and
-    // ProcessInput is an `action def` (:> MemoAction). Those foundations share
-    // no supertype, so every typed relation in the ontology is unavailable
-    // here: legalRelationshipTypes returns MemoLink and nothing else.
+    // `sampleActionFlow.process` is an action usage (:> MemoAction). Those
+    // foundations share no supertype, so every typed relation in the ontology
+    // is unavailable here: legalRelationshipTypes returns MemoLink and nothing
+    // else.
+    //
+    // The target is the action *usage*, not the `ProcessInput` definition.
+    // Binding a value to a definition is not portable — SysIDE rejects it,
+    // because a value must be a feature and a definition is not.
     connection linkLaneBProcessesInput : MemoLink
-        connect linkSource ::> laneB to linkTarget ::> ProcessInput {
-        attribute :>> linkRationale =
-            "Lane B is the swimlane that carries the ProcessInput behaviour. The association crosses the part/action metaclass boundary, so no typed relation can express it.";
+        connect linkSource ::> laneB to linkTarget ::> sampleActionFlow.process {
+        @Rationale {
+            :>> text =
+                "Lane B is the swimlane that carries the ProcessInput behaviour. The association crosses the part/action metaclass boundary, so no typed relation can express it.";
+        }
     }
 
     view sampleActionFlowView : MemoDiagramView {
@@ -78,13 +88,6 @@ package memo_examples_sysml_diagram_samples_model_samples_action_flow_view {
         attribute :>> shortDescription = "Dummy actions, typed item flows, successions, and a composite action for renderer development.";
         attribute :>> viewKind = DiagramViewKind::actionflow;
         attribute :>> diagramType = "afd";
+        part :>> viewpointDefinition = functionalViewpoint;
     }
-
-    connection : IncludedIn connect sourceElement ::> sampleActionFlow.receive to targetView ::> sampleActionFlowView;
-    connection : IncludedIn connect sourceElement ::> sampleActionFlow.validate to targetView ::> sampleActionFlowView;
-    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process to targetView ::> sampleActionFlowView;
-    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process.processStepA to targetView ::> sampleActionFlowView;
-    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process.processStepB to targetView ::> sampleActionFlowView;
-    connection : IncludedIn connect sourceElement ::> sampleActionFlow.process.processStepC to targetView ::> sampleActionFlowView;
-    connection : IncludedIn connect sourceElement ::> sampleActionFlow.record to targetView ::> sampleActionFlowView;
 }

package/examples/sysml-diagram-samples/model/{samples → catalog/viewpoints/unassigned/views}/context_view.sysml

@@ -1,7 +1,7 @@
 // System context sample (general view kind, `context` diagram type). The system
 // under consideration is one block; every other element is an external actor,
 // neighbouring system, or use context it interacts with across its boundary.
-package memo_examples_sysml_diagram_samples_model_samples_context_view {
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_context_view {
     private import ScalarValues::*;
 
     private import memo_architecture_operational_context_actors::*;
@@ -9,6 +9,7 @@ package memo_examples_sysml_diagram_samples_model_samples_context_view {
     private import memo_architecture_operational_structure::*;
     private import memo_core_relationships::*;
     private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_context_context_viewpoint::*;
     private import memo_core_enumerations::*;
 
     // The operational system of interest is intentionally represented as one
@@ -17,7 +18,7 @@ package memo_examples_sysml_diagram_samples_model_samples_context_view {
     part infusionSystem : OperationalEntity {
         attribute :>> name = "Infusion Pump System";
         attribute :>> entityKind = OperationalEntityKind::device;
-        attribute :>> contextRole = "systemOfInterest";
+        attribute :>> responsibility = "System of interest for this context view.";
     }
     part clinician : User { attribute :>> name = "Clinician"; }
     part patient : User { attribute :>> name = "Patient"; }
@@ -31,25 +32,24 @@ package memo_examples_sysml_diagram_samples_model_samples_context_view {
     connection : InteractsWith connect contextParticipant ::> clinician to target ::> infusionSystem;
     connection : InteractsWith connect contextParticipant ::> patient to target ::> infusionSystem;
     connection : InteractsWith connect contextParticipant ::> biomedTech to target ::> infusionSystem;
-    connection : ExchangesWith connect source ::> infusionSystem to target ::> pharmacySystem;
+    flow from infusionSystem to pharmacySystem;
     connection : AppliesInContext connect useContext ::> homeContext to subjectElement ::> infusionSystem;
 
     view sampleContextView : MemoDiagramView {
         expose infusionSystem::**;
+        expose clinician;
+        expose patient;
+        expose biomedTech;
+        expose pharmacySystem;
+        expose homeContext;
         attribute depth = 1;
         attribute :>> title = "Sample · System Context";
         attribute :>> shortDescription = "Operational system context: one black-box system boundary, its external people, peer systems, operating environment, and named boundary-crossing interactions.";
         attribute :>> viewKind = DiagramViewKind::general;
         attribute :>> diagramType = "context";
+        part :>> viewpointDefinition = contextViewpoint;
         part :>> selectionQuery {
-            attribute :>> includeRelationshipKinds = ("InteractsWith", "ExchangesWith", "AppliesInContext");
+            attribute :>> includeRelationshipKinds = ("InteractsWith", "flow", "AppliesInContext");
         }
     }
-
-    connection : IncludedIn connect sourceElement ::> infusionSystem to targetView ::> sampleContextView;
-    connection : IncludedIn connect sourceElement ::> clinician to targetView ::> sampleContextView;
-    connection : IncludedIn connect sourceElement ::> patient to targetView ::> sampleContextView;
-    connection : IncludedIn connect sourceElement ::> biomedTech to targetView ::> sampleContextView;
-    connection : IncludedIn connect sourceElement ::> pharmacySystem to targetView ::> sampleContextView;
-    connection : IncludedIn connect sourceElement ::> homeContext to targetView ::> sampleContextView;
 }

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/context_view.viewlayout

@@ -0,0 +1,47 @@
+format: memo.viewlayout/v1
+viewSource: model/catalog/viewpoints/unassigned/views/context_view.sysml
+layouts:
+  diag-sample-sampleContextView:
+    nodes:
+      __context_boundary__:
+        x: 327.4
+        y: 109
+        ports: {}
+      infusionSystem:
+        x: 92
+        y: 74
+        ports: {}
+      biomedTech:
+        x: 40
+        y: 40
+        ports: {}
+      clinician:
+        x: 53.400000000000006
+        y: 146
+        ports: {}
+      patient:
+        x: 53.400000000000006
+        y: 252
+        ports: {}
+      homeContext:
+        x: 440
+        y: 600
+        ports: {}
+      pharmacySystem:
+        x: 855.4
+        y: 199
+        ports: {}
+    edges:
+      rel-8: {}
+      rel-9: {}
+      rel-10: {}
+      rel-11: {}
+      rel-12: {}
+    annotations: {}
+    canvas:
+      autoLayout: false
+      zoom: 0.7154088050314465
+      pan:
+        x: 50.15487421383642
+        y: -9.616352201257882
+      coordinateSpace: context-child-v1

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/functional_flow_view.sysml

@@ -0,0 +1,143 @@
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_functional_flow_view {
+    private import ScalarValues::*;
+
+    private import memo_architecture_logical_structure::*;
+    private import memo_architecture_logical_interfaces::*;
+    private import memo_architecture_functional_functions::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_functional_functional_viewpoint::*;
+    private import memo_core_enumerations::*;
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Sample · Functional flow — component behaviour of dose delivery
+    //
+    // Demonstrates an Action Flow (activity) diagram of *functional/component*
+    // behaviour: how the architecture components collaborate to deliver a dose.
+    // Swimlanes group functions by the component that realises them; typed item
+    // flows show data (blue), energy (orange) and material (green) moving
+    // between functions; a fork/join runs occlusion monitoring concurrently
+    // with drive/deliver; and `fxDeliver` is a composite (double-click to
+    // drill into its valve sub-flow, then "← Parent" to return).
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // Typed flow payloads
+    item def FxSensorReading specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::data;
+    }
+    item def FxRateCommand specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::command;
+    }
+    item def FxMotorEnergy specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::energy;
+    }
+    item def FxMedicationFluid specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::fluid;
+    }
+    item def FxOcclusionSignal specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::signal;
+    }
+
+    // Functions with typed in/out pins
+    action def FxAcquire specializes SystemFunction { out item reading : FxSensorReading; }
+    action def FxCompute specializes SystemFunction { in item reading : FxSensorReading; out item command : FxRateCommand; }
+    action def FxEnforce specializes SystemFunction { in item command : FxRateCommand; out item safeCommand : FxRateCommand; }
+    action def FxDrive specializes SystemFunction { in item command : FxRateCommand; out item energy : FxMotorEnergy; }
+    action def FxDeliverMedication specializes SystemFunction { in item energy : FxMotorEnergy; out item fluid : FxMedicationFluid; }
+    action def FxMonitor specializes SystemFunction { out item signal : FxOcclusionSignal; }
+    action def FxDetect specializes SystemFunction { in item signal : FxOcclusionSignal; }
+
+    // Component hierarchy used by the Level control:
+    // L1 system → L2 subsystems → L3 allocated components.
+    part fxPumpSystem : LogicalComponent {
+        attribute :>> name = "Infusion Pump System";
+        part fxSensingSubsystem : LogicalComponent {
+            attribute :>> name = "Sensing Subsystem";
+            part fxSensor : LogicalComponent { attribute :>> name = "Sensor Subsystem"; }
+        }
+        part fxControlSubsystem : LogicalComponent {
+            attribute :>> name = "Control Subsystem";
+            part fxController : LogicalComponent { attribute :>> name = "Infusion Controller"; }
+        }
+        part fxDeliverySubsystem : LogicalComponent {
+            attribute :>> name = "Delivery Subsystem";
+            part fxActuator : LogicalComponent { attribute :>> name = "Pump Actuator"; }
+        }
+        part fxSafetySubsystem : LogicalComponent {
+            attribute :>> name = "Safety Subsystem";
+            part fxSafety : LogicalComponent { attribute :>> name = "Safety Monitor"; }
+        }
+    }
+
+    action fxDeliveryFlow : SystemFunction {
+        action fxAcquire : FxAcquire { attribute :>> name = "Acquire Sensor Data"; }
+        action fxCompute : FxCompute { attribute :>> name = "Compute Infusion Rate"; }
+
+        // Split: enforce/drive/deliver runs concurrently with occlusion monitoring
+        fork fxForkDeliver;
+        action fxEnforce : FxEnforce { attribute :>> name = "Enforce Dose Limits"; }
+        action fxDrive : FxDrive { attribute :>> name = "Drive Pump Motor"; }
+        action fxMonitor : FxMonitor { attribute :>> name = "Monitor Occlusion"; }
+        action fxDetect : FxDetect { attribute :>> name = "Detect Occlusion"; }
+        join fxJoinDeliver;
+
+        // Composite function — valve sub-flow (drill-in)
+        action fxDeliver : FxDeliverMedication {
+            attribute :>> name = "Deliver Medication";
+            action fxOpenValve : SystemFunction { attribute :>> name = "Open Valve"; }
+            action fxHoldDose : SystemFunction { attribute :>> name = "Hold Metered Dose"; }
+            action fxCloseValve : SystemFunction { attribute :>> name = "Close Valve"; }
+
+            flow of FxMedicationFluid from fxDeliveryFlow.fxDeliver.fxHoldDose to fxCloseValve;
+
+            first start then fxOpenValve;
+            first fxOpenValve then fxHoldDose;
+            first fxHoldDose then fxCloseValve;
+            first fxCloseValve then done;
+        }
+
+        action fxLog : SystemFunction { attribute :>> name = "Log Delivery"; }
+
+        flow of FxSensorReading from fxAcquire.reading to fxCompute.reading;
+        flow of FxRateCommand from fxEnforce.safeCommand to fxDrive.command;
+        flow of FxMotorEnergy from fxDrive.energy to fxDeliver.energy;
+        flow of FxOcclusionSignal from fxMonitor.signal to fxDetect.signal;
+
+        first start then fxAcquire;
+        first fxAcquire then fxCompute;
+        first fxCompute then fxForkDeliver;
+        first fxForkDeliver then fxEnforce;
+        first fxForkDeliver then fxMonitor;
+        first fxEnforce then fxDrive;
+        first fxDrive then fxDeliver;
+        first fxMonitor then fxDetect;
+        first fxDeliver then fxJoinDeliver;
+        first fxDetect then fxJoinDeliver;
+        first fxJoinDeliver then fxLog;
+        first fxLog then done;
+    }
+
+    // Swimlane allocation — which component realises each function
+    allocate fxDeliveryFlow.fxAcquire to fxPumpSystem.fxSensingSubsystem.fxSensor;
+    allocate fxDeliveryFlow.fxCompute to fxPumpSystem.fxControlSubsystem.fxController;
+    allocate fxDeliveryFlow.fxEnforce to fxPumpSystem.fxSafetySubsystem.fxSafety;
+    allocate fxDeliveryFlow.fxDrive to fxPumpSystem.fxDeliverySubsystem.fxActuator;
+    allocate fxDeliveryFlow.fxDeliver to fxPumpSystem.fxDeliverySubsystem.fxActuator;
+    allocate fxDeliveryFlow.fxMonitor to fxPumpSystem.fxSafetySubsystem.fxSafety;
+    allocate fxDeliveryFlow.fxDetect to fxPumpSystem.fxSafetySubsystem.fxSafety;
+    allocate fxDeliveryFlow.fxLog to fxPumpSystem.fxControlSubsystem.fxController;
+    allocate fxDeliveryFlow.fxDeliver.fxOpenValve to fxPumpSystem.fxDeliverySubsystem.fxActuator;
+    allocate fxDeliveryFlow.fxDeliver.fxHoldDose to fxPumpSystem.fxDeliverySubsystem.fxActuator;
+    allocate fxDeliveryFlow.fxDeliver.fxCloseValve to fxPumpSystem.fxDeliverySubsystem.fxActuator;
+
+    view fxDeliveryView : MemoDiagramView {
+        expose fxDeliveryFlow::**;
+        expose fxPumpSystem::**;
+        attribute depth = 2;
+        attribute :>> title = "Sample · Dose Delivery (Functional Flow)";
+        attribute :>> shortDescription = "Component behaviour: functions in swimlanes per realising component, typed data/energy/material flows, a fork/join for concurrent occlusion monitoring, and a composite 'Deliver Medication' valve sub-flow (double-click to drill in).";
+        attribute :>> viewKind = DiagramViewKind::actionflow;
+        attribute :>> diagramType = "ffd";
+        part :>> viewpointDefinition = functionalViewpoint;
+    }
+}

package/examples/sysml-diagram-samples/model/catalog/viewpoints/unassigned/views/interconnection_view.sysml

@@ -0,0 +1,87 @@
+package memo_examples_sysml_diagram_samples_viewpoints_unassigned_views_interconnection_view {
+    private import ScalarValues::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_architecture_operational_context_use_context::*;
+
+    private import memo_architecture_logical_interfaces::*;
+    private import memo_architecture_logical_structure::*;
+    private import memo_core_common::*;
+    private import memo_core_relationships::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_viewpoints_logical_logical_viewpoint::*;
+    private import memo_core_enumerations::*;
+
+    // Ports are owned by the part whose boundary they are, which is what lets
+    // a delegation be written at all: SysML v2 checks a flow's source for
+    // `out`-ness relative to the owner, so a boundary port only reads as a
+    // source from INSIDE its part. The subassemblies are nested the same way —
+    // real containment, not a port-to-port `Composes` edge, which is what
+    // CR-ONT-065 used to forbid before nesting made the rule unnecessary.
+    part coffeeMachine : LogicalComponent {
+        attribute :>> name = "Coffee Machine";
+        in port mainsWaterIn : DataPort { in item payload : MemoItem; }
+        out port beverageOut : DataPort { out item payload : MemoItem; }
+        inout port serviceInterface : DataPort {
+            inout item payload : MemoItem;
+            out port diagnostics : DataPort { out item payload : MemoItem; }
+        }
+
+        part waterTank : LogicalComponent {
+            attribute :>> name = "Water Reservoir";
+            out port tankWaterOut : DataPort { out item payload : MemoItem; }
+            in port tankWaterIn : DataPort { in item payload : MemoItem; }
+        }
+        part heaterAssembly : LogicalComponent {
+            attribute :>> name = "Thermal Control Assembly";
+            in port heaterWaterIn : DataPort { in item payload : MemoItem; }
+            out port heatedWaterOut : DataPort { out item payload : MemoItem; }
+
+            part heatingElement : LogicalComponent {
+                attribute :>> name = "Water Heating Element";
+                out port heaterStatusOut : DataPort { out item payload : MemoItem; }
+            }
+        }
+        part brewGroup : LogicalComponent {
+            attribute :>> name = "Brew Group";
+            in port brewWaterIn : DataPort { in item payload : MemoItem; }
+            out port brewedCoffeeOut : DataPort { out item payload : MemoItem; }
+        }
+    }
+    part waterSupply : LogicalComponent {
+        attribute :>> name = "Water Supply";
+        out port supplyWaterOut : DataPort { out item payload : MemoItem; }
+    }
+    part cup : LogicalComponent {
+        attribute :>> name = "Cup";
+        in port cupBeverageIn : DataPort { in item payload : MemoItem; }
+    }
+
+    // Transport between two components: `out` to `in`, one item moving.
+    flow from waterSupply.supplyWaterOut to coffeeMachine.mainsWaterIn;
+    flow from coffeeMachine.waterTank.tankWaterOut to coffeeMachine.heaterAssembly.heaterWaterIn;
+    flow from coffeeMachine.heaterAssembly.heatedWaterOut to coffeeMachine.brewGroup.brewWaterIn;
+    flow from coffeeMachine.beverageOut to cup.cupBeverageIn;
+
+    // Delegation between a boundary port and the interior it stands for. These
+    // are `in`-to-`in` and `out`-to-`out`, because nothing travels: the two
+    // features are the same feature. SysML v2 spells that `bind` (training
+    // ch. 12), not `flow` (ch. 13).
+    bind coffeeMachine.mainsWaterIn = coffeeMachine.waterTank.tankWaterIn;
+    bind coffeeMachine.brewGroup.brewedCoffeeOut = coffeeMachine.beverageOut;
+    bind coffeeMachine.heaterAssembly.heatingElement.heaterStatusOut = coffeeMachine.serviceInterface.diagnostics;
+
+    view sampleInterconnectionView : MemoDiagramView {
+        expose coffeeMachine::**;
+        expose waterSupply::**;
+        expose cup::**;
+        attribute depth = 2;
+        attribute :>> title = "Coffee Machine · Thermal & Fluid IBD";
+        attribute :>> shortDescription = "Balanced internal architecture with readable boundary ports, nested service diagnostics, and external water and beverage interfaces.";
+        attribute :>> viewKind = DiagramViewKind::interconnection;
+        attribute :>> diagramType = "ibd";
+        part :>> viewpointDefinition = logicalArchitectureViewpoint;
+        part :>> selectionQuery {
+            attribute :>> includeRelationshipKinds = ("Composes", "flow", "bind");
+        }
+    }
+}