linkforge-core 1.4.0__tar.gz → 1.4.2__tar.gz

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/.gitignore

@@ -105,3 +105,6 @@ site/
 
 # Linting Tools
 actionlint
+
+# Blender Development Symlinks
+platforms/blender/src/linkforge/blender/core

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linkforge-core
-Version: 1.4.0
+Version: 1.4.2
 Summary: LinkForge Core: Programmable IR and Physical Validation Engine for Robotics
 Project-URL: Homepage, https://github.com/arounamounchili/linkforge
 Project-URL: Documentation, https://linkforge.readthedocs.io/
@@ -37,17 +37,13 @@ Description-Content-Type: text/markdown
   <a href="https://github.com/arounamounchili/linkforge/blob/main/core/LICENSE"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License"></a>
 </p>
 
----
-
-## 🔭 What Is LinkForge Core?
+## What Is LinkForge Core?
 
 Writing and maintaining URDF or SRDF by hand is fragile: inertia values are guessed, collision geometries drift, and physics bugs surface only after a simulator crash (or worse, on hardware). LinkForge Core solves this by treating your robot as **source code with physical constraints**, not a static XML document.
 
 It provides a mathematically rigorous, zero-dependency Intermediate Representation (IR) engine with hardened physical validation, scientific inertia solvers (Mirtich / Sylvester), and lossless round-trip translation between **URDF**, **XACRO**, and **SRDF**.
 
----
-
-## 📦 Installation
+## Installation
 
 ```bash
 pip install linkforge-core
@@ -55,18 +51,14 @@ pip install linkforge-core
 
 Zero external dependencies. No Blender, no ROS installation, no C++ compilation required.
 
----
-
-## ⚡ Why LinkForge Core?
+## Why LinkForge Core?
 
-- **⚖️ Physically Guaranteed Sim Stability**: Zero-mass links or unphysical inertia tensors cause simulators like Gazebo or Isaac Sim to crash. LinkForge Core uses the **Mirtich algorithm** (Divergence Theorem) to calculate exact inertia properties from geometries, validated against **Sylvester's Criterion** to ensure physical validity.
-- **🔌 Standardized & Namespaced Assembly**: Easily compile complex robots, merge multiple sub-assemblies (e.g. attaching a gripper to an arm), and apply joint prefixing and limits programmatically using the fluent **Composer API**.
-- **🛡️ Hardened Sandboxed Security**: Safely parse untrusted third-party robot descriptions. LinkForge Core blocks path-traversal attacks and restrains file reading to designated package boundaries.
-- **📦 Light & Portable**: Zero external dependencies. No C++ compilation required, making it highly portable across standard Python environments, CI/CD pipelines, and HPC clusters.
+- **Physically Guaranteed Sim Stability**: Zero-mass links or unphysical inertia tensors cause simulators like Gazebo or Isaac Sim to crash. LinkForge Core uses the **Mirtich algorithm** (Divergence Theorem) to calculate exact inertia properties from geometries, validated against **Sylvester's Criterion** to ensure physical validity.
+- **Standardized & Namespaced Assembly**: Easily compile complex robots, merge multiple sub-assemblies (e.g. attaching a gripper to an arm), and apply joint prefixing and limits programmatically using the fluent **Composer API**.
+- **Hardened Sandboxed Security**: Safely parse untrusted third-party robot descriptions. LinkForge Core blocks path-traversal attacks and restrains file reading to designated package boundaries.
+- **Light & Portable**: Zero external dependencies. No C++ compilation required, making it highly portable across standard Python environments, CI/CD pipelines, and HPC clusters.
 
----
-
-## 🚀 Quickstart
+## Quickstart
 
 LinkForge Core exposes a flat, curated public API. No nested import paths required.
 
@@ -100,9 +92,7 @@ builder.link("upper_arm", parent="base_link") \
 urdf_xml = builder.export_urdf()
 ```
 
----
-
-## 💎 Key Capabilities
+## Key Capabilities
 
 ### Parse, Validate & Compile (Full Round-Trip)
 
@@ -126,8 +116,6 @@ else:
         print(f"  [{issue.code.name}] {issue.message} on {issue.affected_objects}")
 ```
 
----
-
 ### MoveIt 2 & SRDF Semantic Composition
 
 Programmatically compose MoveIt 2 planning groups, end-effectors, and self-collision matrices for SRDF without manually editing XML:
@@ -162,8 +150,6 @@ semantic = read_srdf("my_robot.srdf")
 write_srdf(semantic, "my_robot_updated.srdf")
 ```
 
----
-
 ### Exact Solid-Body Inertia Solver
 
 Compute principal moments of inertia and Center of Mass offsets for primitives or complex triangle meshes, hardened with local origin conditioning for floating-point accuracy:
@@ -176,8 +162,6 @@ geometry = Box(size=Vector3(1.0, 0.5, 0.3))
 inertia = calculate_inertia(geometry, mass=10.0)
 ```
 
----
-
 ### Sensor Suite
 
 Define cameras, LiDAR, IMU, GPS, and force/torque sensors with configurable noise models directly in the IR:
@@ -199,8 +183,6 @@ builder.link("camera_link", parent="base_link") \
     .commit()
 ```
 
----
-
 ### Headless Use in CI / ML Pipelines
 
 `linkforge-core` has zero GUI dependencies, making it ideal for headless environments:
@@ -227,10 +209,8 @@ pip install linkforge-core
 python ci_validate.py
 ```
 
----
-
-## 📚 Resources & Documentation
+## Resources & Documentation
 
-- **📚 Extensive Documentation**: Read the tutorials and how-to guides at [linkforge.readthedocs.io](https://linkforge.readthedocs.io/).
-- **🐙 Open Source Repository**: View source, open issues, and join discussions on [GitHub](https://github.com/arounamounchili/linkforge).
-- **📄 License**: Standard open-source **[Apache-2.0 License](https://github.com/arounamounchili/linkforge/blob/main/core/LICENSE)**.
+- **Extensive Documentation**: Read the tutorials and how-to guides at [linkforge.readthedocs.io](https://linkforge.readthedocs.io/).
+- **Open Source Repository**: View source, open issues, and join discussions on [GitHub](https://github.com/arounamounchili/linkforge).
+- **License**: Standard open-source **[Apache-2.0 License](https://github.com/arounamounchili/linkforge/blob/main/core/LICENSE)**.

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/README.md

@@ -8,17 +8,13 @@
   <a href="https://github.com/arounamounchili/linkforge/blob/main/core/LICENSE"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License"></a>
 </p>
 
----
-
-## 🔭 What Is LinkForge Core?
+## What Is LinkForge Core?
 
 Writing and maintaining URDF or SRDF by hand is fragile: inertia values are guessed, collision geometries drift, and physics bugs surface only after a simulator crash (or worse, on hardware). LinkForge Core solves this by treating your robot as **source code with physical constraints**, not a static XML document.
 
 It provides a mathematically rigorous, zero-dependency Intermediate Representation (IR) engine with hardened physical validation, scientific inertia solvers (Mirtich / Sylvester), and lossless round-trip translation between **URDF**, **XACRO**, and **SRDF**.
 
----
-
-## 📦 Installation
+## Installation
 
 ```bash
 pip install linkforge-core
@@ -26,18 +22,14 @@ pip install linkforge-core
 
 Zero external dependencies. No Blender, no ROS installation, no C++ compilation required.
 
----
-
-## ⚡ Why LinkForge Core?
+## Why LinkForge Core?
 
-- **⚖️ Physically Guaranteed Sim Stability**: Zero-mass links or unphysical inertia tensors cause simulators like Gazebo or Isaac Sim to crash. LinkForge Core uses the **Mirtich algorithm** (Divergence Theorem) to calculate exact inertia properties from geometries, validated against **Sylvester's Criterion** to ensure physical validity.
-- **🔌 Standardized & Namespaced Assembly**: Easily compile complex robots, merge multiple sub-assemblies (e.g. attaching a gripper to an arm), and apply joint prefixing and limits programmatically using the fluent **Composer API**.
-- **🛡️ Hardened Sandboxed Security**: Safely parse untrusted third-party robot descriptions. LinkForge Core blocks path-traversal attacks and restrains file reading to designated package boundaries.
-- **📦 Light & Portable**: Zero external dependencies. No C++ compilation required, making it highly portable across standard Python environments, CI/CD pipelines, and HPC clusters.
+- **Physically Guaranteed Sim Stability**: Zero-mass links or unphysical inertia tensors cause simulators like Gazebo or Isaac Sim to crash. LinkForge Core uses the **Mirtich algorithm** (Divergence Theorem) to calculate exact inertia properties from geometries, validated against **Sylvester's Criterion** to ensure physical validity.
+- **Standardized & Namespaced Assembly**: Easily compile complex robots, merge multiple sub-assemblies (e.g. attaching a gripper to an arm), and apply joint prefixing and limits programmatically using the fluent **Composer API**.
+- **Hardened Sandboxed Security**: Safely parse untrusted third-party robot descriptions. LinkForge Core blocks path-traversal attacks and restrains file reading to designated package boundaries.
+- **Light & Portable**: Zero external dependencies. No C++ compilation required, making it highly portable across standard Python environments, CI/CD pipelines, and HPC clusters.
 
----
-
-## 🚀 Quickstart
+## Quickstart
 
 LinkForge Core exposes a flat, curated public API. No nested import paths required.
 
@@ -71,9 +63,7 @@ builder.link("upper_arm", parent="base_link") \
 urdf_xml = builder.export_urdf()
 ```
 
----
-
-## 💎 Key Capabilities
+## Key Capabilities
 
 ### Parse, Validate & Compile (Full Round-Trip)
 
@@ -97,8 +87,6 @@ else:
         print(f"  [{issue.code.name}] {issue.message} on {issue.affected_objects}")
 ```
 
----
-
 ### MoveIt 2 & SRDF Semantic Composition
 
 Programmatically compose MoveIt 2 planning groups, end-effectors, and self-collision matrices for SRDF without manually editing XML:
@@ -133,8 +121,6 @@ semantic = read_srdf("my_robot.srdf")
 write_srdf(semantic, "my_robot_updated.srdf")
 ```
 
----
-
 ### Exact Solid-Body Inertia Solver
 
 Compute principal moments of inertia and Center of Mass offsets for primitives or complex triangle meshes, hardened with local origin conditioning for floating-point accuracy:
@@ -147,8 +133,6 @@ geometry = Box(size=Vector3(1.0, 0.5, 0.3))
 inertia = calculate_inertia(geometry, mass=10.0)
 ```
 
----
-
 ### Sensor Suite
 
 Define cameras, LiDAR, IMU, GPS, and force/torque sensors with configurable noise models directly in the IR:
@@ -170,8 +154,6 @@ builder.link("camera_link", parent="base_link") \
     .commit()
 ```
 
----
-
 ### Headless Use in CI / ML Pipelines
 
 `linkforge-core` has zero GUI dependencies, making it ideal for headless environments:
@@ -198,10 +180,8 @@ pip install linkforge-core
 python ci_validate.py
 ```
 
----
-
-## 📚 Resources & Documentation
+## Resources & Documentation
 
-- **📚 Extensive Documentation**: Read the tutorials and how-to guides at [linkforge.readthedocs.io](https://linkforge.readthedocs.io/).
-- **🐙 Open Source Repository**: View source, open issues, and join discussions on [GitHub](https://github.com/arounamounchili/linkforge).
-- **📄 License**: Standard open-source **[Apache-2.0 License](https://github.com/arounamounchili/linkforge/blob/main/core/LICENSE)**.
+- **Extensive Documentation**: Read the tutorials and how-to guides at [linkforge.readthedocs.io](https://linkforge.readthedocs.io/).
+- **Open Source Repository**: View source, open issues, and join discussions on [GitHub](https://github.com/arounamounchili/linkforge).
+- **License**: Standard open-source **[Apache-2.0 License](https://github.com/arounamounchili/linkforge/blob/main/core/LICENSE)**.

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "linkforge-core"
-version = "1.4.0" # x-release-please-version
+version = "1.4.2" # x-release-please-version
 description = "LinkForge Core: Programmable IR and Physical Validation Engine for Robotics"
 readme = "README.md"
 license = "Apache-2.0"

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/__init__.py

@@ -11,7 +11,7 @@ for parsing, generating, and validating robot descriptions across formats.
 from __future__ import annotations
 
 # Versioning
-__version__ = "1.4.0"  # x-release-please-version
+__version__ = "1.4.2"  # x-release-please-version
 
 # Sub-Package Exposure
 # (Ensures lf.models, lf.parsers, etc. are accessible via dot-notation)
@@ -47,9 +47,9 @@ from .composer import (
 
 # Core Infrastructure: Constants and Exceptions
 from .constants import (
-    DEFAULT_GRAVITY,
     DEFAULT_LINK_MASS,
     EPSILON,
+    GRAVITY_ENABLED,
     PI,
 )
 from .exceptions import (
@@ -293,7 +293,7 @@ __all__ = [
     # Constants
     "PI",
     "EPSILON",
-    "DEFAULT_GRAVITY",
+    "GRAVITY_ENABLED",
     "DEFAULT_LINK_MASS",
     # Logging
     "get_logger",

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/_utils/xml_utils.py

@@ -136,11 +136,14 @@ def serialize_xml(
 
     # Ensure namespaces are explicitly present on root if ElementTree dropped them
     if namespaces:
+        import re
+
         for prefix, uri in namespaces.items():
             ns_attr = f'xmlns:{prefix}="{uri}"'
-            # Using a more robust check for root tag insertion
-            if ns_attr not in xml_str and "<robot" in xml_str:
-                xml_str = xml_str.replace("<robot", f"<robot {ns_attr}", 1)
+            if ns_attr not in xml_str:
+                xml_str = re.sub(
+                    rf"<{element.tag}\b", f"<{element.tag} {ns_attr}", xml_str, count=1
+                )
 
     return get_xml_header(element, version) + xml_str
 
@@ -350,28 +353,6 @@ def xml_add_text(parent: ET.Element, tag: str, value: Any) -> ET.Element:
     return elem
 
 
-def xml_add_vector(
-    parent: ET.Element,
-    tag: str,
-    vector: Vector3,
-    formatter: Callable[[float], str],
-) -> ET.Element:
-    """Create a sub-element for a vector relying on a formatter for the values.
-
-    Args:
-        parent: The parent XML element.
-        tag: The tag name for the new element.
-        vector: The Vector3 object containing the values.
-        formatter: A callable that takes a float and returns a string (e.g., format_float).
-
-    Returns:
-        The newly created XML element with the formatted text string.
-    """
-    # Create text from formatted components
-    text_val = f"{formatter(vector.x)} {formatter(vector.y)} {formatter(vector.z)}"
-    return xml_add_text(parent, tag, text_val)
-
-
 def create_xml_element(
     parent: ET.Element,
     tag: str,

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/composer/link_builder.py

@@ -983,7 +983,7 @@ class LinkBuilder:
                 if l_state.inertial_origin is None:
                     l_state.inertial_origin = source_origin
             else:
-                l_state.inertia = InertiaTensor.zero()
+                l_state.inertia = InertiaTensor.stability_floor()
 
         return Inertial(
             mass=l_state.mass,

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/composer/semantic_builder.py

@@ -36,6 +36,10 @@ class SemanticBuilder:
         """Initialize semantic builder."""
         self._builder = builder
 
+    def done(self) -> IComposer:
+        """Return to the parent RobotBuilder."""
+        return self._builder
+
     def group(
         self,
         name: str,
@@ -45,7 +49,7 @@ class SemanticBuilder:
         subgroups: list[str] | None = None,
         base_link: str | None = None,
         tip_link: str | None = None,
-    ) -> IComposer:
+    ) -> SemanticBuilder:
         """Define a planning group for MoveIt.
 
         Args:
@@ -75,11 +79,11 @@ class SemanticBuilder:
 
         semantic = self._builder.robot.semantic
         self._builder.robot.semantic = replace(semantic, groups=tuple(semantic.groups) + (group,))
-        return self._builder
+        return self
 
     def group_state(
         self, name: str, group: str, values: dict[str, float | tuple[float, ...]]
-    ) -> IComposer:
+    ) -> SemanticBuilder:
         """Define a named state (e.g. 'home') for a planning group.
 
         Args:
@@ -98,11 +102,11 @@ class SemanticBuilder:
         self._builder.robot.semantic = replace(
             semantic, group_states=tuple(semantic.group_states) + (state,)
         )
-        return self._builder
+        return self
 
     def end_effector(
         self, name: str, group: str, parent_link: str, parent_group: str | None = None
-    ) -> IComposer:
+    ) -> SemanticBuilder:
         """Define an end effector for MoveIt.
 
         Args:
@@ -119,9 +123,9 @@ class SemanticBuilder:
         self._builder.robot.semantic = replace(
             semantic, end_effectors=tuple(semantic.end_effectors) + (ee,)
         )
-        return self._builder
+        return self
 
-    def passive_joint(self, name: str) -> IComposer:
+    def passive_joint(self, name: str) -> SemanticBuilder:
         """Mark a joint as passive (not actuated) for MoveIt.
 
         Args:
@@ -135,7 +139,7 @@ class SemanticBuilder:
         self._builder.robot.semantic = replace(
             semantic, passive_joints=tuple(semantic.passive_joints) + (pj,)
         )
-        return self._builder
+        return self
 
     def virtual_joint(
         self,
@@ -143,7 +147,7 @@ class SemanticBuilder:
         child_link: str,
         parent_frame: str = "world",
         joint_type: str = SRDF_VJOIN_FIXED,
-    ) -> IComposer:
+    ) -> SemanticBuilder:
         """Define a virtual joint connecting the robot to the world frame.
 
         Args:
@@ -162,11 +166,11 @@ class SemanticBuilder:
         self._builder.robot.semantic = replace(
             semantic, virtual_joints=tuple(semantic.virtual_joints) + (vj,)
         )
-        return self._builder
+        return self
 
     def disable_collisions(
         self, link1: str, link2: str, reason: str = SRDF_REASON_ADJACENT
-    ) -> IComposer:
+    ) -> SemanticBuilder:
         """Instruct MoveIt to ignore collisions between two specific links.
 
         Args:
@@ -181,9 +185,11 @@ class SemanticBuilder:
         self._builder.robot.semantic = replace(
             semantic, disabled_collisions=tuple(semantic.disabled_collisions) + (dc,)
         )
-        return self._builder
+        return self
 
-    def enable_collisions(self, link1: str, link2: str, reason: str | None = None) -> IComposer:
+    def enable_collisions(
+        self, link1: str, link2: str, reason: str | None = None
+    ) -> SemanticBuilder:
         """Explicitly re-enable collision checking between two specific links.
 
         Args:
@@ -198,9 +204,9 @@ class SemanticBuilder:
         self._builder.robot.semantic = replace(
             semantic, enabled_collisions=tuple(semantic.enabled_collisions) + (ec,)
         )
-        return self._builder
+        return self
 
-    def disable_default_collisions(self, link: str) -> IComposer:
+    def disable_default_collisions(self, link: str) -> SemanticBuilder:
         """Disable all default collisions for a specific link.
 
         Args:
@@ -214,9 +220,9 @@ class SemanticBuilder:
             semantic,
             no_default_collision_links=tuple(semantic.no_default_collision_links) + (link,),
         )
-        return self._builder
+        return self
 
-    def joint_property(self, joint_name: str, property_name: str, value: str) -> IComposer:
+    def joint_property(self, joint_name: str, property_name: str, value: str) -> SemanticBuilder:
         """Add a custom property/metadata to a joint.
 
         Args:
@@ -232,9 +238,9 @@ class SemanticBuilder:
         self._builder.robot.semantic = replace(
             semantic, joint_properties=tuple(semantic.joint_properties) + (jp,)
         )
-        return self._builder
+        return self
 
-    def approximate_link_collision(self, link: str, spheres: list[SrdfSphere]) -> IComposer:
+    def approximate_link_collision(self, link: str, spheres: list[SrdfSphere]) -> SemanticBuilder:
         """Add sphere-based collision approximation for a link.
 
         Args:
@@ -250,4 +256,4 @@ class SemanticBuilder:
             semantic,
             link_sphere_approximations=tuple(semantic.link_sphere_approximations) + (lsa,),
         )
-        return self._builder
+        return self

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/constants.py

@@ -75,10 +75,6 @@ MAX_XML_DEPTH: Final[int] = 2000
 
 # Geometric and Mesh thresholds
 DEGENERATE_VOL_THRESHOLD: Final[float] = 1e-12  # m³
-NEGATIVE_INERTIA_THRESHOLD: Final[float] = -1e-06
-MESH_PROXIMITY_THRESHOLD: Final[int] = 6
-MESH_SLIVER_THRESHOLD: Final[float] = 1000.0
-MIN_MESH_AREA: Final[float] = 1e-15  # m²
 
 
 # 4. Global Physics Defaults
@@ -94,7 +90,7 @@ DEFAULT_CONTACT_KP: Final[float] = 1e12  # N/m
 DEFAULT_CONTACT_KD: Final[float] = 1.0  # N·s/m
 
 # Simulation toggles
-DEFAULT_GRAVITY: Final[bool] = True
+GRAVITY_ENABLED: Final[bool] = True
 DEFAULT_SELF_COLLIDE: Final[bool] = False
 
 
@@ -105,13 +101,11 @@ DEFAULT_SELF_COLLIDE: Final[bool] = False
 DEFAULT_LINK_MASS: Final[float] = 1.0  # kg
 DEFAULT_MATERIAL_RGBA: Final[tuple[float, float, float, float]] = (0.7, 0.7, 0.7, 1.0)
 DEFAULT_MATERIAL_RGBA_STR: Final[str] = "0.7 0.7 0.7 1.0"
-DEFAULT_MESH_SCALE_STR: Final[str] = "1 1 1"
 DEFAULT_GEOMETRY_RADIUS: Final[float] = 0.1  # m
 DEFAULT_GEOMETRY_LENGTH: Final[float] = 0.5  # m
 
 # Joint Defaults
 DEFAULT_AXIS_XYZ: Final[tuple[float, float, float]] = (0.0, 0.0, 1.0)
-DEFAULT_AXIS_XYZ_STR: Final[str] = "0 0 1"
 DEFAULT_URDF_AXIS_XYZ: Final[tuple[float, float, float]] = (1.0, 0.0, 0.0)  # URDF spec default
 DEFAULT_URDF_AXIS_XYZ_STR: Final[str] = "1 0 0"
 
@@ -146,7 +140,6 @@ CAM_FORMAT_BAYER_BGGR8: Final[str] = "BAYER_BGGR8"
 
 # LIDAR Horizontal Parameters
 DEFAULT_LIDAR_SAMPLES: Final[int] = 640
-DEFAULT_LIDAR_HORIZONTAL_RESOLUTION: Final[float] = 1.0
 DEFAULT_LIDAR_RANGE_MIN: Final[float] = 0.1  # m
 DEFAULT_LIDAR_RANGE_MAX: Final[float] = 10.0  # m
 DEFAULT_LIDAR_RANGE_RESOLUTION: Final[float] = 0.01  # m
@@ -185,6 +178,7 @@ DEFAULT_JOINT_TYPE: Final[str] = JOINT_REVOLUTE
 SENSOR_CAMERA: Final[str] = "camera"
 SENSOR_DEPTH_CAMERA: Final[str] = "depth_camera"
 SENSOR_LIDAR: Final[str] = "lidar"
+SENSOR_RAY: Final[str] = "ray"
 SENSOR_GPU_LIDAR: Final[str] = "gpu_lidar"
 SENSOR_IMU: Final[str] = "imu"
 SENSOR_GPS: Final[str] = "gps"
@@ -213,20 +207,14 @@ SRDF_VJOIN_PLANAR: Final[str] = "planar"
 SRDF_VJOIN_FLOATING: Final[str] = "floating"
 
 SRDF_REASON_ADJACENT: Final[str] = "Adjacent"
-SRDF_REASON_NEVER: Final[str] = "Never"
-SRDF_REASON_USER: Final[str] = "User"
-SRDF_REASON_DEFAULT: Final[str] = "Default"
 
 # Standard fallback names
 UNNAMED_LINK: Final[str] = "unnamed_link"
 UNNAMED_JOINT: Final[str] = "unnamed_joint"
-UNNAMED_SENSOR: Final[str] = "unnamed_sensor"
 
 # Sensor Update Rates (Industry standard defaults)
 DEFAULT_UPDATE_RATE_IMU: Final[float] = 100.0  # Hz
 DEFAULT_UPDATE_RATE_GPS: Final[float] = 5.0  # Hz
-DEFAULT_UPDATE_RATE_LIDAR: Final[float] = 30.0  # Hz
-DEFAULT_UPDATE_RATE_CAMERA: Final[float] = 30.0  # Hz
 DEFAULT_UPDATE_RATE_CONTACT: Final[float] = 50.0  # Hz
 DEFAULT_UPDATE_RATE_FORCE_TORQUE: Final[float] = 100.0  # Hz
 
@@ -261,13 +249,6 @@ GZ_SENSOR_IMU: Final[str] = "imu"
 GZ_SENSOR_CONTACT: Final[str] = "contact"
 GZ_SENSOR_FORCE_TORQUE: Final[str] = "force_torque"
 
-# Gazebo / GZ XML Elements and Attributes
-GZ_ELEM_GAZEBO: Final[str] = "gazebo"
-GZ_ELEM_SENSOR: Final[str] = "sensor"
-GZ_ELEM_PLUGIN: Final[str] = "plugin"
-GZ_ATTR_REFERENCE: Final[str] = "reference"
-COLLISION_ADJACENT: Final[str] = "Adjacent"
-
 # XACRO Parameters and Attributes
 XACRO_PARAM_NAME: Final[str] = "name"
 XACRO_PARAM_PARENT: Final[str] = "parent"

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/exceptions.py

@@ -29,14 +29,12 @@ class ValidationErrorCode(StrEnum):
     HAS_CYCLE = "has_cycle"
     NO_ROOT = "no_root"
     MULTIPLE_ROOTS = "multiple_roots"
-    DISCONNECTED = "disconnected"
 
     # Physics and Values
     OUT_OF_RANGE = "out_of_range"
     VALUE_EMPTY = "value_empty"
     INVALID_VALUE = "invalid_value"
     PHYSICS_VIOLATION = "physics_violation"
-    MATH_ERROR = "math_error"
     INERTIA_TRIANGLE_INEQUALITY = "inertia_triangle_inequality"
 
     # Mesh Topology
@@ -49,7 +47,6 @@ class ValidationErrorCode(StrEnum):
     MESH_SLIVER = "mesh_sliver"
 
     # Configuration and Misc
-    MISMATCH = "mismatch"
     GENERIC_FAILURE = "generic_failure"
 
 
@@ -114,7 +111,6 @@ class RobotPhysicsError(RobotModelError):
         self.code = code
         self.target = target
         self.value = value
-        self.raw_message = message
 
         full_msg = f"[PHYSICS_{code.name}] {message}"
         if target:
@@ -141,7 +137,6 @@ class RobotValidationError(RobotModelError):
         self.code = code
         self.target = target
         self.value = value
-        self.raw_message = message
 
         full_msg = f"[{code.name}] {message}"
         if target:
@@ -172,7 +167,6 @@ class RobotMathError(RobotModelError):
         self.code = code
         self.target = target
         self.value = value
-        self.raw_message = message
 
         full_msg = f"[MATH_{code.name}] {message}"
         if target:

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/generators/urdf_generator.py

@@ -782,45 +782,6 @@ class URDFGenerator(RobotXMLGenerator):
             bias_stddev_elem = ET.SubElement(noise_elem, "bias_stddev")
             bias_stddev_elem.text = format_float(noise.bias_stddev)
 
-    def _add_gazebo_element(self, parent: ET.Element, gazebo_elem: GazeboElement) -> None:
-        """Add Gazebo extension element to parent.
-
-        Args:
-            parent: Parent XML element
-            gazebo_elem: GazeboElement model
-
-        """
-        # Create gazebo element with optional reference attribute
-        attrib: dict[str, str] = {}
-        if gazebo_elem.reference is not None:
-            attrib["reference"] = gazebo_elem.reference
-
-        gz_elem = create_xml_element(parent, "gazebo", formatter=self._format_value, **attrib)
-
-        # Add material if specified
-        if gazebo_elem.material is not None:
-            xml_add_text(gz_elem, "material", gazebo_elem.material)
-
-        # Add boolean properties
-        self._add_optional_bool_element(gz_elem, "static", gazebo_elem.static)
-        self._add_optional_bool_element(gz_elem, "provideFeedback", gazebo_elem.provide_feedback)
-        self._add_optional_bool_element(
-            gz_elem, "implicitSpringDamper", gazebo_elem.implicit_spring_damper
-        )
-
-        # Add numeric properties
-        self._add_optional_numeric_element(gz_elem, "stopCfm", gazebo_elem.stop_cfm)
-        self._add_optional_numeric_element(gz_elem, "stopErp", gazebo_elem.stop_erp)
-
-        # Add custom properties (sort by key for deterministic output)
-        for key in sorted(gazebo_elem.properties.keys()):
-            prop_elem = ET.SubElement(gz_elem, key)
-            prop_elem.text = gazebo_elem.properties[key]
-
-        # Add plugins (sort by name for deterministic output)
-        for plugin in sorted(gazebo_elem.plugins, key=lambda p: p.name):
-            self._add_gazebo_plugin_element(gz_elem, plugin)
-
     def _add_gazebo_plugin_element(self, parent: ET.Element, plugin: GazeboPlugin) -> None:
         """Add Gazebo plugin element to parent.
 

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/models/link.py

@@ -21,9 +21,9 @@ from ..constants import (
     DEFAULT_CONTACT_KP,
     DEFAULT_FRICTION_MU,
     DEFAULT_FRICTION_MU2,
-    DEFAULT_GRAVITY,
     DEFAULT_SELF_COLLIDE,
     EPSILON,
+    GRAVITY_ENABLED,
     MIN_REASONABLE_INERTIA,
 )
 from ..exceptions import RobotPhysicsError, RobotValidationError, ValidationErrorCode
@@ -46,11 +46,11 @@ class InertiaTensor:
     """
 
     ixx: float
-    ixy: float
-    ixz: float
     iyy: float
-    iyz: float
     izz: float
+    ixy: float = 0.0
+    ixz: float = 0.0
+    iyz: float = 0.0
 
     def __post_init__(self) -> None:
         """Validate inertia tensor values."""
@@ -78,15 +78,16 @@ class InertiaTensor:
             )
 
     @classmethod
-    def zero(cls) -> InertiaTensor:
-        """Create a minimal valid inertia tensor (for massless links)."""
+    def stability_floor(cls) -> InertiaTensor:
+        """Create a minimal valid inertia tensor for stability (e.g. massless links).
+
+        Returns a tensor with MIN_REASONABLE_INERTIA on the diagonals to prevent
+        physics solver instability.
+        """
         return cls(
-            MIN_REASONABLE_INERTIA,
-            0.0,
-            0.0,
-            MIN_REASONABLE_INERTIA,
-            0.0,
-            MIN_REASONABLE_INERTIA,
+            ixx=MIN_REASONABLE_INERTIA,
+            iyy=MIN_REASONABLE_INERTIA,
+            izz=MIN_REASONABLE_INERTIA,
         )
 
 
@@ -96,7 +97,7 @@ class Inertial:
 
     mass: float
     origin: Transform = Transform.identity()
-    inertia: InertiaTensor = field(default_factory=InertiaTensor.zero)
+    inertia: InertiaTensor = field(default_factory=InertiaTensor.stability_floor)
 
     def __post_init__(self) -> None:
         """Validate inertial properties.
@@ -122,7 +123,7 @@ class LinkPhysics:
     """
 
     self_collide: bool = DEFAULT_SELF_COLLIDE
-    gravity: bool = DEFAULT_GRAVITY
+    gravity: bool = GRAVITY_ENABLED
     mu: float = DEFAULT_FRICTION_MU
     mu2: float = DEFAULT_FRICTION_MU2
     kp: float = DEFAULT_CONTACT_KP
@@ -211,7 +212,7 @@ class Link:
     @property
     def inertia(self) -> InertiaTensor:
         """Get link inertia tensor (zero tensor if not defined)."""
-        return self.inertial.inertia if self.inertial else InertiaTensor.zero()
+        return self.inertial.inertia if self.inertial else InertiaTensor.stability_floor()
 
     @property
     def inertial_origin(self) -> Transform:

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/models/robot.py

@@ -24,8 +24,8 @@ from typing import Any
 from .._utils.string_utils import is_valid_name
 from ..base import FileSystemResolver, IResourceResolver
 from ..constants import (
-    COLLISION_ADJACENT,
     IR_VERSION,
+    SRDF_REASON_ADJACENT,
 )
 from ..exceptions import RobotValidationError, ValidationErrorCode
 from .gazebo import GazeboElement
@@ -856,13 +856,15 @@ class Robot:
         self.semantic = replace(self.semantic, groups=tuple(self.semantic.groups) + (group,))
         return self
 
-    def disable_collisions(self, link1: str, link2: str, reason: str = COLLISION_ADJACENT) -> Robot:
+    def disable_collisions(
+        self, link1: str, link2: str, reason: str = SRDF_REASON_ADJACENT
+    ) -> Robot:
         """Disable collision checking between two links.
 
         Args:
             link1: First link name.
             link2: Second link name.
-            reason: Reason for disabling (default: COLLISION_ADJACENT).
+            reason: Reason for disabling (default: SRDF_REASON_ADJACENT).
 
         Returns:
             The robot instance for chaining.
@@ -881,7 +883,7 @@ class Robot:
         )
         return self
 
-    def disable_all_collisions(self, links: list[str], reason: str = COLLISION_ADJACENT) -> Robot:
+    def disable_all_collisions(self, links: list[str], reason: str = SRDF_REASON_ADJACENT) -> Robot:
         """Disable collision checking between all pairs in the provided list.
 
         Args:

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/models/sensor.py

@@ -50,6 +50,7 @@ from ..constants import (
     SENSOR_GPU_LIDAR,
     SENSOR_IMU,
     SENSOR_LIDAR,
+    SENSOR_RAY,
 )
 from ..exceptions import RobotValidationError, ValidationErrorCode
 from .gazebo import GazeboPlugin
@@ -57,11 +58,17 @@ from .geometry import Transform
 
 
 class SensorType(StrEnum):
-    """Enumeration of supported sensor types in the LinkForge IR."""
+    """Enumeration of supported sensor types in the LinkForge IR.
+
+    Note on LIDAR vs RAY:
+    - LIDAR is the modern Gazebo Harmonic/GZ standard ("lidar")
+    - RAY is provided for Gazebo Classic / ROS1 compatibility ("ray")
+    """
 
     CAMERA = SENSOR_CAMERA
     DEPTH_CAMERA = SENSOR_DEPTH_CAMERA
     LIDAR = SENSOR_LIDAR
+    RAY = SENSOR_RAY
     GPU_LIDAR = SENSOR_GPU_LIDAR
     IMU = SENSOR_IMU
     GPS = SENSOR_GPS

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/parsers/urdf_parser.py

@@ -1031,13 +1031,13 @@ class URDFParser(RobotXMLParser[Robot]):
                         try:
                             link = self._parse_link(elem, materials, source_directory)
                             robot.add_link(link)
-                        except (RobotModelError, ValueError, Exception) as e:
+                        except (RobotModelError, ValueError) as e:
                             logger.warning(f"Skipping invalid link '{elem.get('name')}': {e}")
 
                     elif tag == "joint":
                         try:
                             delayed_joints.append(self._parse_joint(elem))
-                        except (RobotModelError, ValueError, Exception) as e:
+                        except (RobotModelError, ValueError) as e:
                             logger.warning(f"Skipping invalid joint '{elem.get('name')}': {e}")
 
                     elif tag == "transmission":
@@ -1045,7 +1045,7 @@ class URDFParser(RobotXMLParser[Robot]):
                             trans = self._parse_transmission(elem)
                             if trans:
                                 delayed_transmissions.append(trans)
-                        except (RobotModelError, ValueError, Exception) as e:
+                        except (RobotModelError, ValueError) as e:
                             logger.warning(
                                 f"Skipping invalid transmission '{elem.get('name')}': {e}"
                             )
@@ -1055,7 +1055,7 @@ class URDFParser(RobotXMLParser[Robot]):
                             ros2_ctrl = self._parse_ros2_control(elem)
                             if ros2_ctrl:
                                 delayed_ros2_controls.append(ros2_ctrl)
-                        except (RobotModelError, ValueError, Exception) as e:
+                        except (RobotModelError, ValueError) as e:
                             logger.warning(
                                 f"Skipping invalid ros2_control '{elem.get('name')}': {e}"
                             )
@@ -1082,7 +1082,7 @@ class URDFParser(RobotXMLParser[Robot]):
                             # 3. Extract other Gazebo metadata (plugins, material, properties)
                             gazebo_elem = self._parse_gazebo_element(elem)
                             delayed_gazebo_elements.append((gazebo_elem, physics_data))
-                        except (RobotModelError, ValueError, Exception) as e:
+                        except (RobotModelError, ValueError) as e:
                             logger.warning(
                                 f"Skipping invalid gazebo element '{elem.get('name') or elem.get('reference')}': {e}"
                             )
@@ -1095,25 +1095,25 @@ class URDFParser(RobotXMLParser[Robot]):
         for joint in delayed_joints:
             try:
                 robot.add_joint(joint)
-            except Exception as e:
+            except (RobotModelError, ValueError) as e:
                 logger.warning(f"Skipping invalid joint '{joint.name}': {e}")
 
         for trans in delayed_transmissions:
             try:
                 robot.add_transmission(trans)
-            except Exception as e:
+            except (RobotModelError, ValueError) as e:
                 logger.warning(f"Skipping invalid transmission '{trans.name}': {e}")
 
         for ros2_ctrl in delayed_ros2_controls:
             try:
                 robot.add_ros2_control(ros2_ctrl)
-            except Exception as e:
+            except (RobotModelError, ValueError) as e:
                 logger.warning(f"Skipping invalid ros2_control '{ros2_ctrl.name}': {e}")
 
         for sensor in delayed_sensors:
             try:
                 robot.add_sensor(sensor)
-            except Exception as e:
+            except (RobotModelError, ValueError) as e:
                 logger.warning(f"Skipping invalid sensor '{sensor.name}': {e}")
 
         for gazebo_elem, physics_data in delayed_gazebo_elements:
@@ -1139,7 +1139,7 @@ class URDFParser(RobotXMLParser[Robot]):
                     or gazebo_elem.implicit_spring_damper is not None
                 ):
                     robot.add_gazebo_element(gazebo_elem)
-            except Exception as e:
+            except (RobotModelError, ValueError) as e:
                 logger.warning(f"Skipping invalid gazebo element '{gazebo_elem.reference}': {e}")
 
         return robot

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/parsers/xacro_parser.py

@@ -6,9 +6,11 @@ properties, and includes.
 
 from __future__ import annotations
 
+import ast
 import copy
 import json
 import math
+import operator
 import os
 import re
 import sys
@@ -48,8 +50,6 @@ logger = get_logger(__name__)
 DEFAULT_MAX_DEPTH = 2000  # Increased for extremely complex industrial robots
 RECURSION_LIMIT_BOOST = 5000  # Safer limit that prevents C-stack segmentation faults
 
-_DUNDER_PATTERN: re.Pattern[str] = re.compile(r"__\w+__")
-
 # Safe math context for evaluations
 MATH_CONTEXT: dict[str, Any] = {
     name: getattr(math, name) for name in dir(math) if not name.startswith("__")
@@ -72,6 +72,118 @@ MATH_CONTEXT["__builtins__"] = {
 MATH_CONTEXT["true"] = True
 MATH_CONTEXT["false"] = False
 
+_SAFE_OPERATORS: dict[type[ast.AST], Any] = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+    ast.BitXor: operator.xor,
+    ast.BitOr: operator.or_,
+    ast.BitAnd: operator.and_,
+    ast.USub: operator.neg,
+    ast.UAdd: operator.pos,
+    ast.Not: operator.not_,
+    ast.Eq: operator.eq,
+    ast.NotEq: operator.ne,
+    ast.Lt: operator.lt,
+    ast.LtE: operator.le,
+    ast.Gt: operator.gt,
+    ast.GtE: operator.ge,
+    ast.And: lambda a, b: a and b,
+    ast.Or: lambda a, b: a or b,
+}
+
+
+def _safe_eval(expr: str, context: dict[str, Any]) -> Any:
+    """Safe evaluation of an AST expression using a restricted context."""
+
+    def _eval_node(node: ast.AST) -> Any:
+        if isinstance(node, ast.Expression):
+            return _eval_node(node.body)
+        elif isinstance(node, ast.Constant):
+            return node.value
+        elif isinstance(node, ast.Name):
+            if node.id.startswith("__") and node.id.endswith("__"):
+                raise RobotXacroExpressionError(expr, f"Forbidden dunder attributes: '{node.id}'")
+            if node.id in context:
+                return context[node.id]
+            if "__builtins__" in context and node.id in context["__builtins__"]:
+                return context["__builtins__"][node.id]
+            raise NameError(f"Unknown variable '{node.id}'")  # noqa: TRY003
+        elif isinstance(node, ast.BinOp):
+            op = _SAFE_OPERATORS.get(type(node.op))
+            if not op:
+                raise TypeError(f"Unsupported operator {type(node.op)}")  # noqa: TRY003
+            return op(_eval_node(node.left), _eval_node(node.right))
+        elif isinstance(node, ast.UnaryOp):
+            op = _SAFE_OPERATORS.get(type(node.op))
+            if not op:
+                raise TypeError(f"Unsupported unary operator {type(node.op)}")  # noqa: TRY003
+            return op(_eval_node(node.operand))
+        elif isinstance(node, ast.BoolOp):
+            if isinstance(node.op, ast.And):
+                res = _eval_node(node.values[0])
+                for val in node.values[1:]:
+                    res = res and _eval_node(val)
+                return res
+            elif isinstance(node.op, ast.Or):
+                res = _eval_node(node.values[0])
+                for val in node.values[1:]:
+                    res = res or _eval_node(val)
+                return res
+            raise TypeError(f"Unsupported boolean operator {type(node.op)}")  # noqa: TRY003
+        elif isinstance(node, ast.Compare):
+            left = _eval_node(node.left)
+            for cmp_op, right_node in zip(node.ops, node.comparators, strict=False):
+                op_func = _SAFE_OPERATORS.get(type(cmp_op))
+                if not op_func:
+                    raise TypeError(f"Unsupported comparison operator {type(cmp_op)}")  # noqa: TRY003
+                right = _eval_node(right_node)
+                if not op_func(left, right):
+                    return False
+                left = right
+            return True
+        elif isinstance(node, ast.Call):
+            func = _eval_node(node.func)
+            if not callable(func):
+                raise TypeError(f"'{type(func)}' object is not callable")  # noqa: TRY003
+            args = [_eval_node(arg) for arg in node.args]
+            kwargs = {kw.arg: _eval_node(kw.value) for kw in node.keywords if kw.arg is not None}
+            return func(*args, **kwargs)
+        elif isinstance(node, ast.Attribute):
+            if node.attr.startswith("__") and node.attr.endswith("__"):
+                raise RobotXacroExpressionError(expr, f"Forbidden dunder attributes: '{node.attr}'")
+            val = _eval_node(node.value)
+            if hasattr(val, node.attr):
+                return getattr(val, node.attr)
+            elif isinstance(val, dict) and node.attr in val:
+                return val[node.attr]
+            raise AttributeError(f"Object has no attribute '{node.attr}'")  # noqa: TRY003
+        elif isinstance(node, ast.Subscript):
+            val = _eval_node(node.value)
+            slice_val = _eval_node(node.slice)
+            return val[slice_val]
+        elif isinstance(node, ast.List):
+            return [_eval_node(elt) for elt in node.elts]
+        elif isinstance(node, ast.Dict):
+            return {
+                _eval_node(k) if k else None: _eval_node(v)
+                for k, v in zip(node.keys, node.values, strict=False)
+            }
+        elif isinstance(node, ast.Tuple):
+            return tuple(_eval_node(elt) for elt in node.elts)
+        else:
+            raise TypeError(f"Unsupported AST node {type(node)}")  # noqa: TRY003
+
+    # We no longer catch SyntaxError and wrap it, allowing it to bubble up
+    # just like eval() did, so the existing try/except blocks work as before.
+    tree = ast.parse(expr, mode="eval")
+    return _eval_node(tree)
+
+
 # Internal XML tags used for structural processing
 _TAG_CONTAINER = "container"
 _TAG_SKIP = "skip"
@@ -733,10 +845,8 @@ class XacroResolver:
         else:
             try:
                 # Standard expression evaluation
-                if _DUNDER_PATTERN.search(condition_str):
-                    raise RobotXacroExpressionError(condition_str, "Forbidden dunder attributes")
                 ctx = {**self.eval_context, **self.properties, **self.args}
-                return bool(eval(condition_str, ctx, {}))
+                return bool(_safe_eval(condition_str, ctx))
             except Exception as e:
                 if isinstance(e, RobotParserError):
                     raise
@@ -894,9 +1004,6 @@ class XacroResolver:
         Raises:
             RobotXacroExpressionError: If the expression is invalid or contains forbidden dunder attributes.
         """
-        if _DUNDER_PATTERN.search(expr):
-            raise RobotXacroExpressionError(expr, "Forbidden dunder attributes")
-
         try:
             # Build nested context for hierarchical namespaces (e.g. arm.mass)
             ctx = self.eval_context.copy()
@@ -925,7 +1032,7 @@ class XacroResolver:
                         if "." not in short_name:
                             ctx[short_name] = val
 
-            return eval(expr, ctx, {})
+            return _safe_eval(expr, ctx)
         except Exception as e:
             # CRITICAL: Do not silent-fail! If math fails (e.g. missing variable),
             # we must tell the user immediately rather than producing a corrupt output.

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/parsers/xml_base.py

@@ -317,8 +317,8 @@ class RobotXMLParser(RobotParser[T], Generic[T]):
                 inertia = InertiaTensor(ixx=ixx, iyy=iyy, izz=izz, ixy=ixy, ixz=ixz, iyz=iyz)
             except RobotModelError:
                 # If triangle inequality is still violated, fall back to minimal valid
-                inertia = InertiaTensor.zero()
+                inertia = InertiaTensor.stability_floor()
         else:
-            inertia = InertiaTensor.zero()
+            inertia = InertiaTensor.stability_floor()
 
         return Inertial(mass=mass, origin=origin, inertia=inertia)

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/validation/security.py

@@ -43,9 +43,11 @@ def validate_mesh_path(
         RobotSecurityError: If the mesh path attempts to escape the source directory
         RobotSecurityError: If absolute paths are not allowed but one is provided
     """
-    # Decode URL encoding to catch encoded path traversal attempts (e.g., %2e%2e%2f -> ../)
+    # Decode URL encoding to catch encoded path traversal attempts (e.g., %252e%252e%252f -> ../)
     mesh_str = str(mesh_filepath)
     decoded_str = unquote(mesh_str)
+    while unquote(decoded_str) != decoded_str:
+        decoded_str = unquote(decoded_str)
 
     # Recreate Path from decoded string for further validation
     if decoded_str != mesh_str:
@@ -122,6 +124,8 @@ def validate_package_uri(uri: str) -> str:
 
     # Decode URL encoding to catch encoded path traversal attempts
     decoded_uri = unquote(uri)
+    while unquote(decoded_uri) != decoded_uri:
+        decoded_uri = unquote(decoded_uri)
 
     # Check both original and decoded for path traversal
     if ".." in uri or ".." in decoded_uri:

{linkforge_core-1.4.0 → linkforge_core-1.4.2}/src/linkforge/core/composer/robot_builder.py

@@ -230,9 +230,6 @@ class RobotBuilder:
         self._active_link_builders.clear()
 
         if validate:
-            # Trigger root search to verify connectivity (raises error if no root)
-            _ = self.robot.root_link
-
             if self.robot.has_cycle:
                 raise RobotValidationError(
                     ValidationErrorCode.HAS_CYCLE,
@@ -240,6 +237,9 @@ class RobotBuilder:
                     target="KinematicTree",
                 )
 
+            # Trigger root search to verify connectivity (raises error if no root)
+            _ = self.robot.root_link
+
         return self.robot
 
     def export_urdf(self, validate: bool = True, pretty_print: bool = True) -> str: