fix: align mechanical dynamic port validation

app/simulation/components/amesim/mechanical/translational.py

@@ -1129,14 +1129,29 @@ class AmesimLmechn1(AlgebraicComponent):
                 raise ValueError(f"LMECHN1 {integer_name} must be an integer.")
         return cls(name=name, medium=medium, v1=parameters["v1"], sum=parameters["sum"])
 
-    @property
-    def active_ports(self) -> tuple[str, ...]:
-        return tuple(f"port_{index}" for index in range(1, self.v1 + 2))
+    @classmethod
+    def active_port_definitions_for_parameters(
+        cls,
+        parameters: Mapping[str, float],
+    ) -> tuple[PortDefinition, ...]:
+        right_port_count = float(parameters["v1"])
+        if not right_port_count.is_integer():
+            raise ValueError("LMECHN1 v1 must be an integer.")
+        count = int(right_port_count)
+        if count < 1 or count > 20:
+            raise ValueError("LMECHN1 v1 must be between 1 and 20.")
+        return cls.PORTS[: count + 1]
 
     @property
     def active_port_definitions(self) -> tuple[PortDefinition, ...]:
         return self.PORTS[: self.v1 + 1]
 
+    @property
+    def active_ports(self) -> tuple[str, ...]:
+        return tuple(
+            definition.name for definition in self.active_port_definitions
+        )
+
     @property
     def reference_port_name(self) -> str:
         return f"port_{self.v1 + 1}"

app/simulation/core/base.py

@@ -44,6 +44,15 @@ class Component(ABC):
             if port.definition is not None
         )
 
+    @classmethod
+    def active_port_definitions_for_parameters(
+        cls,
+        parameters: Mapping[str, float],
+    ) -> tuple[PortDefinition, ...]:
+        """Declared ports enabled by one normalized parameter set."""
+
+        return cls.PORTS
+
     @property
     def active_port_definitions(self) -> tuple[PortDefinition, ...]:
         """Instance ports that participate in execution and result reporting."""

app/simulation/registry.py

@@ -73,6 +73,16 @@ class ComponentModelSpec:
     def parameter_by_name(self) -> dict[str, ParameterDefinition]:
         return {parameter.name: parameter for parameter in self.parameters}
 
+    def active_ports(
+        self,
+        values: Mapping[str, float],
+    ) -> tuple[PortDefinition, ...]:
+        resolved = {
+            parameter.name: values.get(parameter.name, parameter.default)
+            for parameter in self.parameters
+        }
+        return self.component_class.active_port_definitions_for_parameters(resolved)
+
     def as_catalog_dict(self) -> dict[str, object]:
         category = self.library.category_by_id[self.display.category_id]
         display_ports = self.display.port_by_name

app/simulation/systems/network.py

@@ -96,8 +96,8 @@ class SimulationNetwork:
                 f"Cannot connect component {endpoint_a.component} to itself."
             )
 
-        first_port = self._port_for(endpoint_a)
-        second_port = self._port_for(endpoint_b)
+        first_port = self._active_port_for(endpoint_a)
+        second_port = self._active_port_for(endpoint_b)
         first_definition = first_port.definition
         second_definition = second_port.definition
         if first_definition is None or second_definition is None:
@@ -168,6 +168,20 @@ class SimulationNetwork:
             raise ValueError(f"Unknown component: {endpoint.component}.") from exc
         return component.get_port(endpoint.port)
 
+    def _active_port_for(self, endpoint: Endpoint) -> PortState:
+        try:
+            component = self.components[endpoint.component]
+        except KeyError as exc:
+            raise ValueError(f"Unknown component: {endpoint.component}.") from exc
+        active_names = {
+            definition.name for definition in component.active_port_definitions
+        }
+        if endpoint.port not in active_names:
+            raise ValueError(
+                f"Port {endpoint} is not active for the component's current parameters."
+            )
+        return component.get_port(endpoint.port)
+
     def connection_equation_residuals(self) -> tuple[EquationResidual, ...]:
         """Evaluate connector equations that have a direct scalar residual.