@memoarchitect/ontology 0.4.6 → 0.6.0

package/README.md

@@ -18,7 +18,7 @@ pin an exact release; the package has no repository or runtime dependency on Mem
 Tools or Memo Architect.
 
 ```bash
-pnpm add @memoarchitect/ontology@0.4.6
+pnpm add @memoarchitect/ontology@0.6.0
 ```
 
 For coordinated development, the private `memo-meta` workspace checks out
@@ -50,16 +50,17 @@ methodologies/gpca/          @memoarchitect/methodology-gpca descriptor
 template/                    complete starter project copied by memo init
 examples/gpca-pump/          reference model (not a scaffold template)
 src/                         all reusable .sysml content (namespace = directory)
-  medical_device_library.sysml   public import surface
+  memo_namespaces.sysml          public memo import and nested namespace map
   core/                          common/ enumerations/ relationships/
                                  dimensions/ semantics/ + stdlib/* (KerML wrapper)
-  architecture/                  one folder per layer: context/ requirements/ functions/ behavior/
-                                 logical_structure/ software_structure/ … risk/ cybersecurity/ assurance/ …
+  architecture/                  operational/ functional/ logical/ implementation/ realization/
+  assurance/                     requirements/ safety_risk/ cybersecurity/ human_factors/ verification_validation/
   compliance/                    artifacts/ change/ document_views/ postmarket/ iso14971/
   viewpoints/                    reusable viewpoint and view definitions
   rules/                         closure/ coverage/ crosslayer/ lifecycle/ quantitative/ (native constraint defs)
   artifacts/                     artifact kinds (memo::artifacts)
   methodology/                   default methodology
+examples/extensions/             optional domain modules selected by methodology
 ```
 
 ## Build / verify

package/examples/connected-patient-monitor/README.md

@@ -0,0 +1,7 @@
+# Connected patient monitor
+
+A focused MEMO example for a connected patient monitor.
+
+- `model/connected_patient_monitor.sysml` is the public parent package.
+- `model/catalog/` holds the canonical model elements.
+- `model/viewpoints/` holds diagram views of that catalog.

package/examples/connected-patient-monitor/model/catalog/connected_patient_monitor.sysml

@@ -0,0 +1,70 @@
+// Focused example: connected, distributed device system. Bedside monitor →
+// gateway → hospital system, with typed network interfaces, a trust boundary
+// at the hospital network edge, and an ISO/IEEE 11073-coded measurement item.
+package memo_examples_connected_patient_monitor {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_terminology::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_logical_structure::*;
+    private import memo_architecture_logical_interfaces::*;
+    private import memo_assurance_cybersecurity::*;
+
+    part lcMonitor : LogicalComponent {
+        attribute :>> id = "CPM-LC-001"; attribute :>> name = "BedsideMonitor";
+        attribute :>> responsibility = "Acquire and display vitals; publish measurements.";
+    }
+    part lcGateway : LogicalComponent {
+        attribute :>> id = "CPM-LC-002"; attribute :>> name = "WardGateway";
+        attribute :>> responsibility = "Aggregate device data; bridge device LAN to hospital network.";
+    }
+    part lcCdrService : LogicalComponent {
+        attribute :>> id = "CPM-LC-003"; attribute :>> name = "ClinicalDataRepository";
+        attribute :>> externalOwner = "hospital IT";
+    }
+
+    // Typed measurement item, coded against ISO/IEEE 11073-10101.
+    item spo2Item : LogicalExchangeItem {
+        attribute :>> id = "CPM-IT-001"; attribute :>> name = "SpO2Measurement";
+        attribute :>> contentKind = FlowContentKind::measurement;
+        attribute :>> unit = "%";
+        attribute :>> timestampRequired = true;
+        attribute :>> codes = mdcSpo2;
+    }
+    attribute mdcSpo2 : TerminologyCode {
+        attribute :>> systemUri = "urn:iso:std:iso:11073:10101";
+        attribute :>> code = "150456";
+        attribute :>> display = "MDC_PULS_OXIM_SAT_O2";
+    }
+
+    part exSpo2ToGateway : LogicalExchange {
+        attribute :>> id = "CPM-EX-001"; attribute :>> name = "SpO2ToGateway";
+        attribute :>> contentKind = FlowContentKind::measurement;
+        attribute :>> direction = DirectionKind::output;
+        ref :>> exchangedItem = spo2Item;
+    }
+    connection : LogicalConnector connect sourceComponent ::> lcMonitor to targetComponent ::> lcGateway {
+        attribute :>> contentKind = FlowContentKind::measurement;
+        attribute :>> direction = DirectionKind::output;
+    }
+    connection : LogicalConnector connect sourceComponent ::> lcGateway to targetComponent ::> lcCdrService {
+        attribute :>> contentKind = FlowContentKind::information;
+        attribute :>> direction = DirectionKind::output;
+    }
+
+    // Network interface with cybersecurity properties; trust boundary at the
+    // hospital network edge.
+    interface ifHl7Feed : Interface {
+        attribute :>> id = "CPM-IF-001"; attribute :>> name = "GatewayToCdrFeed";
+        attribute :>> protocol = "HL7 FHIR REST over TLS 1.3";
+        attribute :>> securityCriticality = CriticalityKind::high;
+        attribute :>> patientContactInterface = false;
+    }
+    item tbHospitalEdge : TrustBoundary {
+        attribute :>> id = "CPM-TB-001"; attribute :>> name = "DeviceLanToHospitalNetwork";
+    }
+    connection : CrossesTrustBoundary connect boundary ::> tbHospitalEdge to crossingItem ::> ifHl7Feed {
+        attribute :>> crossingKind = InterfaceKind::network;
+    }
+}

package/examples/connected-patient-monitor/model/connected_patient_monitor.sysml

@@ -0,0 +1,3 @@
+package memo_examples_connected_patient_monitor_parent {
+    public import memo_examples_connected_patient_monitor::*;
+}

package/examples/connected-patient-monitor/model/viewpoints/connected_patient_monitor_overview.sysml

@@ -0,0 +1,6 @@
+package memo_examples_connected_patient_monitor_viewpoints {
+    private import memo_examples_connected_patient_monitor::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+    view connectedPatientMonitorOverview : MemoDiagramView { expose memo_examples_connected_patient_monitor::*; attribute depth = 2; attribute :>> title = "Connected Patient Monitor Overview"; attribute :>> viewKind = DiagramViewKind::interconnection; attribute :>> diagramType = "ibd"; }
+}

package/examples/embedded-infusion-pump/README.md

@@ -0,0 +1,7 @@
+# Embedded infusion pump
+
+A focused MEMO example for an embedded infusion pump.
+
+- `model/embedded_infusion_pump.sysml` is the public parent package.
+- `model/catalog/` holds the canonical model elements.
+- `model/viewpoints/` holds diagram views of that catalog.

package/examples/embedded-infusion-pump/model/catalog/embedded_infusion_pump.sysml

@@ -0,0 +1,66 @@
+// Focused example: embedded programmable device — the three software views
+// (module / runtime / deployment) on a minimal infusion pump.
+// SoftwareItem buildsInto DeploymentUnit deploysTo ProcessingNode;
+// SoftwareComponent hostedBy ProcessingNode with scheduling properties.
+package memo_examples_embedded_infusion_pump {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_implementation_software_structure::*;
+    private import memo_architecture_implementation_software_runtime::*;
+    private import memo_architecture_realization_deployment::*;
+    private import memo_architecture_realization_physical::*;
+
+    // Module view (IEC 62304).
+    part swInfusionControl : SoftwareModule {
+        attribute :>> moduleKind = ModuleKind::item;
+        attribute :>> id = "EIP-SW-001"; attribute :>> name = "InfusionControlItem";
+        attribute :>> iec62304Role = "software item, class C";
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+    part swMotorDriver : SoftwareModule {
+        attribute :>> moduleKind = ModuleKind::unit;
+        attribute :>> id = "EIP-SW-002"; attribute :>> name = "MotorDriverUnit";
+        attribute :>> implementationLanguage = "C";
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+    connection : Realizes connect realizing ::> swMotorDriver to realized ::> swInfusionControl;
+
+    // Runtime view.
+    part rtControlLoop : SoftwareComponent {
+        attribute :>> runtimeKind = RuntimeKind::task;
+        attribute :>> id = "EIP-RT-001"; attribute :>> name = "ControlLoopTask";
+        attribute :>> periodMs = 10.0;
+        attribute :>> deadlineMs = 10.0;
+        attribute :>> wcetMs = 2.5;
+        attribute :>> schedulingPolicy = SchedulingPolicyKind::rateMonotonic;
+        attribute :>> restartPolicy = "watchdog reset to safe state (pump stopped)";
+        attribute :>> faultContainment = "MPU-protected region; safe-state on overrun";
+    }
+    connection : Realizes connect realizing ::> rtControlLoop to realized ::> swInfusionControl;
+
+    // Deployment view.
+    part duControlImage : DeploymentUnit {
+        attribute :>> id = "EIP-DU-001"; attribute :>> name = "ControlFirmwareImage";
+        attribute :>> unitKind = "signed firmware image";
+        attribute :>> version = "3.1.0";
+        attribute :>> integrityProtection = "signature verified by boot loader";
+    }
+    part mcuSafety : ProcessingNode {
+        attribute :>> id = "EIP-HW-001"; attribute :>> name = "SafetyMCU";
+        attribute :>> nodeKind = ProcessingNodeKind::microcontroller;
+        attribute :>> realTimeCapable = true;
+        attribute :>> supportsContainerization = false;
+    }
+    part rteBareMetal : RuntimeEnvironment {
+        attribute :>> id = "EIP-RTE-001"; attribute :>> name = "StaticRTOS";
+        attribute :>> osOrRtos = "static-priority RTOS, no dynamic allocation";
+    }
+    connection : BuildsInto connect module ::> swInfusionControl to deploymentUnit ::> duControlImage;
+    connection : DeploysTo connect deploymentUnit ::> duControlImage to node ::> mcuSafety {
+        attribute :>> deploymentKind = DeploymentKind::embedded;
+    }
+    connection : HostedBy connect hostAssembly ::> mcuSafety to processingNode ::> rtControlLoop;
+    connection : ProvidesEnvironment connect node ::> mcuSafety to environment ::> rteBareMetal;
+}

package/examples/embedded-infusion-pump/model/embedded_infusion_pump.sysml

@@ -0,0 +1,3 @@
+package memo_examples_embedded_infusion_pump_parent {
+    public import memo_examples_embedded_infusion_pump::*;
+}

package/examples/embedded-infusion-pump/model/viewpoints/embedded_infusion_pump_overview.sysml

@@ -0,0 +1,6 @@
+package memo_examples_embedded_infusion_pump_viewpoints {
+    private import memo_examples_embedded_infusion_pump::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+    view embeddedInfusionPumpOverview : MemoDiagramView { expose memo_examples_embedded_infusion_pump::*; attribute depth = 2; attribute :>> title = "Embedded Infusion Pump Overview"; attribute :>> viewKind = DiagramViewKind::general; attribute :>> diagramType = "bdd"; }
+}

package/examples/extensions/README.md

@@ -0,0 +1,16 @@
+# Extension examples
+
+An extension is a regular SysML package selected by a MEMO methodology. MEMO
+does not define a separate extension metaclass. `MethodologyDefinition` and
+`ProjectMethodBinding` already accept packages through `includedModule`.
+
+- `template/` is the starting structure for an extension.
+- `clinical/` specializes `OperationalWorkflow` with clinical procedure data.
+
+Extensions specialize or reference base types. They do not redefine
+activities, workflows, architecture elements, relationships, or constraints
+already expressed by the base ontology.
+
+Extension packages remain outside `src/` and outside the `memo::` namespace.
+Projects import an extension package directly and include it in their selected
+methodology.

package/examples/extensions/clinical/memo.package.yaml

@@ -0,0 +1,9 @@
+name: "@memoarchitect/example-extension-clinical"
+version: "0.6.0"
+type: methodology
+extends: "@memoarchitect/methodology-default"
+sysmlDir: "./src"
+description: "Example methodology extension for clinical-procedure vocabulary"
+license: "MIT"
+tags: ["memo", "methodology", "extension", "clinical"]
+usage: ["extension", "clinical-procedures"]

package/examples/extensions/clinical/src/clinical_extension.sysml

@@ -0,0 +1,3 @@
+package memo_extension_clinical {
+    public import memo_extension_clinical_procedures::*;
+}

package/examples/extensions/clinical/src/methodology/clinical_methodology.sysml

@@ -0,0 +1,14 @@
+package memo_extension_clinical_methodology {
+    private import ScalarValues::*;
+    private import memo_methodology_core::*;
+
+    part clinicalExtensionMethod : MethodologyDefinition {
+        attribute :>> id = "EXT-CLINICAL-001";
+        attribute :>> name = "ClinicalProcedureExtension";
+        attribute :>> version = "0.6.0";
+        attribute :>> domain = "clinical procedures";
+        attribute :>> description = "Adds optional clinical-procedure vocabulary to a MEMO project.";
+        attribute :>> baseMethodName = "MedicalDeviceLightDefault";
+        attribute :>> includedModule = "memo_extension_clinical";
+    }
+}

package/examples/extensions/clinical/src/procedures/memo_clinical_procedures.sysml

@@ -0,0 +1,16 @@
+// Clinical data added to the base operational workflow. Activities, tasks,
+// techniques, variants, and resources continue to use the base ontology.
+package memo_extension_clinical_procedures {
+    private import ScalarValues::*;
+
+    private import memo_core_terminology::*;
+    private import memo_architecture_operational_workflows::*;
+
+    action def ClinicalProcedureWorkflow specializes OperationalWorkflow {
+        attribute procedureCode : TerminologyCode[0..1];
+        attribute bodySiteCode : TerminologyCode[0..1];
+        attribute clinicalObjective : String;
+        attribute anesthesiaRequirement : String;
+        attribute typicalDuration : String;
+    }
+}

package/examples/extensions/template/memo.package.yaml

@@ -0,0 +1,9 @@
+name: "{{name}}"
+version: "0.1.0"
+type: methodology
+extends: "@memoarchitect/methodology-default"
+sysmlDir: "./src"
+description: "MEMO methodology extension"
+license: "MIT"
+tags: ["memo", "methodology", "extension"]
+usage: ["extension"]

package/examples/extensions/template/src/extension.sysml

@@ -0,0 +1,15 @@
+// Replace the package name and included module with extension-specific names.
+package memo_extension_template {
+    private import ScalarValues::*;
+    private import memo_methodology_core::*;
+
+    part extensionMethod : MethodologyDefinition {
+        attribute :>> id = "EXT-METH-001";
+        attribute :>> name = "ExtensionMethod";
+        attribute :>> version = "0.1.0";
+        attribute :>> domain = "project extension";
+        attribute :>> description = "Adds a project or domain package to the selected MEMO methodology.";
+        attribute :>> baseMethodName = "MedicalDeviceLightDefault";
+        attribute :>> includedModule = "replace_with_extension_package";
+    }
+}

package/examples/functional-logical-physical/README.md

@@ -0,0 +1,7 @@
+# Functional, logical, physical
+
+A focused MEMO example separating functional, logical, and physical design.
+
+- `model/functional_logical_physical.sysml` is the public parent package.
+- `model/catalog/` holds the canonical model elements.
+- `model/viewpoints/` holds diagram views of that catalog.

package/examples/functional-logical-physical/model/catalog/functional_logical_physical.sysml

@@ -0,0 +1,50 @@
+// Focused example: the realization graph across perspectives.
+// One function is allocated to a logical component and realized by BOTH a
+// software module and a mechanical part — realization is a many-to-many
+// graph, and no layer is a mandatory pipeline stage.
+package memo_examples_functional_logical_physical {
+    private import ScalarValues::*;
+
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_architecture_functional_functions::*;
+    private import memo_architecture_logical_structure::*;
+    private import memo_architecture_implementation_software_structure::*;
+    private import memo_architecture_implementation_hardware_structure::*;
+
+    // Operational world: what the clinician does.
+    action actOcclusionResponse : OperationalActivity {
+        attribute :>> id = "FLP-ACT-001"; attribute :>> name = "RespondToLineOcclusion";
+        attribute :>> criticality = CriticalityKind::high;
+    }
+
+    // Functional: technology-independent responsibility.
+    part fnLimitLinePressure : SystemFunction {
+        attribute :>> id = "FLP-FN-001"; attribute :>> name = "LimitLinePressure";
+        attribute :>> criticality = CriticalityKind::high;
+    }
+    connection : Enables connect enabling ::> fnLimitLinePressure to enabled ::> actOcclusionResponse;
+
+    // Logical: solution structure, still technology-independent.
+    part lcPressureProtection : LogicalComponent {
+        attribute :>> id = "FLP-LC-001"; attribute :>> name = "PressureProtectionElement";
+        attribute :>> controlledVariable = "line pressure";
+    }
+    connection : AllocatedTo connect function ::> fnLimitLinePressure to allocatedElement ::> lcPressureProtection;
+
+    // Implementation: the SAME logical element is realized by software
+    // (pressure-limit supervision) AND mechanics (mechanical relief valve).
+    part swPressureSupervisor : SoftwareModule {
+        attribute :>> id = "FLP-SW-001"; attribute :>> name = "PressureSupervisor";
+        attribute :>> responsibility = "Pause pumping when measured pressure exceeds threshold.";
+        attribute :>> safetyClass = SafetyClassKind::C;
+    }
+    part mechReliefValve : MechanicalPart {
+        attribute :>> id = "FLP-HW-001"; attribute :>> name = "MechanicalReliefValve";
+        attribute :>> mechanicalFunction = "vents line pressure above mechanical set point, independent of software";
+        attribute :>> patientContact = false;
+    }
+    connection : Realizes connect realizing ::> swPressureSupervisor to realized ::> lcPressureProtection;
+    connection : Realizes connect realizing ::> mechReliefValve to realized ::> lcPressureProtection;
+}

package/examples/functional-logical-physical/model/functional_logical_physical.sysml

@@ -0,0 +1,3 @@
+package memo_examples_functional_logical_physical_parent {
+    public import memo_examples_functional_logical_physical::*;
+}

package/examples/functional-logical-physical/model/viewpoints/functional_logical_physical_overview.sysml

@@ -0,0 +1,6 @@
+package memo_examples_functional_logical_physical_viewpoints {
+    private import memo_examples_functional_logical_physical::*;
+    private import memo_viewpoints_definitions::*;
+    private import memo_core_enumerations::*;
+    view functionalLogicalPhysicalOverview : MemoDiagramView { expose memo_examples_functional_logical_physical::*; attribute depth = 2; attribute :>> title = "Function to Physical Realization"; attribute :>> viewKind = DiagramViewKind::general; attribute :>> diagramType = "bdd"; }
+}

package/examples/gpca-pump/README.md

@@ -0,0 +1,26 @@
+# GPCA Pump Reference Example
+
+This is the complete MEMO reference model. It demonstrates scenario-driven
+modelling for a generic patient-controlled analgesia infusion pump.
+
+Start with `ucDeliverPcaTherapy` in `model/catalog/gpca_operational.sysml`:
+
+1. The use case states the clinical goal.
+2. `wfPrepareAndStartTherapy`, `wfManageActiveTherapy`, and
+   `wfRespondToTherapyAlarm` are the workflows that support it.
+3. The operational scenarios select normal, alternate, exception, and recovery
+   paths through those workflows.
+4. The selected path connects to the explicit ISO 14971 chain
+   (`HazardCause` → `Hazard` → `SequenceOfEvents` →
+   `HazardousSituation` → `Harm`), initial and residual risk,
+   `RiskControlMeasure`, architecture, verification, and evidence.
+
+## Layout
+
+- `model/catalog/` — canonical model elements, grouped by concern.
+- `model/views/` — diagram and document views; each answers a review question.
+- `methodology/` — GPCA-specific methodology and profile content.
+- `dhf/` — document templates and generated-document material.
+
+Read the detailed walkthrough at `docs/examples/gpca-walkthrough.md` before
+browsing the full catalog.

package/examples/gpca-pump/dhf/documents/DOC-RMP-001.md

@@ -131,7 +131,7 @@ empty: "No hazardous situations defined."
 ### 5.3 Risk Control Measures
 
 ```memo-query
-kind: RiskControl
+kind: RiskControlMeasure
 display: table
 columns: name, layer, doc
 sort: name

package/examples/gpca-pump/memo.config.yaml

@@ -4,6 +4,6 @@ projectName: gpca-pump
 projectType: device
 
 # Phase H: project pins the GPCA-specific methodology.
-# @memo/methodology-gpca extends @memo/methodology-default and subtracts
+# @memoarchitect/methodology-gpca extends @memoarchitect/methodology-default and subtracts
 # cybersecurity and SOUP for the non-networked prototype variant.
-methodology: "@memo/methodology-gpca@^0.4.6"
+methodology: "@memoarchitect/methodology-gpca@^0.6.0"

package/examples/gpca-pump/methodology/gpca_profiles.sysml

@@ -10,7 +10,7 @@ package memo_examples_gpca_pump_methodology_gpca_profiles {
         attribute :>> name = "GPCAPrototypeMethodology";
         attribute :>> version = "1.0";
         attribute :>> domain = "medical device modeling";
-        attribute :>> description = "GPCA infusion pump methodology — subtraction-based tailoring for non-networked prototype. Excludes cybersecurity layer and SOUPComponent.";
+        attribute :>> description = "GPCA infusion pump methodology — subtraction-based tailoring for non-networked prototype. Excludes cybersecurity layer and SOUP modules.";
         attribute :>> baseMethodName = "MedicalDeviceLightDefault";
     }
 

package/examples/gpca-pump/methodology/gpca_scope.sysml

@@ -18,8 +18,8 @@ package memo_examples_gpca_pump_methodology_gpca_scope {
 
         attribute :>> includedViewpointType = "VP-CTX; VP-LOG; VP-RISK";
 
-        attribute :>> excludedKind = "CybersecurityAsset; AttackSurface; Threat; Vulnerability; ThreatScenario; CyberHazard; CyberRisk; CyberMitigation; SecurityRequirement; TrustBoundary; SecurityClaim; SOUPComponent";
+        attribute :>> excludedKind = "CybersecurityAsset; AttackSurface; Threat; Vulnerability; ThreatScenario; CyberHazard; CyberRisk; CyberMitigation; SecurityRequirement; TrustBoundary; SecurityClaim; SoftwareModule[moduleKind=soup]";
 
-        attribute :>> description = "GPCA prototype methodology — subtracts cybersecurity layer (non-networked device) and SOUPComponent (no SOUP in prototype). Derived from default methodology by exclusion.";
+        attribute :>> description = "GPCA prototype methodology — subtracts cybersecurity layer (non-networked device) and SOUP modules (no SOUP in prototype). Derived from default methodology by exclusion.";
     }
 }

package/examples/gpca-pump/model/catalog/gpca_analysis.sysml

@@ -1,7 +1,7 @@
 package memo_examples_gpca_pump_model_catalog_gpca_analysis {
     private import ScalarValues::*;
 
-    private import memo_architecture_analysis::*;
+    private import memo_assurance_safety_risk_analysis::*;
     private import memo_core_enumerations::*;
 
     // ── FMEA (IEC 60812) ────────────────────────────────────────

package/examples/gpca-pump/model/catalog/gpca_architecture.sysml

@@ -1,8 +1,8 @@
 package memo_examples_gpca_pump_model_catalog_gpca_architecture {
     private import ScalarValues::*;
 
-    private import memo_architecture_hardware_structure::*;
-    private import memo_architecture_software_structure::*;
+    private import memo_architecture_implementation_hardware_structure::*;
+    private import memo_architecture_implementation_software_structure::*;
     private import memo_architecture_logical_structure::*;
     private import memo_core_relationships::*;
     private import memo_core_enumerations::*;
@@ -190,49 +190,49 @@ package memo_examples_gpca_pump_model_catalog_gpca_architecture {
         attribute :>> complexity = ComplexityKind::high;
         attribute :>> operatingSystem = "synchronous data-flow execution; AADL immediate port semantics (source specifies no timing)";
     }
-    part tlm : SoftwareComponent {
+    part tlm : SoftwareModule {
         attribute :>> id = "SW-001";
         attribute :>> name = "Top_Level_Mode";
         attribute :>> responsibility = "Ensure system ON/OFF behavior and startup/shutdown checks.";
         attribute :>> safetyClass = SafetyClassKind::C;
         attribute :>> complexity = ComplexityKind::medium;
     }
-    part config : SoftwareComponent {
+    part config : SoftwareModule {
         attribute :>> id = "SW-002";
         attribute :>> name = "Config";
         attribute :>> responsibility = "Prescription entry, drug-library limit checking, confirmation, and persistent storage.";
         attribute :>> safetyClass = SafetyClassKind::C;
         attribute :>> complexity = ComplexityKind::high;
     }
-    part alarm : SoftwareComponent {
+    part alarm : SoftwareModule {
         attribute :>> id = "SW-003";
         attribute :>> name = "Alarm";
         attribute :>> responsibility = "Monitor and notify exceptional conditions.";
         attribute :>> safetyClass = SafetyClassKind::C;
         attribute :>> complexity = ComplexityKind::high;
     }
-    part logging : SoftwareComponent {
+    part logging : SoftwareModule {
         attribute :>> id = "SW-004";
         attribute :>> name = "Logging";
         attribute :>> responsibility = "Append-only event log of doses, mode changes, alarms, and configuration changes.";
         attribute :>> safetyClass = SafetyClassKind::B;
         attribute :>> complexity = ComplexityKind::medium;
     }
-    part infusionMgr : SoftwareComponent {
+    part infusionMgr : SoftwareModule {
         attribute :>> id = "SW-005";
         attribute :>> name = "Infusion_Manager";
         attribute :>> responsibility = "Handle drug infusion commands and therapy parameters.";
         attribute :>> safetyClass = SafetyClassKind::C;
         attribute :>> complexity = ComplexityKind::high;
     }
-    part systemMonitor : SoftwareComponent {
+    part systemMonitor : SoftwareModule {
         attribute :>> id = "SW-006";
         attribute :>> name = "System_Monitor";
         attribute :>> responsibility = "POST, periodic CPU/RAM/ROM checks, watchdog kicking, and battery supervision.";
         attribute :>> safetyClass = SafetyClassKind::C;
         attribute :>> complexity = ComplexityKind::medium;
     }
-    part systemStatus : SoftwareComponent {
+    part systemStatus : SoftwareModule {
         attribute :>> id = "SW-007";
         attribute :>> name = "System_Status";
         attribute :>> responsibility = "Maintain the shared system status vector (Reservoir_Volume, Volume_Infused, Reservoir_Empty, In_Therapy) consumed by Alarm, Config, and Infusion_Manager.";
@@ -240,7 +240,7 @@ package memo_examples_gpca_pump_model_catalog_gpca_architecture {
         attribute :>> complexity = ComplexityKind::medium;
         attribute :>> sourceReference = "CITE-002: CriSys GPCA AADL v2.0, packages/System_Status.aadl";
     }
-    part outputBus : SoftwareComponent {
+    part outputBus : SoftwareModule {
         attribute :>> id = "SW-008";
         attribute :>> name = "OutputBus";
         attribute :>> responsibility = "Aggregate all subsystem outputs into the single GPCA_SW_OUT output vector (mode, commanded flow rate, notifications, prescription echo, status).";

package/examples/gpca-pump/model/catalog/gpca_behavior_actions.sysml

@@ -2,7 +2,8 @@ package memo_examples_gpca_pump_model_catalog_gpca_behavior_actions {
     private import ScalarValues::*;
     private import memo_examples_gpca_pump_model_catalog_gpca_architecture::*;
 
-    private import memo_architecture_behavior::*;
+    private import memo_architecture_functional_behavior::*;
+    private import memo_architecture_logical_interfaces::*;
     private import memo_core_enumerations::*;
 
     // ═════════════════════════════════════════════════════════════
@@ -16,11 +17,21 @@ package memo_examples_gpca_pump_model_catalog_gpca_behavior_actions {
     // ═════════════════════════════════════════════════════════════
 
     // ── Action definitions (typed steps with parameters) ────────
-    item def SensorStatusVector;
-    item def AlarmSignal;
-    item def BolusRequestSignal;
-    item def FlowCommand;
-    item def TherapyEventRecord;
+    item def SensorStatusVector specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::data;
+    }
+    item def AlarmSignal specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::signal;
+    }
+    item def BolusRequestSignal specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::signal;
+    }
+    item def FlowCommand specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::command;
+    }
+    item def TherapyEventRecord specializes InterfaceItem {
+        attribute :>> itemKind = InterfaceItemKind::event;
+    }
 
     action def AcquireSensorData {
         out sensorStatus : SensorStatusVector;