@2112-lab/central-plant 0.1.45 → 0.1.46

package/dist/bundle/index.js

@@ -19579,6 +19579,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         return null;
       }
       var collisionRadius = 0.5; // Radius around connector that triggers collision
+      var endpointTolerance = 0.55; // Tolerance for determining if connector is at segment endpoint
 
       // Get segment endpoints in world coordinates
       var endpoints = this.calculateSegmentEndpoints(segment);
@@ -19597,6 +19598,13 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           var connectorWorldPos = new THREE__namespace.Vector3();
           child.getWorldPosition(connectorWorldPos);
 
+          // Skip connectors that are at the segment's endpoints (legitimate connection points)
+          var distanceToStart = connectorWorldPos.distanceTo(startPoint);
+          var distanceToEnd = connectorWorldPos.distanceTo(endPoint);
+          if (distanceToStart <= endpointTolerance || distanceToEnd <= endpointTolerance) {
+            return; // Skip this connector - it's at an endpoint
+          }
+
           // Find the closest point on the segment to the connector
           var segmentVector = new THREE__namespace.Vector3().subVectors(endPoint, startPoint);
           var pointVector = new THREE__namespace.Vector3().subVectors(connectorWorldPos, startPoint);
@@ -19795,6 +19803,37 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return c1.distanceTo(c2);
     }
 
+    /**
+     * Constrain a position to maintain orthogonal alignment with a reference position
+     * Movement is restricted to only along the segment's direction vector
+     * @param {THREE.Vector3} newPosition - The proposed new position
+     * @param {THREE.Vector3} referencePosition - The stationary reference position
+     * @param {THREE.Object3D} segment - The segment being adjusted
+     * @returns {THREE.Vector3} Constrained position that maintains orthogonality
+     * @private
+     */
+  }, {
+    key: "constrainPositionToOrthogonal",
+    value: function constrainPositionToOrthogonal(newPosition, referencePosition, segment) {
+      // Get the segment's direction vector
+      var direction = new THREE__namespace.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+      direction.normalize();
+
+      // Calculate vector from reference position to new position
+      var moveVector = new THREE__namespace.Vector3().subVectors(newPosition, referencePosition);
+
+      // Project the move vector onto the segment's direction
+      // This gives us the component of movement along the segment's axis only
+      var projectionLength = moveVector.dot(direction);
+
+      // Constrained position = reference + (projection along segment direction)
+      var constrainedPos = new THREE__namespace.Vector3().copy(referencePosition).add(direction.clone().multiplyScalar(projectionLength));
+      console.log("\uD83D\uDD12 Constrained movement along segment direction: [".concat(direction.x.toFixed(3), ", ").concat(direction.y.toFixed(3), ", ").concat(direction.z.toFixed(3), "]"));
+      console.log("   Projection length: ".concat(projectionLength.toFixed(3)));
+      return constrainedPos;
+    }
+
     /**
      * Update adjacent segment connectors to follow the moved segment's new position
      * Finds segments that were connected to the moved segment BEFORE the move,
@@ -19913,18 +19952,23 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         var stationaryWorldPos = new THREE__namespace.Vector3();
         stationaryConnector.getWorldPosition(stationaryWorldPos);
 
+        // Constrain movement to maintain orthogonal alignment
+        // Horizontal segments: only adjust X and Y, keep Z constant
+        // Vertical segments: only adjust Z, keep X and Y constant
+        var constrainedPosition = _this2.constrainPositionToOrthogonal(pair.newPosition, stationaryWorldPos, adjacentSegment);
+
         // Recreate the segment mesh with new length using explicit endpoint positions
         // Pass the intended positions, not the connector objects (which may have temporary positions)
-        _this2.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, pair.newPosition, stationaryWorldPos);
+        _this2.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, constrainedPosition, stationaryWorldPos);
 
         // CRITICAL: After recreating the mesh, BOTH connectors need to be repositioned
         // because the segment's center and rotation have changed
 
-        // Position moving connector at the new position
-        var movingLocalPos = adjacentSegment.worldToLocal(pair.newPosition.clone());
+        // Position moving connector at the constrained position (not the raw new position)
+        var movingLocalPos = adjacentSegment.worldToLocal(constrainedPosition.clone());
         movingConnector.position.copy(movingLocalPos);
         movingConnector.updateMatrixWorld(true);
-        _this2.updateConnectorPositionInSceneData(movingConnector, pair.newPosition, adjacentSegment);
+        _this2.updateConnectorPositionInSceneData(movingConnector, constrainedPosition, adjacentSegment);
 
         // Position stationary connector at its original world position
         var stationaryLocalPos = adjacentSegment.worldToLocal(stationaryWorldPos.clone());
@@ -24665,10 +24709,6 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
 
       var pipeRadius = 0.1;
       var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
-
-      // Shared geometry for all connector caps to improve performance
-      var capGeometry = new THREE__namespace.SphereGeometry(pipeRadius, 16, 16);
-      this.registerDisposable(capGeometry);
       paths.forEach(function (pathData, index) {
         if (pathData.path && pathData.path.length >= 2) {
           // Convert path points to Vector3 objects for consistent handling
@@ -24722,14 +24762,15 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
               pathTo: pathData.to
             };
 
-            // Create caps at both ends of every segment
-            _this3.createSegmentCaps(cylinder, capGeometry, pipeMaterial, globalSegmentIndex);
-
             // Increment global segment counter
             globalSegmentIndex++;
 
             // Add segment directly to scene instead of to polyline
             sceneViewer.scene.add(cylinder);
+
+            // Add smooth elbow joints only at actual direction changes (not at every point)
+            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, sceneViewer.scene // Pass scene instead of polyline
+            );
           }
           console.log("\u2705 Created pipe path ".concat(pathData.from, "-").concat(pathData.to, " with ").concat(pathPoints.length - 1, " segments"));
         }
@@ -24737,49 +24778,130 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     }
 
     /**
-     * Create connector caps at both segment endpoints as children of the segment
-     * Caps are positioned in local coordinates to match manual segment connector positioning
-     * @param {THREE.Mesh} segment - The parent segment mesh
-     * @param {THREE.BufferGeometry} capGeometry - Shared geometry for caps
-     * @param {THREE.Material} material - Material for the caps
-     * @param {number} segmentIndex - Global segment index
+     * Create and add elbow joint if there's a direction change at the current segment
+     * @param {Array<THREE.Vector3>} pathPoints - Array of path points
+     * @param {number} j - Current segment index
+     * @param {number} pipeRadius - Radius of the pipe
+     * @param {THREE.Material} pipeMaterial - Material for the elbow
+     * @param {Object} pathData - Path data object with from/to information
+     * @param {number} index - Path index for naming
+     * @param {THREE.Scene} scene - Scene object to add elbow to directly
      */
   }, {
-    key: "createSegmentCaps",
-    value: function createSegmentCaps(segment, capGeometry, material, segmentIndex) {
-      var length = segment.geometry.parameters.height;
-
-      // Create start cap
-      var startCap = new THREE__namespace.Mesh(capGeometry, material);
-      // Position at segment start in local space (matches manual segment connector positioning)
-      startCap.position.set(0, -length / 2, 0);
-      startCap.uuid = "SEGMENT-".concat(segmentIndex, "-CAP-START");
-      startCap.userData = {
-        objectType: 'segment-cap',
-        capType: 'start',
-        segmentId: segment.uuid,
-        segmentIndex: segmentIndex
-      };
-      startCap.castShadow = true;
-      startCap.receiveShadow = true;
-      segment.add(startCap);
-      console.log("\uD83D\uDD35 Created START cap for segment ".concat(segmentIndex, " at local position (0, ").concat(-length / 2, ", 0)"));
-
-      // Create end cap
-      var endCap = new THREE__namespace.Mesh(capGeometry, material);
-      // Position at segment end in local space (matches manual segment connector positioning)
-      endCap.position.set(0, length / 2, 0);
-      endCap.uuid = "SEGMENT-".concat(segmentIndex, "-CAP-END");
-      endCap.userData = {
-        objectType: 'segment-cap',
-        capType: 'end',
-        segmentId: segment.uuid,
-        segmentIndex: segmentIndex
+    key: "createAndAddElbowIfNeeded",
+    value: function createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, scene) {
+      // Only check if there are at least 2 more points ahead
+      if (j >= pathPoints.length - 2) {
+        return;
+      }
+      var currentSegment = pathPoints[j + 1].clone().sub(pathPoints[j]).normalize();
+      var nextSegment = pathPoints[j + 2].clone().sub(pathPoints[j + 1]).normalize();
+
+      // Check if there's actually a direction change (not just continuing straight)
+      var angle = currentSegment.angleTo(nextSegment);
+      var minAngle = Math.PI / 36; // 5 degrees minimum for creating an elbow
+
+      if (angle <= minAngle) {
+        return; // No significant direction change
+      }
+      var elbowGeometry = this.createElbowGeometry(pathPoints[j], pathPoints[j + 1], pathPoints[j + 2], pipeRadius);
+      if (!elbowGeometry) {
+        return; // Failed to create geometry
+      }
+      var elbow = new THREE__namespace.Mesh(elbowGeometry, pipeMaterial);
+      elbow.castShadow = true;
+      elbow.receiveShadow = true;
+
+      // Make elbows selectable as well
+      var elbowId = "pipe-elbow-".concat(pathData.from, "-").concat(pathData.to, "-").concat(j);
+      elbow.uuid = "Pipe Elbow ".concat(j + 1, ": ").concat(pathData.from, "-").concat(pathData.to);
+
+      // Add userData for elbows too
+      elbow.userData = {
+        isPipeElbow: true,
+        elbowId: elbowId,
+        elbowIndex: j,
+        pathFrom: pathData.from,
+        pathTo: pathData.to,
+        angle: (angle * 180 / Math.PI).toFixed(1),
+        // Add component data for tooltips
+        component: {
+          type: 'PipeElbow',
+          attributes: {
+            angle: {
+              key: 'Bend Angle',
+              value: (angle * 180 / Math.PI).toFixed(1),
+              unit: '°'
+            }
+          }
+        }
       };
-      endCap.castShadow = true;
-      endCap.receiveShadow = true;
-      segment.add(endCap);
-      console.log("\uD83D\uDD35 Created END cap for segment ".concat(segmentIndex, " at local position (0, ").concat(length / 2, ", 0)"));
+      scene.add(elbow);
+    }
+
+    /**
+     * Create smooth elbow geometry to connect two pipe segments (optimized for 90-degree angles)
+     * @param {THREE.Vector3} point1 - First point (before the joint)
+     * @param {THREE.Vector3} point2 - Joint point (center of the elbow)
+     * @param {THREE.Vector3} point3 - Third point (after the joint)
+     * @param {number} radius - Pipe radius
+     * @returns {THREE.BufferGeometry} Elbow geometry
+     */
+  }, {
+    key: "createElbowGeometry",
+    value: function createElbowGeometry(point1, point2, point3, radius) {
+      try {
+        // Fixed elbow radius for 90-degree bends (simplified)
+        var elbowRadius = radius * 3;
+
+        // Create a curve for the 90-degree elbow
+        var curve = this.createElbowCurve(point1, point2, point3, elbowRadius);
+
+        // Fixed tubular segments for 90-degree bends (quarter circle)
+        var tubularSegments = 12; // Good balance for smooth 90° curves
+        var radialSegments = 16;
+        var closed = false;
+        var elbowGeometry = new THREE__namespace.TubeGeometry(curve, tubularSegments, radius, radialSegments, closed);
+        return elbowGeometry;
+      } catch (error) {
+        console.warn('Failed to create elbow geometry:', error);
+        return null;
+      }
+    }
+
+    /**
+     * Create a smooth curve for the 90-degree elbow joint (simplified)
+     * @param {THREE.Vector3} point1 - First point
+     * @param {THREE.Vector3} point2 - Joint point
+     * @param {THREE.Vector3} point3 - Third point
+     * @param {number} elbowRadius - Radius of the elbow curve
+     * @returns {THREE.Curve} Curve for the elbow
+     */
+  }, {
+    key: "createElbowCurve",
+    value: function createElbowCurve(point1, point2, point3, elbowRadius) {
+      // Calculate direction vectors
+      var dir1 = point2.clone().sub(point1).normalize();
+      var dir2 = point3.clone().sub(point2).normalize();
+
+      // For 90-degree bends, we can use a simpler approach with a quarter circle
+      // The curve radius is proportional to the elbow radius
+      var curveRadius = elbowRadius * 0.001;
+
+      // Calculate the offset distance from the joint point
+      var offset = curveRadius;
+
+      // Calculate start and end points of the curve (offset from the joint)
+      var curveStart = point2.clone().sub(dir1.clone().multiplyScalar(offset));
+      var curveEnd = point2.clone().add(dir2.clone().multiplyScalar(offset));
+
+      // For a 90-degree bend, the control point is at the corner
+      // We can use a quadratic bezier curve for simplicity
+      var controlPoint = point2.clone();
+
+      // Create a quadratic bezier curve (simpler than cubic for 90° bends)
+      var curve = new THREE__namespace.QuadraticBezierCurve3(curveStart, controlPoint, curveEnd);
+      return curve;
     }
 
     /**
@@ -32446,7 +32568,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.45
+   * @version 0.1.46
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.

package/dist/cjs/src/core/centralPlant.js

@@ -19,7 +19,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.45
+   * @version 0.1.46
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.

package/dist/cjs/src/managers/components/transformOperationsManager.js

@@ -940,6 +940,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         return null;
       }
       var collisionRadius = 0.5; // Radius around connector that triggers collision
+      var endpointTolerance = 0.55; // Tolerance for determining if connector is at segment endpoint
 
       // Get segment endpoints in world coordinates
       var endpoints = this.calculateSegmentEndpoints(segment);
@@ -958,6 +959,13 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           var connectorWorldPos = new THREE__namespace.Vector3();
           child.getWorldPosition(connectorWorldPos);
 
+          // Skip connectors that are at the segment's endpoints (legitimate connection points)
+          var distanceToStart = connectorWorldPos.distanceTo(startPoint);
+          var distanceToEnd = connectorWorldPos.distanceTo(endPoint);
+          if (distanceToStart <= endpointTolerance || distanceToEnd <= endpointTolerance) {
+            return; // Skip this connector - it's at an endpoint
+          }
+
           // Find the closest point on the segment to the connector
           var segmentVector = new THREE__namespace.Vector3().subVectors(endPoint, startPoint);
           var pointVector = new THREE__namespace.Vector3().subVectors(connectorWorldPos, startPoint);
@@ -1156,6 +1164,37 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return c1.distanceTo(c2);
     }
 
+    /**
+     * Constrain a position to maintain orthogonal alignment with a reference position
+     * Movement is restricted to only along the segment's direction vector
+     * @param {THREE.Vector3} newPosition - The proposed new position
+     * @param {THREE.Vector3} referencePosition - The stationary reference position
+     * @param {THREE.Object3D} segment - The segment being adjusted
+     * @returns {THREE.Vector3} Constrained position that maintains orthogonality
+     * @private
+     */
+  }, {
+    key: "constrainPositionToOrthogonal",
+    value: function constrainPositionToOrthogonal(newPosition, referencePosition, segment) {
+      // Get the segment's direction vector
+      var direction = new THREE__namespace.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+      direction.normalize();
+
+      // Calculate vector from reference position to new position
+      var moveVector = new THREE__namespace.Vector3().subVectors(newPosition, referencePosition);
+
+      // Project the move vector onto the segment's direction
+      // This gives us the component of movement along the segment's axis only
+      var projectionLength = moveVector.dot(direction);
+
+      // Constrained position = reference + (projection along segment direction)
+      var constrainedPos = new THREE__namespace.Vector3().copy(referencePosition).add(direction.clone().multiplyScalar(projectionLength));
+      console.log("\uD83D\uDD12 Constrained movement along segment direction: [".concat(direction.x.toFixed(3), ", ").concat(direction.y.toFixed(3), ", ").concat(direction.z.toFixed(3), "]"));
+      console.log("   Projection length: ".concat(projectionLength.toFixed(3)));
+      return constrainedPos;
+    }
+
     /**
      * Update adjacent segment connectors to follow the moved segment's new position
      * Finds segments that were connected to the moved segment BEFORE the move,
@@ -1274,18 +1313,23 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         var stationaryWorldPos = new THREE__namespace.Vector3();
         stationaryConnector.getWorldPosition(stationaryWorldPos);
 
+        // Constrain movement to maintain orthogonal alignment
+        // Horizontal segments: only adjust X and Y, keep Z constant
+        // Vertical segments: only adjust Z, keep X and Y constant
+        var constrainedPosition = _this2.constrainPositionToOrthogonal(pair.newPosition, stationaryWorldPos, adjacentSegment);
+
         // Recreate the segment mesh with new length using explicit endpoint positions
         // Pass the intended positions, not the connector objects (which may have temporary positions)
-        _this2.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, pair.newPosition, stationaryWorldPos);
+        _this2.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, constrainedPosition, stationaryWorldPos);
 
         // CRITICAL: After recreating the mesh, BOTH connectors need to be repositioned
         // because the segment's center and rotation have changed
 
-        // Position moving connector at the new position
-        var movingLocalPos = adjacentSegment.worldToLocal(pair.newPosition.clone());
+        // Position moving connector at the constrained position (not the raw new position)
+        var movingLocalPos = adjacentSegment.worldToLocal(constrainedPosition.clone());
         movingConnector.position.copy(movingLocalPos);
         movingConnector.updateMatrixWorld(true);
-        _this2.updateConnectorPositionInSceneData(movingConnector, pair.newPosition, adjacentSegment);
+        _this2.updateConnectorPositionInSceneData(movingConnector, constrainedPosition, adjacentSegment);
 
         // Position stationary connector at its original world position
         var stationaryLocalPos = adjacentSegment.worldToLocal(stationaryWorldPos.clone());

package/dist/cjs/src/managers/pathfinding/PathRenderingManager.js

@@ -184,10 +184,6 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
 
       var pipeRadius = 0.1;
       var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
-
-      // Shared geometry for all connector caps to improve performance
-      var capGeometry = new THREE__namespace.SphereGeometry(pipeRadius, 16, 16);
-      this.registerDisposable(capGeometry);
       paths.forEach(function (pathData, index) {
         if (pathData.path && pathData.path.length >= 2) {
           // Convert path points to Vector3 objects for consistent handling
@@ -241,14 +237,15 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
               pathTo: pathData.to
             };
 
-            // Create caps at both ends of every segment
-            _this3.createSegmentCaps(cylinder, capGeometry, pipeMaterial, globalSegmentIndex);
-
             // Increment global segment counter
             globalSegmentIndex++;
 
             // Add segment directly to scene instead of to polyline
             sceneViewer.scene.add(cylinder);
+
+            // Add smooth elbow joints only at actual direction changes (not at every point)
+            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, sceneViewer.scene // Pass scene instead of polyline
+            );
           }
           console.log("\u2705 Created pipe path ".concat(pathData.from, "-").concat(pathData.to, " with ").concat(pathPoints.length - 1, " segments"));
         }
@@ -256,49 +253,130 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     }
 
     /**
-     * Create connector caps at both segment endpoints as children of the segment
-     * Caps are positioned in local coordinates to match manual segment connector positioning
-     * @param {THREE.Mesh} segment - The parent segment mesh
-     * @param {THREE.BufferGeometry} capGeometry - Shared geometry for caps
-     * @param {THREE.Material} material - Material for the caps
-     * @param {number} segmentIndex - Global segment index
+     * Create and add elbow joint if there's a direction change at the current segment
+     * @param {Array<THREE.Vector3>} pathPoints - Array of path points
+     * @param {number} j - Current segment index
+     * @param {number} pipeRadius - Radius of the pipe
+     * @param {THREE.Material} pipeMaterial - Material for the elbow
+     * @param {Object} pathData - Path data object with from/to information
+     * @param {number} index - Path index for naming
+     * @param {THREE.Scene} scene - Scene object to add elbow to directly
      */
   }, {
-    key: "createSegmentCaps",
-    value: function createSegmentCaps(segment, capGeometry, material, segmentIndex) {
-      var length = segment.geometry.parameters.height;
-
-      // Create start cap
-      var startCap = new THREE__namespace.Mesh(capGeometry, material);
-      // Position at segment start in local space (matches manual segment connector positioning)
-      startCap.position.set(0, -length / 2, 0);
-      startCap.uuid = "SEGMENT-".concat(segmentIndex, "-CAP-START");
-      startCap.userData = {
-        objectType: 'segment-cap',
-        capType: 'start',
-        segmentId: segment.uuid,
-        segmentIndex: segmentIndex
-      };
-      startCap.castShadow = true;
-      startCap.receiveShadow = true;
-      segment.add(startCap);
-      console.log("\uD83D\uDD35 Created START cap for segment ".concat(segmentIndex, " at local position (0, ").concat(-length / 2, ", 0)"));
-
-      // Create end cap
-      var endCap = new THREE__namespace.Mesh(capGeometry, material);
-      // Position at segment end in local space (matches manual segment connector positioning)
-      endCap.position.set(0, length / 2, 0);
-      endCap.uuid = "SEGMENT-".concat(segmentIndex, "-CAP-END");
-      endCap.userData = {
-        objectType: 'segment-cap',
-        capType: 'end',
-        segmentId: segment.uuid,
-        segmentIndex: segmentIndex
+    key: "createAndAddElbowIfNeeded",
+    value: function createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, scene) {
+      // Only check if there are at least 2 more points ahead
+      if (j >= pathPoints.length - 2) {
+        return;
+      }
+      var currentSegment = pathPoints[j + 1].clone().sub(pathPoints[j]).normalize();
+      var nextSegment = pathPoints[j + 2].clone().sub(pathPoints[j + 1]).normalize();
+
+      // Check if there's actually a direction change (not just continuing straight)
+      var angle = currentSegment.angleTo(nextSegment);
+      var minAngle = Math.PI / 36; // 5 degrees minimum for creating an elbow
+
+      if (angle <= minAngle) {
+        return; // No significant direction change
+      }
+      var elbowGeometry = this.createElbowGeometry(pathPoints[j], pathPoints[j + 1], pathPoints[j + 2], pipeRadius);
+      if (!elbowGeometry) {
+        return; // Failed to create geometry
+      }
+      var elbow = new THREE__namespace.Mesh(elbowGeometry, pipeMaterial);
+      elbow.castShadow = true;
+      elbow.receiveShadow = true;
+
+      // Make elbows selectable as well
+      var elbowId = "pipe-elbow-".concat(pathData.from, "-").concat(pathData.to, "-").concat(j);
+      elbow.uuid = "Pipe Elbow ".concat(j + 1, ": ").concat(pathData.from, "-").concat(pathData.to);
+
+      // Add userData for elbows too
+      elbow.userData = {
+        isPipeElbow: true,
+        elbowId: elbowId,
+        elbowIndex: j,
+        pathFrom: pathData.from,
+        pathTo: pathData.to,
+        angle: (angle * 180 / Math.PI).toFixed(1),
+        // Add component data for tooltips
+        component: {
+          type: 'PipeElbow',
+          attributes: {
+            angle: {
+              key: 'Bend Angle',
+              value: (angle * 180 / Math.PI).toFixed(1),
+              unit: '°'
+            }
+          }
+        }
       };
-      endCap.castShadow = true;
-      endCap.receiveShadow = true;
-      segment.add(endCap);
-      console.log("\uD83D\uDD35 Created END cap for segment ".concat(segmentIndex, " at local position (0, ").concat(length / 2, ", 0)"));
+      scene.add(elbow);
+    }
+
+    /**
+     * Create smooth elbow geometry to connect two pipe segments (optimized for 90-degree angles)
+     * @param {THREE.Vector3} point1 - First point (before the joint)
+     * @param {THREE.Vector3} point2 - Joint point (center of the elbow)
+     * @param {THREE.Vector3} point3 - Third point (after the joint)
+     * @param {number} radius - Pipe radius
+     * @returns {THREE.BufferGeometry} Elbow geometry
+     */
+  }, {
+    key: "createElbowGeometry",
+    value: function createElbowGeometry(point1, point2, point3, radius) {
+      try {
+        // Fixed elbow radius for 90-degree bends (simplified)
+        var elbowRadius = radius * 3;
+
+        // Create a curve for the 90-degree elbow
+        var curve = this.createElbowCurve(point1, point2, point3, elbowRadius);
+
+        // Fixed tubular segments for 90-degree bends (quarter circle)
+        var tubularSegments = 12; // Good balance for smooth 90° curves
+        var radialSegments = 16;
+        var closed = false;
+        var elbowGeometry = new THREE__namespace.TubeGeometry(curve, tubularSegments, radius, radialSegments, closed);
+        return elbowGeometry;
+      } catch (error) {
+        console.warn('Failed to create elbow geometry:', error);
+        return null;
+      }
+    }
+
+    /**
+     * Create a smooth curve for the 90-degree elbow joint (simplified)
+     * @param {THREE.Vector3} point1 - First point
+     * @param {THREE.Vector3} point2 - Joint point
+     * @param {THREE.Vector3} point3 - Third point
+     * @param {number} elbowRadius - Radius of the elbow curve
+     * @returns {THREE.Curve} Curve for the elbow
+     */
+  }, {
+    key: "createElbowCurve",
+    value: function createElbowCurve(point1, point2, point3, elbowRadius) {
+      // Calculate direction vectors
+      var dir1 = point2.clone().sub(point1).normalize();
+      var dir2 = point3.clone().sub(point2).normalize();
+
+      // For 90-degree bends, we can use a simpler approach with a quarter circle
+      // The curve radius is proportional to the elbow radius
+      var curveRadius = elbowRadius * 0.001;
+
+      // Calculate the offset distance from the joint point
+      var offset = curveRadius;
+
+      // Calculate start and end points of the curve (offset from the joint)
+      var curveStart = point2.clone().sub(dir1.clone().multiplyScalar(offset));
+      var curveEnd = point2.clone().add(dir2.clone().multiplyScalar(offset));
+
+      // For a 90-degree bend, the control point is at the corner
+      // We can use a quadratic bezier curve for simplicity
+      var controlPoint = point2.clone();
+
+      // Create a quadratic bezier curve (simpler than cubic for 90° bends)
+      var curve = new THREE__namespace.QuadraticBezierCurve3(curveStart, controlPoint, curveEnd);
+      return curve;
     }
 
     /**

package/dist/esm/src/core/centralPlant.js

@@ -15,7 +15,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.45
+   * @version 0.1.46
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.

package/dist/esm/src/managers/components/transformOperationsManager.js

@@ -916,6 +916,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         return null;
       }
       var collisionRadius = 0.5; // Radius around connector that triggers collision
+      var endpointTolerance = 0.55; // Tolerance for determining if connector is at segment endpoint
 
       // Get segment endpoints in world coordinates
       var endpoints = this.calculateSegmentEndpoints(segment);
@@ -934,6 +935,13 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           var connectorWorldPos = new THREE.Vector3();
           child.getWorldPosition(connectorWorldPos);
 
+          // Skip connectors that are at the segment's endpoints (legitimate connection points)
+          var distanceToStart = connectorWorldPos.distanceTo(startPoint);
+          var distanceToEnd = connectorWorldPos.distanceTo(endPoint);
+          if (distanceToStart <= endpointTolerance || distanceToEnd <= endpointTolerance) {
+            return; // Skip this connector - it's at an endpoint
+          }
+
           // Find the closest point on the segment to the connector
           var segmentVector = new THREE.Vector3().subVectors(endPoint, startPoint);
           var pointVector = new THREE.Vector3().subVectors(connectorWorldPos, startPoint);
@@ -1132,6 +1140,37 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return c1.distanceTo(c2);
     }
 
+    /**
+     * Constrain a position to maintain orthogonal alignment with a reference position
+     * Movement is restricted to only along the segment's direction vector
+     * @param {THREE.Vector3} newPosition - The proposed new position
+     * @param {THREE.Vector3} referencePosition - The stationary reference position
+     * @param {THREE.Object3D} segment - The segment being adjusted
+     * @returns {THREE.Vector3} Constrained position that maintains orthogonality
+     * @private
+     */
+  }, {
+    key: "constrainPositionToOrthogonal",
+    value: function constrainPositionToOrthogonal(newPosition, referencePosition, segment) {
+      // Get the segment's direction vector
+      var direction = new THREE.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+      direction.normalize();
+
+      // Calculate vector from reference position to new position
+      var moveVector = new THREE.Vector3().subVectors(newPosition, referencePosition);
+
+      // Project the move vector onto the segment's direction
+      // This gives us the component of movement along the segment's axis only
+      var projectionLength = moveVector.dot(direction);
+
+      // Constrained position = reference + (projection along segment direction)
+      var constrainedPos = new THREE.Vector3().copy(referencePosition).add(direction.clone().multiplyScalar(projectionLength));
+      console.log("\uD83D\uDD12 Constrained movement along segment direction: [".concat(direction.x.toFixed(3), ", ").concat(direction.y.toFixed(3), ", ").concat(direction.z.toFixed(3), "]"));
+      console.log("   Projection length: ".concat(projectionLength.toFixed(3)));
+      return constrainedPos;
+    }
+
     /**
      * Update adjacent segment connectors to follow the moved segment's new position
      * Finds segments that were connected to the moved segment BEFORE the move,
@@ -1250,18 +1289,23 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         var stationaryWorldPos = new THREE.Vector3();
         stationaryConnector.getWorldPosition(stationaryWorldPos);
 
+        // Constrain movement to maintain orthogonal alignment
+        // Horizontal segments: only adjust X and Y, keep Z constant
+        // Vertical segments: only adjust Z, keep X and Y constant
+        var constrainedPosition = _this2.constrainPositionToOrthogonal(pair.newPosition, stationaryWorldPos, adjacentSegment);
+
         // Recreate the segment mesh with new length using explicit endpoint positions
         // Pass the intended positions, not the connector objects (which may have temporary positions)
-        _this2.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, pair.newPosition, stationaryWorldPos);
+        _this2.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, constrainedPosition, stationaryWorldPos);
 
         // CRITICAL: After recreating the mesh, BOTH connectors need to be repositioned
         // because the segment's center and rotation have changed
 
-        // Position moving connector at the new position
-        var movingLocalPos = adjacentSegment.worldToLocal(pair.newPosition.clone());
+        // Position moving connector at the constrained position (not the raw new position)
+        var movingLocalPos = adjacentSegment.worldToLocal(constrainedPosition.clone());
         movingConnector.position.copy(movingLocalPos);
         movingConnector.updateMatrixWorld(true);
-        _this2.updateConnectorPositionInSceneData(movingConnector, pair.newPosition, adjacentSegment);
+        _this2.updateConnectorPositionInSceneData(movingConnector, constrainedPosition, adjacentSegment);
 
         // Position stationary connector at its original world position
         var stationaryLocalPos = adjacentSegment.worldToLocal(stationaryWorldPos.clone());

package/dist/esm/src/managers/pathfinding/PathRenderingManager.js

@@ -160,10 +160,6 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
 
       var pipeRadius = 0.1;
       var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
-
-      // Shared geometry for all connector caps to improve performance
-      var capGeometry = new THREE.SphereGeometry(pipeRadius, 16, 16);
-      this.registerDisposable(capGeometry);
       paths.forEach(function (pathData, index) {
         if (pathData.path && pathData.path.length >= 2) {
           // Convert path points to Vector3 objects for consistent handling
@@ -217,14 +213,15 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
               pathTo: pathData.to
             };
 
-            // Create caps at both ends of every segment
-            _this3.createSegmentCaps(cylinder, capGeometry, pipeMaterial, globalSegmentIndex);
-
             // Increment global segment counter
             globalSegmentIndex++;
 
             // Add segment directly to scene instead of to polyline
             sceneViewer.scene.add(cylinder);
+
+            // Add smooth elbow joints only at actual direction changes (not at every point)
+            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, sceneViewer.scene // Pass scene instead of polyline
+            );
           }
           console.log("\u2705 Created pipe path ".concat(pathData.from, "-").concat(pathData.to, " with ").concat(pathPoints.length - 1, " segments"));
         }
@@ -232,49 +229,130 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     }
 
     /**
-     * Create connector caps at both segment endpoints as children of the segment
-     * Caps are positioned in local coordinates to match manual segment connector positioning
-     * @param {THREE.Mesh} segment - The parent segment mesh
-     * @param {THREE.BufferGeometry} capGeometry - Shared geometry for caps
-     * @param {THREE.Material} material - Material for the caps
-     * @param {number} segmentIndex - Global segment index
+     * Create and add elbow joint if there's a direction change at the current segment
+     * @param {Array<THREE.Vector3>} pathPoints - Array of path points
+     * @param {number} j - Current segment index
+     * @param {number} pipeRadius - Radius of the pipe
+     * @param {THREE.Material} pipeMaterial - Material for the elbow
+     * @param {Object} pathData - Path data object with from/to information
+     * @param {number} index - Path index for naming
+     * @param {THREE.Scene} scene - Scene object to add elbow to directly
      */
   }, {
-    key: "createSegmentCaps",
-    value: function createSegmentCaps(segment, capGeometry, material, segmentIndex) {
-      var length = segment.geometry.parameters.height;
-
-      // Create start cap
-      var startCap = new THREE.Mesh(capGeometry, material);
-      // Position at segment start in local space (matches manual segment connector positioning)
-      startCap.position.set(0, -length / 2, 0);
-      startCap.uuid = "SEGMENT-".concat(segmentIndex, "-CAP-START");
-      startCap.userData = {
-        objectType: 'segment-cap',
-        capType: 'start',
-        segmentId: segment.uuid,
-        segmentIndex: segmentIndex
-      };
-      startCap.castShadow = true;
-      startCap.receiveShadow = true;
-      segment.add(startCap);
-      console.log("\uD83D\uDD35 Created START cap for segment ".concat(segmentIndex, " at local position (0, ").concat(-length / 2, ", 0)"));
-
-      // Create end cap
-      var endCap = new THREE.Mesh(capGeometry, material);
-      // Position at segment end in local space (matches manual segment connector positioning)
-      endCap.position.set(0, length / 2, 0);
-      endCap.uuid = "SEGMENT-".concat(segmentIndex, "-CAP-END");
-      endCap.userData = {
-        objectType: 'segment-cap',
-        capType: 'end',
-        segmentId: segment.uuid,
-        segmentIndex: segmentIndex
+    key: "createAndAddElbowIfNeeded",
+    value: function createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, scene) {
+      // Only check if there are at least 2 more points ahead
+      if (j >= pathPoints.length - 2) {
+        return;
+      }
+      var currentSegment = pathPoints[j + 1].clone().sub(pathPoints[j]).normalize();
+      var nextSegment = pathPoints[j + 2].clone().sub(pathPoints[j + 1]).normalize();
+
+      // Check if there's actually a direction change (not just continuing straight)
+      var angle = currentSegment.angleTo(nextSegment);
+      var minAngle = Math.PI / 36; // 5 degrees minimum for creating an elbow
+
+      if (angle <= minAngle) {
+        return; // No significant direction change
+      }
+      var elbowGeometry = this.createElbowGeometry(pathPoints[j], pathPoints[j + 1], pathPoints[j + 2], pipeRadius);
+      if (!elbowGeometry) {
+        return; // Failed to create geometry
+      }
+      var elbow = new THREE.Mesh(elbowGeometry, pipeMaterial);
+      elbow.castShadow = true;
+      elbow.receiveShadow = true;
+
+      // Make elbows selectable as well
+      var elbowId = "pipe-elbow-".concat(pathData.from, "-").concat(pathData.to, "-").concat(j);
+      elbow.uuid = "Pipe Elbow ".concat(j + 1, ": ").concat(pathData.from, "-").concat(pathData.to);
+
+      // Add userData for elbows too
+      elbow.userData = {
+        isPipeElbow: true,
+        elbowId: elbowId,
+        elbowIndex: j,
+        pathFrom: pathData.from,
+        pathTo: pathData.to,
+        angle: (angle * 180 / Math.PI).toFixed(1),
+        // Add component data for tooltips
+        component: {
+          type: 'PipeElbow',
+          attributes: {
+            angle: {
+              key: 'Bend Angle',
+              value: (angle * 180 / Math.PI).toFixed(1),
+              unit: '°'
+            }
+          }
+        }
       };
-      endCap.castShadow = true;
-      endCap.receiveShadow = true;
-      segment.add(endCap);
-      console.log("\uD83D\uDD35 Created END cap for segment ".concat(segmentIndex, " at local position (0, ").concat(length / 2, ", 0)"));
+      scene.add(elbow);
+    }
+
+    /**
+     * Create smooth elbow geometry to connect two pipe segments (optimized for 90-degree angles)
+     * @param {THREE.Vector3} point1 - First point (before the joint)
+     * @param {THREE.Vector3} point2 - Joint point (center of the elbow)
+     * @param {THREE.Vector3} point3 - Third point (after the joint)
+     * @param {number} radius - Pipe radius
+     * @returns {THREE.BufferGeometry} Elbow geometry
+     */
+  }, {
+    key: "createElbowGeometry",
+    value: function createElbowGeometry(point1, point2, point3, radius) {
+      try {
+        // Fixed elbow radius for 90-degree bends (simplified)
+        var elbowRadius = radius * 3;
+
+        // Create a curve for the 90-degree elbow
+        var curve = this.createElbowCurve(point1, point2, point3, elbowRadius);
+
+        // Fixed tubular segments for 90-degree bends (quarter circle)
+        var tubularSegments = 12; // Good balance for smooth 90° curves
+        var radialSegments = 16;
+        var closed = false;
+        var elbowGeometry = new THREE.TubeGeometry(curve, tubularSegments, radius, radialSegments, closed);
+        return elbowGeometry;
+      } catch (error) {
+        console.warn('Failed to create elbow geometry:', error);
+        return null;
+      }
+    }
+
+    /**
+     * Create a smooth curve for the 90-degree elbow joint (simplified)
+     * @param {THREE.Vector3} point1 - First point
+     * @param {THREE.Vector3} point2 - Joint point
+     * @param {THREE.Vector3} point3 - Third point
+     * @param {number} elbowRadius - Radius of the elbow curve
+     * @returns {THREE.Curve} Curve for the elbow
+     */
+  }, {
+    key: "createElbowCurve",
+    value: function createElbowCurve(point1, point2, point3, elbowRadius) {
+      // Calculate direction vectors
+      var dir1 = point2.clone().sub(point1).normalize();
+      var dir2 = point3.clone().sub(point2).normalize();
+
+      // For 90-degree bends, we can use a simpler approach with a quarter circle
+      // The curve radius is proportional to the elbow radius
+      var curveRadius = elbowRadius * 0.001;
+
+      // Calculate the offset distance from the joint point
+      var offset = curveRadius;
+
+      // Calculate start and end points of the curve (offset from the joint)
+      var curveStart = point2.clone().sub(dir1.clone().multiplyScalar(offset));
+      var curveEnd = point2.clone().add(dir2.clone().multiplyScalar(offset));
+
+      // For a 90-degree bend, the control point is at the corner
+      // We can use a quadratic bezier curve for simplicity
+      var controlPoint = point2.clone();
+
+      // Create a quadratic bezier curve (simpler than cubic for 90° bends)
+      var curve = new THREE.QuadraticBezierCurve3(curveStart, controlPoint, curveEnd);
+      return curve;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2112-lab/central-plant",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "description": "Utility modules for the Central Plant Application",
   "main": "dist/bundle/index.js",
   "module": "dist/esm/index.js",