@2112-lab/central-plant 0.1.55 → 0.1.60

package/dist/bundle/index.js

@@ -3993,6 +3993,80 @@ var TransformControlsManager = /*#__PURE__*/function () {
       var hasConnectorName = object.name && object.name.toLowerCase().includes('connector');
       return (hasConnectorGeometry || isSphereConnector) && hasConnectorName;
     }
+
+    /**
+     * Check if a segment can be added to the current selection
+     * Prevents mixing horizontal and vertical segments
+     * @param {THREE.Object3D} segment - The segment to check
+     * @returns {boolean} True if segment can be added, false otherwise
+     * @private
+     */
+  }, {
+    key: "_canAddSegmentToSelection",
+    value: function _canAddSegmentToSelection(segment) {
+      if (!isSegment(segment)) {
+        return true; // Non-segments can always be added
+      }
+
+      // Find any segments already in selection
+      var existingSegments = this.selectedObjects.filter(function (obj) {
+        return isSegment(obj);
+      });
+
+      // If no segments selected yet, this is the first one - allow it
+      if (existingSegments.length === 0) {
+        return true;
+      }
+
+      // Check orientation compatibility
+      var isNewSegmentHorizontal = this._isSegmentHorizontal(segment);
+
+      // Check if all existing segments have the same orientation
+      var _iterator = _createForOfIteratorHelper(existingSegments),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var existingSegment = _step.value;
+          var isExistingHorizontal = this._isSegmentHorizontal(existingSegment);
+
+          // Disallow mixing horizontal and vertical
+          if (isNewSegmentHorizontal !== isExistingHorizontal) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return true;
+    }
+
+    /**
+     * Check if a segment is horizontal (Z-up coordinate system)
+     * @param {THREE.Object3D} segment - The segment to check
+     * @returns {boolean} True if horizontal, false if vertical
+     * @private
+     */
+  }, {
+    key: "_isSegmentHorizontal",
+    value: function _isSegmentHorizontal(segment) {
+      if (!segment || !segment.geometry || !segment.quaternion) {
+        return false;
+      }
+
+      // Get the segment's direction vector (cylinder aligned with Y-axis by default)
+      var direction = new THREE__namespace.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+      direction.normalize();
+
+      // In Z-up coordinate system, horizontal segments have Z component near 0
+      var zComponent = Math.abs(direction.z);
+      var tolerance = 0.1; // ~5.7 degrees
+
+      return zComponent < tolerance;
+    }
+
     /**
      * Default object selection filter
      * @param {THREE.Object3D} object - The object to check
@@ -4112,6 +4186,12 @@ var TransformControlsManager = /*#__PURE__*/function () {
         this.selectedObjects.splice(index, 1);
         console.log("\u2796 Removed from selection: ".concat(object.name || object.uuid));
       } else {
+        // Validate segment orientation compatibility before adding
+        if (isSegment(object) && !this._canAddSegmentToSelection(object)) {
+          console.warn('⚠️ Cannot mix horizontal and vertical segments in multi-selection');
+          return;
+        }
+
         // Object is not selected, add it
         this.selectedObjects.push(object);
         console.log("\u2795 Added to selection: ".concat(object.name || object.uuid));
@@ -4768,11 +4848,11 @@ var TransformControlsManager = /*#__PURE__*/function () {
       var objectFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
       var objectsWithBounds = this.getSelectableObjectsWithBounds(objectFilter);
       var intersections = [];
-      var _iterator = _createForOfIteratorHelper(objectsWithBounds),
-        _step;
+      var _iterator2 = _createForOfIteratorHelper(objectsWithBounds),
+        _step2;
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var item = _step.value;
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var item = _step2.value;
           var object = item.object,
             boundingBox = item.boundingBox;
 
@@ -4792,9 +4872,9 @@ var TransformControlsManager = /*#__PURE__*/function () {
 
         // Sort by distance (closest first)
       } catch (err) {
-        _iterator.e(err);
+        _iterator2.e(err);
       } finally {
-        _iterator.f();
+        _iterator2.f();
       }
       intersections.sort(function (a, b) {
         return a.distance - b.distance;
@@ -4896,35 +4976,20 @@ var TransformControlsManager = /*#__PURE__*/function () {
     key: "applyMultiSelectionTransform",
     value: (function () {
       var _applyMultiSelectionTransform = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
-        var _this9 = this;
-        var groupPosition, originalCentroid, positionDelta, deltaX, deltaY, deltaZ, threshold, _this$sceneViewer, _this$sceneViewer2, _this$sceneViewer3, _this$sceneViewer4, _this$sceneViewer5, segments, gateways, components, transformOpsManager, THROTTLE_DELAY, SEGMENT_DELAY, _throttleDelay, _loop, i, _THROTTLE_DELAY, _SEGMENT_DELAY, _throttleDelay2, _loop2, _i, GATEWAY_THROTTLE, GATEWAY_DELAY, COMPONENT_THROTTLE, COMPONENT_DELAY, throttleDelay, _i2, _gateway$userData, gateway, gatewayId, _i3, _component$userData, component, componentId;
-        return _regenerator().w(function (_context4) {
-          while (1) switch (_context4.n) {
+        var _this$_calculateTrans, deltaX, deltaY, deltaZ, threshold, segments, gateways, components;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
             case 0:
               if (!(!this.multiSelectionGroup || this.selectedObjects.length === 0)) {
-                _context4.n = 1;
+                _context2.n = 1;
                 break;
               }
-              return _context4.a(2);
+              return _context2.a(2);
             case 1:
               console.log("\uD83D\uDD27 Applying multi-selection transform to ".concat(this.selectedObjects.length, " objects"));
 
-              // Calculate the transformation delta from the group
-              groupPosition = this.multiSelectionGroup.position.clone(); // Get the original centroid position (from when group was created)
-              originalCentroid = new THREE__namespace.Vector3();
-              this.selectedObjects.forEach(function (obj) {
-                var originalWorldPos = obj.userData._multiSelectOriginalWorldPosition;
-                if (originalWorldPos) {
-                  originalCentroid.add(originalWorldPos);
-                }
-              });
-              originalCentroid.divideScalar(this.selectedObjects.length);
-
-              // Calculate position delta - this is the same for ALL objects
-              positionDelta = groupPosition.clone().sub(originalCentroid); // Round deltas to avoid floating point precision issues
-              deltaX = Math.round(positionDelta.x * 2) / 2;
-              deltaY = Math.round(positionDelta.y * 2) / 2;
-              deltaZ = Math.round(positionDelta.z * 2) / 2;
+              // Calculate transformation deltas
+              _this$_calculateTrans = this._calculateTransformDeltas(), deltaX = _this$_calculateTrans.deltaX, deltaY = _this$_calculateTrans.deltaY, deltaZ = _this$_calculateTrans.deltaZ, threshold = _this$_calculateTrans.threshold;
               console.log('🔧 Transform delta:', {
                 deltaX: deltaX,
                 deltaY: deltaY,
@@ -4932,23 +4997,16 @@ var TransformControlsManager = /*#__PURE__*/function () {
               });
 
               // Only process if there's a meaningful translation
-              threshold = 0.001;
-              if (!(this.currentMode === 'translate' && positionDelta.length() > threshold)) {
-                _context4.n = 21;
+              if (!(this.currentMode !== 'translate' || Math.abs(deltaX) < threshold && Math.abs(deltaY) < threshold && Math.abs(deltaZ) < threshold)) {
+                _context2.n = 2;
                 break;
               }
-              // FIRST: Reset all objects to their original positions
-              // This undoes the visual transform applied during drag
-              this.selectedObjects.forEach(function (obj) {
-                var originalPos = obj.userData._multiSelectOriginalPosition;
-                if (originalPos) {
-                  obj.position.copy(originalPos);
-                  obj.updateMatrixWorld(true);
-                }
-              });
-              console.log('🔄 Reset objects to original positions before API calls');
+              return _context2.a(2);
+            case 2:
+              // Reset all objects to original positions
+              this._resetObjectsToOriginalPositions();
 
-              // Separate segments from other objects
+              // Separate objects by type
               segments = this.selectedObjects.filter(function (obj) {
                 return isSegment(obj);
               });
@@ -4957,433 +5015,462 @@ var TransformControlsManager = /*#__PURE__*/function () {
               });
               components = this.selectedObjects.filter(function (obj) {
                 return !isSegment(obj) && !isGateway(obj);
-              }); // Debug: Check availability of managers
-              console.log('🔍 Debug - sceneViewer available:', !!this.sceneViewer);
-              console.log('🔍 Debug - sceneViewer.managers available:', !!((_this$sceneViewer = this.sceneViewer) !== null && _this$sceneViewer !== void 0 && _this$sceneViewer.managers));
-              console.log('🔍 Debug - Available managers:', (_this$sceneViewer2 = this.sceneViewer) !== null && _this$sceneViewer2 !== void 0 && _this$sceneViewer2.managers ? Object.keys(this.sceneViewer.managers) : 'none');
-              console.log('🔍 Debug - transformOperationsManager (direct):', !!((_this$sceneViewer3 = this.sceneViewer) !== null && _this$sceneViewer3 !== void 0 && _this$sceneViewer3.transformOperationsManager));
-              console.log('🔍 Debug - transformOperations (managers.transformOperations):', !!((_this$sceneViewer4 = this.sceneViewer) !== null && _this$sceneViewer4 !== void 0 && (_this$sceneViewer4 = _this$sceneViewer4.managers) !== null && _this$sceneViewer4 !== void 0 && _this$sceneViewer4.transformOperations));
-              console.log('🔍 Debug - Segments to translate:', segments.length);
-
-              // BATCH SEGMENT TRANSLATIONS: Call translateSegment with skipPathUpdate=true
-              // Process segments SEQUENTIALLY with throttling for maximum stability
-              // Access transformOperationsManager directly from sceneViewer (it's attached in attachToComponent)
-              if (!(segments.length > 0 && (_this$sceneViewer5 = this.sceneViewer) !== null && _this$sceneViewer5 !== void 0 && _this$sceneViewer5.transformOperationsManager)) {
-                _context4.n = 5;
+              }); // Translate each object type
+              _context2.n = 3;
+              return this._translateSegments(segments, deltaX, deltaY, deltaZ, threshold);
+            case 3:
+              _context2.n = 4;
+              return this._translateGateways(gateways, deltaX, deltaY, deltaZ, threshold);
+            case 4:
+              _context2.n = 5;
+              return this._translateComponents(components, deltaX, deltaY, deltaZ, threshold);
+            case 5:
+              console.log("\u2705 All ".concat(this.selectedObjects.length, " objects translated"));
+
+              // Cleanup and refresh
+              this._finalizeMultiSelectionTransform();
+            case 6:
+              return _context2.a(2);
+          }
+        }, _callee2, this);
+      }));
+      function applyMultiSelectionTransform() {
+        return _applyMultiSelectionTransform.apply(this, arguments);
+      }
+      return applyMultiSelectionTransform;
+    }()
+    /**
+     * Calculate transformation deltas from multi-selection group
+     * @returns {Object} Delta values and threshold
+     * @private
+     */
+    )
+  }, {
+    key: "_calculateTransformDeltas",
+    value: function _calculateTransformDeltas() {
+      var groupPosition = this.multiSelectionGroup.position.clone();
+
+      // Get original centroid position
+      var originalCentroid = new THREE__namespace.Vector3();
+      this.selectedObjects.forEach(function (obj) {
+        var originalWorldPos = obj.userData._multiSelectOriginalWorldPosition;
+        if (originalWorldPos) {
+          originalCentroid.add(originalWorldPos);
+        }
+      });
+      originalCentroid.divideScalar(this.selectedObjects.length);
+
+      // Calculate and round deltas
+      var positionDelta = groupPosition.clone().sub(originalCentroid);
+      return {
+        deltaX: Math.round(positionDelta.x * 2) / 2,
+        deltaY: Math.round(positionDelta.y * 2) / 2,
+        deltaZ: Math.round(positionDelta.z * 2) / 2,
+        threshold: 0.001
+      };
+    }
+
+    /**
+     * Reset all selected objects to their original positions
+     * @private
+     */
+  }, {
+    key: "_resetObjectsToOriginalPositions",
+    value: function _resetObjectsToOriginalPositions() {
+      this.selectedObjects.forEach(function (obj) {
+        var originalPos = obj.userData._multiSelectOriginalPosition;
+        if (originalPos) {
+          obj.position.copy(originalPos);
+          obj.updateMatrixWorld(true);
+        }
+      });
+      console.log('🔄 Reset objects to original positions before API calls');
+    }
+
+    /**
+     * Translate segments with batched path updates
+     * @private
+     */
+  }, {
+    key: "_translateSegments",
+    value: (function () {
+      var _translateSegments2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(segments, deltaX, deltaY, deltaZ, threshold) {
+        var _this$sceneViewer, _this$sceneViewer2;
+        var transformOpsManager, useOptimizedPath, throttleDelay, AXIS_THROTTLE, OBJECT_DELAY, i, segment, axes, _i, _axes, _axes$_i, axis, delta;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (!(segments.length === 0)) {
+                _context3.n = 1;
                 break;
               }
-              console.log("\uD83D\uDD27 Batch translating ".concat(segments.length, " segments (sequential with throttling)..."));
-              transformOpsManager = this.sceneViewer.transformOperationsManager; // Throttle delay in milliseconds (adjust as needed for stability)
-              THROTTLE_DELAY = 10; // 10ms between axis operations
-              SEGMENT_DELAY = 20; // 20ms between segments
-              // Helper function for throttled delay
-              _throttleDelay = function _throttleDelay(ms) {
+              return _context3.a(2);
+            case 1:
+              transformOpsManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.transformOperationsManager;
+              useOptimizedPath = transformOpsManager != null;
+              if (useOptimizedPath) {
+                console.log("\uD83D\uDD27 Batch translating ".concat(segments.length, " segments..."));
+              } else {
+                console.warn('⚠️ TransformOperationsManager not available, using fallback');
+              }
+              throttleDelay = function throttleDelay(ms) {
                 return new Promise(function (resolve) {
                   return setTimeout(resolve, ms);
                 });
-              }; // Process each segment sequentially with throttling for stability
-              _loop = /*#__PURE__*/_regenerator().m(function _loop(i) {
-                var segment, _segment$userData, _segment$userData2, segmentId, success, newSegmentId, _segment$userData3, _segment$userData4, _segmentId, _success, _newSegmentId, _segment$userData5, _segment$userData6, _segmentId2, _success2, _newSegmentId2, selectedIndex;
-                return _regenerator().w(function (_context2) {
-                  while (1) switch (_context2.n) {
-                    case 0:
-                      segment = segments[i]; // Call translateSegment API with skipPathUpdate=true to defer path updates
-                      // IMPORTANT: Refresh segment reference after each axis to handle UUID changes from manualization
-                      if (!(Math.abs(deltaX) > threshold)) {
-                        _context2.n = 1;
-                        break;
-                      }
-                      segmentId = segment.uuid || ((_segment$userData = segment.userData) === null || _segment$userData === void 0 ? void 0 : _segment$userData.originalUuid);
-                      success = transformOpsManager.translateSegment(segmentId, 'x', deltaX, true);
-                      if (!success) {
-                        console.warn("\u26A0\uFE0F Failed to translate segment ".concat(segmentId, " on X axis"));
-                      }
-                      // Refresh segment reference by searching for the new UUID or by segmentIndex
-                      // After manualization, UUID changes from SEGMENT-X to Segment-X
-                      newSegmentId = (_segment$userData2 = segment.userData) !== null && _segment$userData2 !== void 0 && _segment$userData2.segmentIndex ? "SEGMENT-".concat(segment.userData.segmentIndex) : segmentId;
-                      segment = _this9.sceneViewer.scene.getObjectByProperty('uuid', newSegmentId) || segment;
-
-                      // Update matrix to ensure geometry is current for next operation
-                      if (segment) {
-                        segment.updateMatrix();
-                        segment.updateMatrixWorld(true);
-                      }
-                      _context2.n = 1;
-                      return _throttleDelay(THROTTLE_DELAY);
-                    case 1:
-                      if (!(Math.abs(deltaY) > threshold)) {
-                        _context2.n = 2;
-                        break;
-                      }
-                      _segmentId = segment.uuid || ((_segment$userData3 = segment.userData) === null || _segment$userData3 === void 0 ? void 0 : _segment$userData3.originalUuid);
-                      _success = transformOpsManager.translateSegment(_segmentId, 'y', deltaY, true);
-                      if (!_success) {
-                        console.warn("\u26A0\uFE0F Failed to translate segment ".concat(_segmentId, " on Y axis"));
-                      }
-                      // Refresh segment reference by searching for the new UUID
-                      _newSegmentId = (_segment$userData4 = segment.userData) !== null && _segment$userData4 !== void 0 && _segment$userData4.segmentIndex ? "SEGMENT-".concat(segment.userData.segmentIndex) : _segmentId;
-                      segment = _this9.sceneViewer.scene.getObjectByProperty('uuid', _newSegmentId) || segment;
-
-                      // Update matrix to ensure geometry is current for next operation
-                      if (segment) {
-                        segment.updateMatrix();
-                        segment.updateMatrixWorld(true);
-                      }
-                      _context2.n = 2;
-                      return _throttleDelay(THROTTLE_DELAY);
-                    case 2:
-                      if (!(Math.abs(deltaZ) > threshold)) {
-                        _context2.n = 3;
-                        break;
-                      }
-                      _segmentId2 = segment.uuid || ((_segment$userData5 = segment.userData) === null || _segment$userData5 === void 0 ? void 0 : _segment$userData5.originalUuid);
-                      _success2 = transformOpsManager.translateSegment(_segmentId2, 'z', deltaZ, true);
-                      if (!_success2) {
-                        console.warn("\u26A0\uFE0F Failed to translate segment ".concat(_segmentId2, " on Z axis"));
-                      }
-                      // Refresh segment reference by searching for the new UUID
-                      _newSegmentId2 = (_segment$userData6 = segment.userData) !== null && _segment$userData6 !== void 0 && _segment$userData6.segmentIndex ? "SEGMENT-".concat(segment.userData.segmentIndex) : _segmentId2;
-                      segment = _this9.sceneViewer.scene.getObjectByProperty('uuid', _newSegmentId2) || segment;
-
-                      // Update matrix to ensure geometry is current for next operation
-                      if (segment) {
-                        segment.updateMatrix();
-                        segment.updateMatrixWorld(true);
-                      }
-                      _context2.n = 3;
-                      return _throttleDelay(THROTTLE_DELAY);
-                    case 3:
-                      // Update the segment in the selectedObjects array with the refreshed reference
-                      // This ensures transform controls and multi-selection display use the current object
-                      selectedIndex = _this9.selectedObjects.findIndex(function (obj) {
-                        var _obj$userData;
-                        return obj.uuid === segments[i].uuid || ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.originalUuid) === segments[i].uuid;
-                      });
-                      if (selectedIndex !== -1 && segment) {
-                        // Clear bounding box cache for both old and new segment references
-                        if (_this9.boundingBoxCache.has(segments[i])) {
-                          _this9.boundingBoxCache.delete(segments[i]);
-                        }
-                        if (_this9.boundingBoxCache.has(segment)) {
-                          _this9.boundingBoxCache.delete(segment);
-                        }
-                        _this9.selectedObjects[selectedIndex] = segment;
-                        console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
-                      }
-                      if (segment) {
-                        console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(i + 1, "/").concat(segments.length, "):"), {
-                          deltaX: deltaX,
-                          deltaY: deltaY,
-                          deltaZ: deltaZ
-                        });
-                      } else {
-                        console.warn("\u26A0\uFE0F Segment reference became null after translation (".concat(i + 1, "/").concat(segments.length, ")"));
-                      }
-
-                      // Delay between segments to ensure all updates propagate
-                      if (!(i < segments.length - 1)) {
-                        _context2.n = 4;
-                        break;
-                      }
-                      _context2.n = 4;
-                      return _throttleDelay(SEGMENT_DELAY);
-                    case 4:
-                      return _context2.a(2);
-                  }
-                }, _loop);
-              });
+              };
+              AXIS_THROTTLE = 10;
+              OBJECT_DELAY = 20;
               i = 0;
             case 2:
               if (!(i < segments.length)) {
-                _context4.n = 4;
+                _context3.n = 8;
                 break;
               }
-              return _context4.d(_regeneratorValues(_loop(i)), 3);
+              segment = segments[i];
+              axes = [{
+                axis: 'x',
+                delta: deltaX
+              }, {
+                axis: 'y',
+                delta: deltaY
+              }, {
+                axis: 'z',
+                delta: deltaZ
+              }]; // Translate on each axis
+              _i = 0, _axes = axes;
             case 3:
-              i++;
-              _context4.n = 2;
-              break;
-            case 4:
-              // Only call updatePaths ONCE after all segments are translated
-              console.log('🔄 Calling updatePaths once for all segments...');
-              if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
-                this.sceneViewer.updatePaths();
-                console.log('✅ Paths regenerated successfully for all segments');
+              if (!(_i < _axes.length)) {
+                _context3.n = 6;
+                break;
               }
-              _context4.n = 8;
-              break;
-            case 5:
-              if (!(segments.length > 0)) {
-                _context4.n = 8;
+              _axes$_i = _axes[_i], axis = _axes$_i.axis, delta = _axes$_i.delta;
+              if (!(Math.abs(delta) > threshold)) {
+                _context3.n = 5;
                 break;
               }
-              // Fallback to individual API calls if manager not available
-              // Note: These calls include updatePaths() so will be slower
-              console.warn('⚠️ TransformOperationsManager not available, using individual API calls');
-
-              // Use same throttling as above
-              _THROTTLE_DELAY = 10;
-              _SEGMENT_DELAY = 20;
-              _throttleDelay2 = function _throttleDelay2(ms) {
-                return new Promise(function (resolve) {
-                  return setTimeout(resolve, ms);
-                });
-              };
-              _loop2 = /*#__PURE__*/_regenerator().m(function _loop2(_i) {
-                var segment, _segment$userData7, _segment$userData8, segmentId, newSegmentId, _segment$userData9, _segment$userData0, _segmentId3, _newSegmentId3, _segment$userData1, _segment$userData10, _segmentId4, _newSegmentId4, selectedIndex;
-                return _regenerator().w(function (_context3) {
-                  while (1) switch (_context3.n) {
-                    case 0:
-                      segment = segments[_i];
-                      if (!(Math.abs(deltaX) > threshold)) {
-                        _context3.n = 1;
-                        break;
-                      }
-                      segmentId = segment.uuid || ((_segment$userData7 = segment.userData) === null || _segment$userData7 === void 0 ? void 0 : _segment$userData7.originalUuid);
-                      _this9.centralPlant.translateSegment(segmentId, 'x', deltaX);
-                      // Refresh segment reference by searching for the new UUID after manualization
-                      newSegmentId = (_segment$userData8 = segment.userData) !== null && _segment$userData8 !== void 0 && _segment$userData8.segmentIndex ? "SEGMENT-".concat(segment.userData.segmentIndex) : segmentId;
-                      segment = _this9.sceneViewer.scene.getObjectByProperty('uuid', newSegmentId) || segment;
-
-                      // Update matrix to ensure geometry is current for next operation
-                      if (segment) {
-                        segment.updateMatrix();
-                        segment.updateMatrixWorld(true);
-                      }
-                      _context3.n = 1;
-                      return _throttleDelay2(_THROTTLE_DELAY);
-                    case 1:
-                      if (!(Math.abs(deltaY) > threshold)) {
-                        _context3.n = 2;
-                        break;
-                      }
-                      _segmentId3 = segment.uuid || ((_segment$userData9 = segment.userData) === null || _segment$userData9 === void 0 ? void 0 : _segment$userData9.originalUuid);
-                      _this9.centralPlant.translateSegment(_segmentId3, 'y', deltaY);
-                      // Refresh segment reference by searching for the new UUID after manualization
-                      _newSegmentId3 = (_segment$userData0 = segment.userData) !== null && _segment$userData0 !== void 0 && _segment$userData0.segmentIndex ? "SEGMENT-".concat(segment.userData.segmentIndex) : _segmentId3;
-                      segment = _this9.sceneViewer.scene.getObjectByProperty('uuid', _newSegmentId3) || segment;
-
-                      // Update matrix to ensure geometry is current for next operation
-                      if (segment) {
-                        segment.updateMatrix();
-                        segment.updateMatrixWorld(true);
-                      }
-                      _context3.n = 2;
-                      return _throttleDelay2(_THROTTLE_DELAY);
-                    case 2:
-                      if (!(Math.abs(deltaZ) > threshold)) {
-                        _context3.n = 3;
-                        break;
-                      }
-                      _segmentId4 = segment.uuid || ((_segment$userData1 = segment.userData) === null || _segment$userData1 === void 0 ? void 0 : _segment$userData1.originalUuid);
-                      _this9.centralPlant.translateSegment(_segmentId4, 'z', deltaZ);
-                      // Refresh segment reference by searching for the new UUID after manualization
-                      _newSegmentId4 = (_segment$userData10 = segment.userData) !== null && _segment$userData10 !== void 0 && _segment$userData10.segmentIndex ? "SEGMENT-".concat(segment.userData.segmentIndex) : _segmentId4;
-                      segment = _this9.sceneViewer.scene.getObjectByProperty('uuid', _newSegmentId4) || segment;
-
-                      // Update matrix to ensure geometry is current for next operation
-                      if (segment) {
-                        segment.updateMatrix();
-                        segment.updateMatrixWorld(true);
-                      }
-                      _context3.n = 3;
-                      return _throttleDelay2(_THROTTLE_DELAY);
-                    case 3:
-                      // Update the segment in the selectedObjects array with the refreshed reference
-                      selectedIndex = _this9.selectedObjects.findIndex(function (obj) {
-                        var _obj$userData2;
-                        return obj.uuid === segments[_i].uuid || ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.originalUuid) === segments[_i].uuid;
-                      });
-                      if (selectedIndex !== -1 && segment) {
-                        // Clear bounding box cache for both old and new segment references
-                        if (_this9.boundingBoxCache.has(segments[_i])) {
-                          _this9.boundingBoxCache.delete(segments[_i]);
-                        }
-                        if (_this9.boundingBoxCache.has(segment)) {
-                          _this9.boundingBoxCache.delete(segment);
-                        }
-                        _this9.selectedObjects[selectedIndex] = segment;
-                        console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
-                      }
-                      if (segment) {
-                        console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(_i + 1, "/").concat(segments.length, "):"), {
-                          deltaX: deltaX,
-                          deltaY: deltaY,
-                          deltaZ: deltaZ
-                        });
-                      } else {
-                        console.warn("\u26A0\uFE0F Segment reference became null after translation (".concat(_i + 1, "/").concat(segments.length, ")"));
-                      }
-
-                      // Delay between segments
-                      if (!(_i < segments.length - 1)) {
-                        _context3.n = 4;
-                        break;
-                      }
-                      _context3.n = 4;
-                      return _throttleDelay2(_SEGMENT_DELAY);
-                    case 4:
-                      return _context3.a(2);
-                  }
-                }, _loop2);
-              });
-              _i = 0;
+              _context3.n = 4;
+              return this._translateSegmentOnAxis(segment, axis, delta, useOptimizedPath, i);
+            case 4:
+              segment = _context3.v;
+              _context3.n = 5;
+              return throttleDelay(AXIS_THROTTLE);
+            case 5:
+              _i++;
+              _context3.n = 3;
+              break;
             case 6:
-              if (!(_i < segments.length)) {
-                _context4.n = 8;
+              // Update selected objects array with refreshed reference
+              this._updateSegmentReference(segments[i], segment, i);
+              if (segment) {
+                console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(i + 1, "/").concat(segments.length, ")"));
+              } else {
+                console.warn("\u26A0\uFE0F Segment reference became null (".concat(i + 1, "/").concat(segments.length, ")"));
+              }
+              if (!(i < segments.length - 1)) {
+                _context3.n = 7;
                 break;
               }
-              return _context4.d(_regeneratorValues(_loop2(_i)), 7);
+              _context3.n = 7;
+              return throttleDelay(OBJECT_DELAY);
             case 7:
-              _i++;
-              _context4.n = 6;
+              i++;
+              _context3.n = 2;
               break;
             case 8:
-              // Throttle delays for gateways and components
-              GATEWAY_THROTTLE = 10;
-              GATEWAY_DELAY = 15;
-              COMPONENT_THROTTLE = 10;
-              COMPONENT_DELAY = 15;
+              // Batch update paths for optimized path only
+              if (useOptimizedPath && (_this$sceneViewer2 = this.sceneViewer) !== null && _this$sceneViewer2 !== void 0 && _this$sceneViewer2.updatePaths) {
+                console.log('🔄 Calling updatePaths once for all segments...');
+                this.sceneViewer.updatePaths();
+                console.log('✅ Paths regenerated successfully');
+              }
+            case 9:
+              return _context3.a(2);
+          }
+        }, _callee3, this);
+      }));
+      function _translateSegments(_x, _x2, _x3, _x4, _x5) {
+        return _translateSegments2.apply(this, arguments);
+      }
+      return _translateSegments;
+    }()
+    /**
+     * Refresh segment reference after manualization
+     * Handles the UUID change from original format to SEGMENT-{index} format
+     * @param {THREE.Object3D} segment - Original segment object
+     * @returns {THREE.Object3D|null} Refreshed segment reference or null if not found
+     * @private
+     */
+    )
+  }, {
+    key: "_refreshSegmentReference",
+    value: function _refreshSegmentReference(segment) {
+      var _segment$userData, _segment$userData2;
+      if (!segment) return null;
+      var segmentId = segment.uuid || ((_segment$userData = segment.userData) === null || _segment$userData === void 0 ? void 0 : _segment$userData.originalUuid);
+
+      // Try to find by new UUID format (SEGMENT-{index})
+      var newSegmentId = (_segment$userData2 = segment.userData) !== null && _segment$userData2 !== void 0 && _segment$userData2.segmentIndex ? "SEGMENT-".concat(segment.userData.segmentIndex) : segmentId;
+      var refreshedSegment = this.sceneViewer.scene.getObjectByProperty('uuid', newSegmentId) || segment;
+      if (refreshedSegment) {
+        refreshedSegment.updateMatrix();
+        refreshedSegment.updateMatrixWorld(true);
+      }
+      return refreshedSegment;
+    }
+
+    /**
+     * Translate a segment on a single axis and refresh its reference
+     * @private
+     */
+  }, {
+    key: "_translateSegmentOnAxis",
+    value: (function () {
+      var _translateSegmentOnAxis2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(segment, axis, delta, useOptimizedPath, index) {
+        var _segment$userData3;
+        var segmentId, success;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              segmentId = segment.uuid || ((_segment$userData3 = segment.userData) === null || _segment$userData3 === void 0 ? void 0 : _segment$userData3.originalUuid);
+              if (useOptimizedPath) {
+                success = this.sceneViewer.transformOperationsManager.translateSegment(segmentId, axis, delta, true);
+                if (!success) {
+                  console.warn("\u26A0\uFE0F Failed to translate segment ".concat(segmentId, " on ").concat(axis, " axis"));
+                }
+              } else {
+                this.centralPlant.translateSegment(segmentId, axis, delta);
+              }
+
+              // Refresh segment reference after manualization
+              return _context4.a(2, this._refreshSegmentReference(segment));
+          }
+        }, _callee4, this);
+      }));
+      function _translateSegmentOnAxis(_x6, _x7, _x8, _x9, _x0) {
+        return _translateSegmentOnAxis2.apply(this, arguments);
+      }
+      return _translateSegmentOnAxis;
+    }()
+    /**
+     * Update segment reference in selectedObjects array and clear cache
+     * @private
+     */
+    )
+  }, {
+    key: "_updateSegmentReference",
+    value: function _updateSegmentReference(oldSegment, newSegment, index) {
+      var selectedIndex = this.selectedObjects.findIndex(function (obj) {
+        var _obj$userData;
+        return obj.uuid === oldSegment.uuid || ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.originalUuid) === oldSegment.uuid;
+      });
+      if (selectedIndex !== -1 && newSegment) {
+        // Clear bounding box cache
+        this.boundingBoxCache.delete(oldSegment);
+        this.boundingBoxCache.delete(newSegment);
+        this.selectedObjects[selectedIndex] = newSegment;
+        console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed reference"));
+      }
+    }
+
+    /**
+     * Translate gateways on all axes
+     * @private
+     */
+  }, {
+    key: "_translateGateways",
+    value: (function () {
+      var _translateGateways2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(gateways, deltaX, deltaY, deltaZ, threshold) {
+        var _this9 = this;
+        var throttleDelay, AXIS_THROTTLE, OBJECT_DELAY, i, _gateway$userData, gateway, gatewayId;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              if (!(gateways.length === 0)) {
+                _context5.n = 1;
+                break;
+              }
+              return _context5.a(2);
+            case 1:
               throttleDelay = function throttleDelay(ms) {
                 return new Promise(function (resolve) {
                   return setTimeout(resolve, ms);
                 });
-              }; // Translate gateways sequentially with throttling
-              _i2 = 0;
-            case 9:
-              if (!(_i2 < gateways.length)) {
-                _context4.n = 14;
+              };
+              AXIS_THROTTLE = 10;
+              OBJECT_DELAY = 15;
+              i = 0;
+            case 2:
+              if (!(i < gateways.length)) {
+                _context5.n = 5;
                 break;
               }
-              gateway = gateways[_i2];
+              gateway = gateways[i];
               gatewayId = gateway.uuid || ((_gateway$userData = gateway.userData) === null || _gateway$userData === void 0 ? void 0 : _gateway$userData.originalUuid);
-              if (!(Math.abs(deltaX) > threshold)) {
-                _context4.n = 10;
-                break;
-              }
-              this.centralPlant.translateGateway(gatewayId, 'x', deltaX);
-              _context4.n = 10;
-              return throttleDelay(GATEWAY_THROTTLE);
-            case 10:
-              if (!(Math.abs(deltaY) > threshold)) {
-                _context4.n = 11;
-                break;
-              }
-              this.centralPlant.translateGateway(gatewayId, 'y', deltaY);
-              _context4.n = 11;
-              return throttleDelay(GATEWAY_THROTTLE);
-            case 11:
-              if (!(Math.abs(deltaZ) > threshold)) {
-                _context4.n = 12;
-                break;
-              }
-              this.centralPlant.translateGateway(gatewayId, 'z', deltaZ);
-              _context4.n = 12;
-              return throttleDelay(GATEWAY_THROTTLE);
-            case 12:
-              console.log("\uD83D\uDEAA Gateway ".concat(gateway.name, " translated (").concat(_i2 + 1, "/").concat(gateways.length, "):"), {
-                deltaX: deltaX,
-                deltaY: deltaY,
-                deltaZ: deltaZ
+              _context5.n = 3;
+              return this._translateObjectOnAxes(gatewayId, deltaX, deltaY, deltaZ, threshold, throttleDelay, AXIS_THROTTLE, function (id, axis, delta) {
+                return _this9.centralPlant.translateGateway(id, axis, delta);
               });
-
-              // Delay between gateways
-              if (!(_i2 < gateways.length - 1)) {
-                _context4.n = 13;
+            case 3:
+              console.log("\uD83D\uDEAA Gateway ".concat(gateway.name, " translated (").concat(i + 1, "/").concat(gateways.length, ")"));
+              if (!(i < gateways.length - 1)) {
+                _context5.n = 4;
                 break;
               }
-              _context4.n = 13;
-              return throttleDelay(GATEWAY_DELAY);
-            case 13:
-              _i2++;
-              _context4.n = 9;
+              _context5.n = 4;
+              return throttleDelay(OBJECT_DELAY);
+            case 4:
+              i++;
+              _context5.n = 2;
               break;
-            case 14:
-              _i3 = 0;
-            case 15:
-              if (!(_i3 < components.length)) {
-                _context4.n = 20;
-                break;
-              }
-              component = components[_i3];
-              componentId = component.uuid || ((_component$userData = component.userData) === null || _component$userData === void 0 ? void 0 : _component$userData.originalUuid);
-              if (!(Math.abs(deltaX) > threshold)) {
-                _context4.n = 16;
-                break;
-              }
-              this.centralPlant.translate(componentId, 'x', deltaX);
-              _context4.n = 16;
-              return throttleDelay(COMPONENT_THROTTLE);
-            case 16:
-              if (!(Math.abs(deltaY) > threshold)) {
-                _context4.n = 17;
+            case 5:
+              return _context5.a(2);
+          }
+        }, _callee5, this);
+      }));
+      function _translateGateways(_x1, _x10, _x11, _x12, _x13) {
+        return _translateGateways2.apply(this, arguments);
+      }
+      return _translateGateways;
+    }()
+    /**
+     * Translate components on all axes
+     * @private
+     */
+    )
+  }, {
+    key: "_translateComponents",
+    value: (function () {
+      var _translateComponents2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(components, deltaX, deltaY, deltaZ, threshold) {
+        var _this0 = this;
+        var throttleDelay, AXIS_THROTTLE, OBJECT_DELAY, i, _component$userData, component, componentId;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              if (!(components.length === 0)) {
+                _context6.n = 1;
                 break;
               }
-              this.centralPlant.translate(componentId, 'y', deltaY);
-              _context4.n = 17;
-              return throttleDelay(COMPONENT_THROTTLE);
-            case 17:
-              if (!(Math.abs(deltaZ) > threshold)) {
-                _context4.n = 18;
+              return _context6.a(2);
+            case 1:
+              throttleDelay = function throttleDelay(ms) {
+                return new Promise(function (resolve) {
+                  return setTimeout(resolve, ms);
+                });
+              };
+              AXIS_THROTTLE = 10;
+              OBJECT_DELAY = 15;
+              i = 0;
+            case 2:
+              if (!(i < components.length)) {
+                _context6.n = 5;
                 break;
               }
-              this.centralPlant.translate(componentId, 'z', deltaZ);
-              _context4.n = 18;
-              return throttleDelay(COMPONENT_THROTTLE);
-            case 18:
-              console.log("\uD83D\uDD27 Component ".concat(component.name, " translated (").concat(_i3 + 1, "/").concat(components.length, "):"), {
-                deltaX: deltaX,
-                deltaY: deltaY,
-                deltaZ: deltaZ
+              component = components[i];
+              componentId = component.uuid || ((_component$userData = component.userData) === null || _component$userData === void 0 ? void 0 : _component$userData.originalUuid);
+              _context6.n = 3;
+              return this._translateObjectOnAxes(componentId, deltaX, deltaY, deltaZ, threshold, throttleDelay, AXIS_THROTTLE, function (id, axis, delta) {
+                return _this0.centralPlant.translate(id, axis, delta);
               });
-
-              // Delay between components
-              if (!(_i3 < components.length - 1)) {
-                _context4.n = 19;
+            case 3:
+              console.log("\uD83D\uDD27 Component ".concat(component.name, " translated (").concat(i + 1, "/").concat(components.length, ")"));
+              if (!(i < components.length - 1)) {
+                _context6.n = 4;
                 break;
               }
-              _context4.n = 19;
-              return throttleDelay(COMPONENT_DELAY);
-            case 19:
-              _i3++;
-              _context4.n = 15;
+              _context6.n = 4;
+              return throttleDelay(OBJECT_DELAY);
+            case 4:
+              i++;
+              _context6.n = 2;
               break;
-            case 20:
-              console.log("\u2705 All ".concat(this.selectedObjects.length, " objects translated with delta:"), {
-                deltaX: deltaX,
-                deltaY: deltaY,
-                deltaZ: deltaZ
-              });
-            case 21:
-              // Reset the multi-selection group transform (if it still exists)
-              // Note: The group might have been cleared during async operations
-              if (this.multiSelectionGroup) {
-                this.multiSelectionGroup.position.set(0, 0, 0);
-                this.multiSelectionGroup.rotation.set(0, 0, 0);
-                this.multiSelectionGroup.scale.set(1, 1, 1);
-              } else {
-                console.warn('⚠️ Multi-selection group was cleared during transformation');
+            case 5:
+              return _context6.a(2);
+          }
+        }, _callee6, this);
+      }));
+      function _translateComponents(_x14, _x15, _x16, _x17, _x18) {
+        return _translateComponents2.apply(this, arguments);
+      }
+      return _translateComponents;
+    }()
+    /**
+     * Generic method to translate object on all axes with throttling
+     * @private
+     */
+    )
+  }, {
+    key: "_translateObjectOnAxes",
+    value: (function () {
+      var _translateObjectOnAxes2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(objectId, deltaX, deltaY, deltaZ, threshold, throttleDelay, axisThrottle, translateFn) {
+        var axes, _i2, _axes2, _axes2$_i, axis, delta;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              axes = [{
+                axis: 'x',
+                delta: deltaX
+              }, {
+                axis: 'y',
+                delta: deltaY
+              }, {
+                axis: 'z',
+                delta: deltaZ
+              }];
+              _i2 = 0, _axes2 = axes;
+            case 1:
+              if (!(_i2 < _axes2.length)) {
+                _context7.n = 3;
+                break;
               }
-
-              // CRITICAL: Clear bounding box cache after manualization
-              // Manualization changes object references, making cached boxes invalid
-              this.clearBoundingBoxCache();
-
-              // Update the multi-selection display with new positions (only if we still have selected objects)
-              if (this.selectedObjects.length > 0) {
-                this.updateMultiSelection();
+              _axes2$_i = _axes2[_i2], axis = _axes2$_i.axis, delta = _axes2$_i.delta;
+              if (!(Math.abs(delta) > threshold)) {
+                _context7.n = 2;
+                break;
               }
-              console.log("\u2705 Multi-selection transform applied");
-            case 22:
-              return _context4.a(2);
+              translateFn(objectId, axis, delta);
+              _context7.n = 2;
+              return throttleDelay(axisThrottle);
+            case 2:
+              _i2++;
+              _context7.n = 1;
+              break;
+            case 3:
+              return _context7.a(2);
           }
-        }, _callee2, this);
+        }, _callee7);
       }));
-      function applyMultiSelectionTransform() {
-        return _applyMultiSelectionTransform.apply(this, arguments);
+      function _translateObjectOnAxes(_x19, _x20, _x21, _x22, _x23, _x24, _x25, _x26) {
+        return _translateObjectOnAxes2.apply(this, arguments);
       }
-      return applyMultiSelectionTransform;
+      return _translateObjectOnAxes;
     }()
+    /**
+     * Finalize multi-selection transform by resetting group and updating display
+     * @private
+     */
+    )
+  }, {
+    key: "_finalizeMultiSelectionTransform",
+    value: function _finalizeMultiSelectionTransform() {
+      // Reset multi-selection group transform
+      if (this.multiSelectionGroup) {
+        this.multiSelectionGroup.position.set(0, 0, 0);
+        this.multiSelectionGroup.rotation.set(0, 0, 0);
+        this.multiSelectionGroup.scale.set(1, 1, 1);
+      } else {
+        console.warn('⚠️ Multi-selection group was cleared during transformation');
+      }
+
+      // Clear bounding box cache after manualization
+      this.clearBoundingBoxCache();
+
+      // Update multi-selection display
+      if (this.selectedObjects.length > 0) {
+        this.updateMultiSelection();
+      }
+      console.log("\u2705 Multi-selection transform applied");
+    }
+
     /**
      * Handle transformation of a pipe segment using the centralPlant translateSegment API
      * 
@@ -5393,11 +5480,10 @@ var TransformControlsManager = /*#__PURE__*/function () {
      * 
      * @param {THREE.Object3D} segment - The transformed pipe segment
      */
-    )
   }, {
     key: "handlePipeSegmentTransform",
     value: function handlePipeSegmentTransform(segment) {
-      var _this$transformState, _this$transformState2, _segment$userData11;
+      var _this$transformState, _this$transformState2, _segment$userData4;
       console.log('🔧 Pipe segment transformed:', segment.name);
 
       // Safety checks
@@ -5434,7 +5520,7 @@ var TransformControlsManager = /*#__PURE__*/function () {
       });
 
       // Get the segment ID (try both uuid and originalUuid)
-      var segmentId = segment.uuid || ((_segment$userData11 = segment.userData) === null || _segment$userData11 === void 0 ? void 0 : _segment$userData11.originalUuid);
+      var segmentId = segment.uuid || ((_segment$userData4 = segment.userData) === null || _segment$userData4 === void 0 ? void 0 : _segment$userData4.originalUuid);
       if (!segmentId) {
         console.error('❌ Cannot find segment ID for translateSegment API call');
         return;
@@ -5453,14 +5539,14 @@ var TransformControlsManager = /*#__PURE__*/function () {
       if (Math.abs(deltaY) > threshold) {
         // Round to nearest 0.5 to match grid snapping  
         var roundedDeltaY = Math.round(deltaY * 2) / 2;
-        var _success3 = this.centralPlant.translateSegment(segmentId, 'y', roundedDeltaY);
-        if (_success3) translationApplied = true;
+        var _success = this.centralPlant.translateSegment(segmentId, 'y', roundedDeltaY);
+        if (_success) translationApplied = true;
       }
       if (Math.abs(deltaZ) > threshold) {
         // Round to nearest 0.5 to match grid snapping
         var roundedDeltaZ = Math.round(deltaZ * 2) / 2;
-        var _success4 = this.centralPlant.translateSegment(segmentId, 'z', roundedDeltaZ);
-        if (_success4) translationApplied = true;
+        var _success2 = this.centralPlant.translateSegment(segmentId, 'z', roundedDeltaZ);
+        if (_success2) translationApplied = true;
       }
       if (translationApplied) {
         console.log("\u2705 Applied segment translation through centralPlant translateSegment API");
@@ -5536,14 +5622,14 @@ var TransformControlsManager = /*#__PURE__*/function () {
       if (Math.abs(deltaY) > threshold) {
         // Round to nearest 0.5 to match grid snapping  
         var roundedDeltaY = Math.round(deltaY * 2) / 2;
-        var _success5 = this.centralPlant.translateGateway(gatewayId, 'y', roundedDeltaY);
-        if (_success5) translationApplied = true;
+        var _success3 = this.centralPlant.translateGateway(gatewayId, 'y', roundedDeltaY);
+        if (_success3) translationApplied = true;
       }
       if (Math.abs(deltaZ) > threshold) {
         // Round to nearest 0.5 to match grid snapping
         var roundedDeltaZ = Math.round(deltaZ * 2) / 2;
-        var _success6 = this.centralPlant.translateGateway(gatewayId, 'z', roundedDeltaZ);
-        if (_success6) translationApplied = true;
+        var _success4 = this.centralPlant.translateGateway(gatewayId, 'z', roundedDeltaZ);
+        if (_success4) translationApplied = true;
       }
       if (translationApplied) {
         console.log("\u2705 Applied gateway translation through centralPlant translateGateway API");
@@ -19059,10 +19145,15 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         console.error("\u274C translateComponent(): Object with ID '".concat(componentId, "' is not a valid component"));
         return false;
       }
-
-      // Apply the translation
       console.log("\uD83D\uDD04 translateComponent(): Translating component ".concat(componentId, " on ").concat(axis, " axis by ").concat(value));
 
+      // Run collision validation checks before applying the translation
+      var collisionValidation = this.validateTranslateComponentCollisions(component, axis, value);
+      if (!collisionValidation) {
+        return false;
+      }
+
+      // All validations passed - apply the translation
       // Update the Three.js object position
       component.position[axis] += value;
 
@@ -19106,6 +19197,100 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return true;
     }
 
+    /**
+     * Validate collision checks for translateComponent operation
+     * @param {THREE.Object3D} component - The component to translate
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by
+     * @returns {boolean} True if no collisions detected, false if translation would cause collision
+     * @private
+     */
+  }, {
+    key: "validateTranslateComponentCollisions",
+    value: function validateTranslateComponentCollisions(component, axis, value) {
+      // Store original position for reverting
+      var originalPosition = component.position[axis];
+
+      // Temporarily apply the translation to check for collisions
+      component.position[axis] += value;
+      component.updateMatrix();
+      component.updateMatrixWorld(true);
+      console.log("\uD83D\uDD0D Checking collisions with translated position: ".concat(axis, "=").concat(component.position[axis].toFixed(3)));
+
+      // Check for collision with manual segments
+      var manualSegmentCollision = this.checkComponentManualSegmentCollision(component);
+      if (manualSegmentCollision) {
+        console.warn("\u26A0\uFE0F translateComponent(): Component would collide with manual segment (allowed)");
+        console.warn("   Segment ID: ".concat(manualSegmentCollision.segmentId));
+        console.warn("   Distance to segment: ".concat(manualSegmentCollision.distance.toFixed(3)));
+        console.warn("   Segment endpoints: [".concat(manualSegmentCollision.segmentStart.x.toFixed(3), ", ").concat(manualSegmentCollision.segmentStart.y.toFixed(3), ", ").concat(manualSegmentCollision.segmentStart.z.toFixed(3), "] to [").concat(manualSegmentCollision.segmentEnd.x.toFixed(3), ", ").concat(manualSegmentCollision.segmentEnd.y.toFixed(3), ", ").concat(manualSegmentCollision.segmentEnd.z.toFixed(3), "]"));
+        // Note: We do NOT return false - collision is allowed
+      } else {
+        console.log('✅ No collisions detected');
+      }
+
+      // Revert the temporary translation
+      component.position[axis] = originalPosition;
+      component.updateMatrix();
+      component.updateMatrixWorld(true);
+      return true; // Always allow translation
+    }
+
+    /**
+     * Validate collision checks for translateGateway operation
+     * @param {THREE.Object3D} gateway - The gateway to translate
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by
+     * @returns {boolean} True if no collisions detected, false if translation would cause collision
+     * @private
+     */
+  }, {
+    key: "validateTranslateGatewayCollisions",
+    value: function validateTranslateGatewayCollisions(gateway, axis, value) {
+      // Store original position for reverting
+      var originalPosition = gateway.position[axis];
+
+      // Temporarily apply the translation to check for collisions
+      gateway.position[axis] += value;
+      gateway.updateMatrix();
+      gateway.updateMatrixWorld(true);
+      console.log("\uD83D\uDD0D Checking collisions with translated gateway position: ".concat(axis, "=").concat(gateway.position[axis].toFixed(3)));
+
+      // Check for collision with components (this should block translation)
+      var componentCollision = this.checkGatewayComponentCollision(gateway);
+      if (componentCollision) {
+        // Revert the translation
+        gateway.position[axis] = originalPosition;
+        gateway.updateMatrix();
+        gateway.updateMatrixWorld(true);
+        console.warn("\u26A0\uFE0F translateGateway(): Translation canceled - gateway would collide with component");
+        console.warn("   Component ID: ".concat(componentCollision.componentId));
+        console.warn("   Component Name: ".concat(componentCollision.componentName));
+        return false;
+      }
+
+      // Check for collision with manual segments (this should also block translation)
+      var manualSegmentCollision = this.checkGatewayManualSegmentCollision(gateway);
+      if (manualSegmentCollision) {
+        // Revert the translation
+        gateway.position[axis] = originalPosition;
+        gateway.updateMatrix();
+        gateway.updateMatrixWorld(true);
+        console.warn("\u26A0\uFE0F translateGateway(): Translation canceled - gateway would collide with manual segment");
+        console.warn("   Segment ID: ".concat(manualSegmentCollision.segmentId));
+        console.warn("   Distance to segment: ".concat(manualSegmentCollision.distance.toFixed(3), " (threshold: 0.25)"));
+        console.warn("   Segment endpoints: [".concat(manualSegmentCollision.segmentStart.x.toFixed(3), ", ").concat(manualSegmentCollision.segmentStart.y.toFixed(3), ", ").concat(manualSegmentCollision.segmentStart.z.toFixed(3), "] to [").concat(manualSegmentCollision.segmentEnd.x.toFixed(3), ", ").concat(manualSegmentCollision.segmentEnd.y.toFixed(3), ", ").concat(manualSegmentCollision.segmentEnd.z.toFixed(3), "]"));
+        return false;
+      }
+      console.log('✅ No collisions detected');
+
+      // Revert the temporary translation
+      gateway.position[axis] = originalPosition;
+      gateway.updateMatrix();
+      gateway.updateMatrixWorld(true);
+      return true; // Allow translation only if no collisions
+    }
+
     /**
      * Translate a pipe segment by segmentId
      * @param {string} segmentId - The UUID of the pipe segment to translate
@@ -19277,12 +19462,10 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         console.warn("\u26A0\uFE0F translateSegment(): Translation canceled - segment would intersect with other segment(s)");
         return false;
       }
-      console.log('✅ No intersections detected, proceeding with translation');
+      console.log('✅ No intersections detected, translation pre-applied');
 
-      // Revert the temporary translation
-      segment.position[axis] = originalPosition;
-      segment.updateMatrix();
-      segment.updateMatrixWorld(true);
+      // Leave the translation applied - caller expects it to be ready
+      // This eliminates redundant matrix updates
       return true;
     }
   }, {
@@ -19298,16 +19481,14 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       var segment = validationResult.segment;
       console.log("\uD83D\uDD04 translateSegment(): Translating segment ".concat(segmentId, " on ").concat(axis, " axis by ").concat(value));
 
-      // Run collision validation checks
+      // Run collision validation checks (applies translation if successful)
       var collisionValidation = this.validateTranslateSegmentCollisions(segment, axis, value);
       if (!collisionValidation) {
         return false;
       }
 
-      // All validations passed - apply the translation
-      segment.position[axis] += value;
-      segment.updateMatrix();
-      segment.updateMatrixWorld(true);
+      // All validations passed - translation already applied by validateTranslateSegmentCollisions
+      // No need to redundantly update matrices again
 
       // Validate PathfindingManager and SceneOperationsManager availability
       var pathfindingManager = (_this$sceneViewer$man2 = this.sceneViewer.managers) === null || _this$sceneViewer$man2 === void 0 ? void 0 : _this$sceneViewer$man2.pathfindingManager;
@@ -19432,7 +19613,13 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       }
       console.log("\uD83D\uDD04 translateGateway(): Translating gateway ".concat(gatewayId, " on ").concat(axis, " axis by ").concat(value));
 
-      // Apply the translation to the Three.js object
+      // Run collision validation checks before applying the translation
+      var collisionValidation = this.validateTranslateGatewayCollisions(gateway, axis, value);
+      if (!collisionValidation) {
+        return false;
+      }
+
+      // All validations passed - apply the translation to the Three.js object
       gateway.position[axis] += value;
 
       // Update matrices
@@ -19842,7 +20029,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
      * Check if a segment intersects with any segments in the scene
      * For grid-based segments (0.5 grid), checks if segments cross or overlap
      * Uses only endpoint comparisons, no radius checks
-     * Allows T-junctions (endpoint touching line) if segments are connected (same pathFrom/pathTo)
+     * Allows T-junctions in two cases:
+     *   1. Segments are part of the same connection path (same pathFrom/pathTo)
+     *   2. One segment's endpoint touches another segment's line (not at endpoints)
      * @param {THREE.Object3D} segment - The segment to check for intersections
      * @returns {boolean} True if segment intersects with any segment
      * @private
@@ -19905,19 +20094,26 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
           // If exactly 1 endpoint is shared, check if they overlap along the same line
           if (sharedEndpointCount === 1) {
-            // Check if segments are collinear (on the same line)
-            var _distance = _this2.calculateSegmentToSegmentDistance(segmentEndpoints.start, segmentEndpoints.end, otherEndpoints.start, otherEndpoints.end);
-            if (_distance < endpointTolerance) {
-              // Segments are on the same line and share one endpoint
-              // This means they overlap along part of their length
-              console.log("\uD83D\uDD34 Overlapping collinear segments detected - share 1 endpoint and are on same line");
+            // Check if segments are collinear (on the same line) by comparing direction vectors
+            // Get direction vectors for both segments
+            var dir1 = new THREE__namespace.Vector3().subVectors(segmentEndpoints.end, segmentEndpoints.start).normalize();
+            var dir2 = new THREE__namespace.Vector3().subVectors(otherEndpoints.end, otherEndpoints.start).normalize();
+
+            // Calculate the absolute dot product (to handle opposite directions)
+            var dotProduct = Math.abs(dir1.dot(dir2));
+
+            // If dot product is close to 1.0, the segments are parallel/collinear
+            // Threshold of 0.9999 allows for ~0.8 degree deviation
+            var collinearThreshold = 0.9999;
+            if (dotProduct > collinearThreshold) {
+              // Segments are collinear and share one endpoint - they overlap
+              console.log("\uD83D\uDD34 Overlapping collinear segments detected - share 1 endpoint and are parallel (dot product: ".concat(dotProduct.toFixed(6), ")"));
               console.log("   Segment 1: [".concat(segmentEndpoints.start.x.toFixed(2), ", ").concat(segmentEndpoints.start.y.toFixed(2), ", ").concat(segmentEndpoints.start.z.toFixed(2), "] to [").concat(segmentEndpoints.end.x.toFixed(2), ", ").concat(segmentEndpoints.end.y.toFixed(2), ", ").concat(segmentEndpoints.end.z.toFixed(2), "]"));
               console.log("   Segment 2: [".concat(otherEndpoints.start.x.toFixed(2), ", ").concat(otherEndpoints.start.y.toFixed(2), ", ").concat(otherEndpoints.start.z.toFixed(2), "] to [").concat(otherEndpoints.end.x.toFixed(2), ", ").concat(otherEndpoints.end.y.toFixed(2), ", ").concat(otherEndpoints.end.z.toFixed(2), "]"));
-              console.log("   Distance: ".concat(_distance.toFixed(6)));
               hasIntersection = true;
             } else {
-              // Valid end-to-end connection at different angles
-              console.log("\u2705 Segments connected at one endpoint with different directions - valid connection");
+              // Valid end-to-end connection at different angles (L-junction, etc.)
+              console.log("\u2705 Segments connected at one endpoint with different directions - valid L-junction (dot product: ".concat(dotProduct.toFixed(6), ")"));
             }
             return;
           }
@@ -19928,12 +20124,23 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           // If distance is near zero, segments cross or overlap
           if (distance < endpointTolerance) {
             // Special case: T-junction (one segment's endpoint touches the other's line)
-            // This is allowed if the segments are part of the same connection path
+            // This is allowed if:
+            // 1. Segments are part of the same connection path, OR
+            // 2. The moving segment's endpoint touches the manual segment (T-junction)
             if (sameConnection) {
               var _segment$userData8, _segment$userData9;
               console.log("\u2705 T-junction detected but allowed - segments are part of the same connection (".concat((_segment$userData8 = segment.userData) === null || _segment$userData8 === void 0 ? void 0 : _segment$userData8.pathFrom, " \u2192 ").concat((_segment$userData9 = segment.userData) === null || _segment$userData9 === void 0 ? void 0 : _segment$userData9.pathTo, ")"));
               return;
             }
+
+            // Check if this is a valid T-junction (moving segment endpoint touching manual segment)
+            var isTJunction = _this2.isTJunction(segmentEndpoints.start, segmentEndpoints.end, otherEndpoints.start, otherEndpoints.end, endpointTolerance);
+            if (isTJunction) {
+              console.log("\u2705 T-junction detected but allowed - moving segment endpoint touches manual segment");
+              console.log("   Moving segment: [".concat(segmentEndpoints.start.x.toFixed(2), ", ").concat(segmentEndpoints.start.y.toFixed(2), ", ").concat(segmentEndpoints.start.z.toFixed(2), "] to [").concat(segmentEndpoints.end.x.toFixed(2), ", ").concat(segmentEndpoints.end.y.toFixed(2), ", ").concat(segmentEndpoints.end.z.toFixed(2), "]"));
+              console.log("   Manual segment: [".concat(otherEndpoints.start.x.toFixed(2), ", ").concat(otherEndpoints.start.y.toFixed(2), ", ").concat(otherEndpoints.start.z.toFixed(2), "] to [").concat(otherEndpoints.end.x.toFixed(2), ", ").concat(otherEndpoints.end.y.toFixed(2), ", ").concat(otherEndpoints.end.z.toFixed(2), "]"));
+              return;
+            }
             console.log("\uD83D\uDD34 Intersection detected - segments cross or overlap");
             console.log("   Segment 1: [".concat(segmentEndpoints.start.x.toFixed(2), ", ").concat(segmentEndpoints.start.y.toFixed(2), ", ").concat(segmentEndpoints.start.z.toFixed(2), "] to [").concat(segmentEndpoints.end.x.toFixed(2), ", ").concat(segmentEndpoints.end.y.toFixed(2), ", ").concat(segmentEndpoints.end.z.toFixed(2), "]"));
             console.log("   Segment 2: [".concat(otherEndpoints.start.x.toFixed(2), ", ").concat(otherEndpoints.start.y.toFixed(2), ", ").concat(otherEndpoints.start.z.toFixed(2), "] to [").concat(otherEndpoints.end.x.toFixed(2), ", ").concat(otherEndpoints.end.y.toFixed(2), ", ").concat(otherEndpoints.end.z.toFixed(2), "]"));
@@ -19971,6 +20178,71 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return this.calculateSegmentEndpoints(segment);
     }
 
+    /**
+     * Check if two segments form a valid T-junction
+     * A T-junction occurs when one segment's endpoint touches the other segment's line (not at an endpoint)
+     * @param {THREE.Vector3} seg1Start - Start point of segment 1
+     * @param {THREE.Vector3} seg1End - End point of segment 1
+     * @param {THREE.Vector3} seg2Start - Start point of segment 2
+     * @param {THREE.Vector3} seg2End - End point of segment 2
+     * @param {number} tolerance - Distance tolerance for "touching"
+     * @returns {boolean} True if segments form a T-junction
+     * @private
+     */
+  }, {
+    key: "isTJunction",
+    value: function isTJunction(seg1Start, seg1End, seg2Start, seg2End, tolerance) {
+      // Helper function to check if a point lies on a line segment (not at endpoints)
+      var isPointOnLineSegment = function isPointOnLineSegment(point, lineStart, lineEnd, tol) {
+        // Direction vector of the line
+        var lineDir = new THREE__namespace.Vector3().subVectors(lineEnd, lineStart);
+        var lineLength = lineDir.length();
+        if (lineLength < 1e-10) {
+          return false; // Degenerate line segment
+        }
+        lineDir.normalize();
+
+        // Vector from line start to point
+        var toPoint = new THREE__namespace.Vector3().subVectors(point, lineStart);
+
+        // Project point onto line to find closest point on line
+        var projectionLength = toPoint.dot(lineDir);
+
+        // Check if projection is within the line segment (not at endpoints)
+        if (projectionLength <= tol || projectionLength >= lineLength - tol) {
+          return false; // Point is at or near an endpoint, not a T-junction
+        }
+
+        // Calculate closest point on line
+        var closestPoint = new THREE__namespace.Vector3().copy(lineStart).add(lineDir.clone().multiplyScalar(projectionLength));
+
+        // Check if point is close enough to the line
+        var distance = point.distanceTo(closestPoint);
+        return distance < tol;
+      };
+
+      // Check if seg1's start point touches seg2's line (not at endpoints)
+      if (isPointOnLineSegment(seg1Start, seg2Start, seg2End, tolerance)) {
+        return true;
+      }
+
+      // Check if seg1's end point touches seg2's line (not at endpoints)
+      if (isPointOnLineSegment(seg1End, seg2Start, seg2End, tolerance)) {
+        return true;
+      }
+
+      // Check if seg2's start point touches seg1's line (not at endpoints)
+      if (isPointOnLineSegment(seg2Start, seg1Start, seg1End, tolerance)) {
+        return true;
+      }
+
+      // Check if seg2's end point touches seg1's line (not at endpoints)
+      if (isPointOnLineSegment(seg2End, seg1Start, seg1End, tolerance)) {
+        return true;
+      }
+      return false;
+    }
+
     /**
      * Check if any point along a segment's path would collide with component connector within 0.5 radius
      * @param {THREE.Object3D} segment - The segment to check
@@ -20020,8 +20292,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
           // Handle degenerate case (zero-length segment)
           if (segmentLengthSquared < 1e-10) {
-            var _distance2 = startPoint.distanceTo(connectorWorldPos);
-            if (_distance2 <= collisionRadius) {
+            var _distance = startPoint.distanceTo(connectorWorldPos);
+            if (_distance <= collisionRadius) {
               // Find the parent component
               var component = child.parent;
               while (component && !((_component$userData2 = component.userData) !== null && _component$userData2 !== void 0 && _component$userData2.libraryId)) {
@@ -20041,7 +20313,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
                   y: startPoint.y,
                   z: startPoint.z
                 },
-                distance: _distance2
+                distance: _distance
               };
             }
             return;
@@ -20185,6 +20457,210 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return collision;
     }
 
+    /**
+     * Check if a component would collide with any manual (declared) segment
+     * @param {THREE.Object3D} component - The component to check for collisions
+     * @returns {Object|null} Collision info {segmentId, distance, segmentStart, segmentEnd} if collision detected, null otherwise
+     * @private
+     */
+  }, {
+    key: "checkComponentManualSegmentCollision",
+    value: function checkComponentManualSegmentCollision(component) {
+      var _this$sceneViewer8,
+        _this3 = this;
+      if (!((_this$sceneViewer8 = this.sceneViewer) !== null && _this$sceneViewer8 !== void 0 && _this$sceneViewer8.scene) || !component) {
+        return null;
+      }
+
+      // Create a bounding box for the component
+      var componentBBox = new THREE__namespace.Box3().setFromObject(component);
+      var collision = null;
+
+      // Traverse scene to find all manual segments (isDeclared === true)
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData15, _child$userData16;
+        if (collision) return; // Stop if collision already found
+
+        // Only check manual segments (isDeclared === true)
+        if (((_child$userData15 = child.userData) === null || _child$userData15 === void 0 ? void 0 : _child$userData15.objectType) === 'segment' && ((_child$userData16 = child.userData) === null || _child$userData16 === void 0 ? void 0 : _child$userData16.isDeclared) === true) {
+          // Get segment endpoints
+          var segmentEndpoints = _this3.getSegmentEndpoints(child);
+
+          // Check if segment intersects with component's bounding box
+          // We'll use a line-box intersection test
+          var line = new THREE__namespace.Line3(segmentEndpoints.start, segmentEndpoints.end);
+          var closestPoint = new THREE__namespace.Vector3();
+          line.closestPointToPoint(componentBBox.getCenter(new THREE__namespace.Vector3()), true, closestPoint);
+
+          // Check if the closest point on the line is within the bounding box
+          if (componentBBox.containsPoint(closestPoint)) {
+            console.log('⚠️ TransformOperationsManager: Component bounding box collision with manual segment:', child.uuid);
+            collision = {
+              segmentId: child.uuid,
+              distance: 0,
+              // Inside the bounding box
+              segmentStart: segmentEndpoints.start.clone(),
+              segmentEnd: segmentEndpoints.end.clone()
+            };
+            return;
+          }
+
+          // Also check if either endpoint of the segment is inside the component bounding box
+          if (componentBBox.containsPoint(segmentEndpoints.start) || componentBBox.containsPoint(segmentEndpoints.end)) {
+            console.log('⚠️ TransformOperationsManager: Component bounding box contains manual segment endpoint:', child.uuid);
+            collision = {
+              segmentId: child.uuid,
+              distance: 0,
+              // Inside the bounding box
+              segmentStart: segmentEndpoints.start.clone(),
+              segmentEnd: segmentEndpoints.end.clone()
+            };
+            return;
+          }
+
+          // Additionally, check if the segment line intersects any of the bounding box faces
+          // This catches cases where the segment passes through the box without endpoints inside
+          var ray = new THREE__namespace.Ray(segmentEndpoints.start, new THREE__namespace.Vector3().subVectors(segmentEndpoints.end, segmentEndpoints.start).normalize());
+          var segmentLength = segmentEndpoints.start.distanceTo(segmentEndpoints.end);
+          var intersection = ray.intersectBox(componentBBox, new THREE__namespace.Vector3());
+          if (intersection) {
+            var distanceToIntersection = segmentEndpoints.start.distanceTo(intersection);
+            if (distanceToIntersection <= segmentLength) {
+              console.log('⚠️ TransformOperationsManager: Manual segment intersects component bounding box:', child.uuid);
+              collision = {
+                segmentId: child.uuid,
+                distance: 0,
+                // Intersects the bounding box
+                segmentStart: segmentEndpoints.start.clone(),
+                segmentEnd: segmentEndpoints.end.clone()
+              };
+            }
+          }
+        }
+      });
+      return collision;
+    }
+
+    /**
+     * Check if a gateway would collide with any manual (declared) segment
+     * Gateways are treated as point objects, so we check if the gateway point
+     * is too close to any manual segment line. Gateways ARE allowed to be at
+     * segment endpoints, but NOT along the segment between endpoints.
+     * @param {THREE.Object3D} gateway - The gateway to check for collisions
+     * @returns {Object|null} Collision info {segmentId, distance, segmentStart, segmentEnd} if collision detected, null otherwise
+     * @private
+     */
+  }, {
+    key: "checkGatewayManualSegmentCollision",
+    value: function checkGatewayManualSegmentCollision(gateway) {
+      var _this$sceneViewer9,
+        _this4 = this;
+      if (!((_this$sceneViewer9 = this.sceneViewer) !== null && _this$sceneViewer9 !== void 0 && _this$sceneViewer9.scene) || !gateway) {
+        return null;
+      }
+
+      // Get gateway world position
+      var gatewayPos = new THREE__namespace.Vector3();
+      gateway.getWorldPosition(gatewayPos);
+
+      // Define collision threshold - gateways are small point objects
+      var collisionThreshold = 0.25; // Gateway is too close to segment if within this distance
+      var endpointTolerance = 0.01; // Tolerance for considering gateway at an endpoint
+
+      var collision = null;
+
+      // Traverse scene to find all manual segments (isDeclared === true)
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData17, _child$userData18;
+        if (collision) return; // Stop if collision already found
+
+        // Only check manual segments (isDeclared === true)
+        if (((_child$userData17 = child.userData) === null || _child$userData17 === void 0 ? void 0 : _child$userData17.objectType) === 'segment' && ((_child$userData18 = child.userData) === null || _child$userData18 === void 0 ? void 0 : _child$userData18.isDeclared) === true) {
+          // Get segment endpoints
+          var segmentEndpoints = _this4.getSegmentEndpoints(child);
+
+          // Check if gateway is at either endpoint - this is ALLOWED
+          var distToStart = gatewayPos.distanceTo(segmentEndpoints.start);
+          var distToEnd = gatewayPos.distanceTo(segmentEndpoints.end);
+          if (distToStart < endpointTolerance || distToEnd < endpointTolerance) {
+            console.log('✅ TransformOperationsManager: Gateway at segment endpoint (allowed):', child.uuid);
+            return; // Skip collision check - this is allowed
+          }
+
+          // Calculate distance from gateway point to segment line
+          var line = new THREE__namespace.Line3(segmentEndpoints.start, segmentEndpoints.end);
+          var closestPoint = new THREE__namespace.Vector3();
+          line.closestPointToPoint(gatewayPos, true, closestPoint);
+          var distance = gatewayPos.distanceTo(closestPoint);
+
+          // Check if gateway is too close to the segment (but not at endpoints)
+          if (distance < collisionThreshold) {
+            console.log('⚠️ TransformOperationsManager: Gateway too close to manual segment:', child.uuid);
+            console.log("   Distance: ".concat(distance.toFixed(3), " (threshold: ").concat(collisionThreshold, ")"));
+            collision = {
+              segmentId: child.uuid,
+              distance: distance,
+              segmentStart: segmentEndpoints.start.clone(),
+              segmentEnd: segmentEndpoints.end.clone()
+            };
+            return;
+          }
+        }
+      });
+      return collision;
+    }
+
+    /**
+     * Check if a gateway would collide with any component's bounding box
+     * Uses worldBoundingBox from currentSceneData for optimal performance
+     * @param {THREE.Object3D} gateway - The gateway to check for collisions
+     * @returns {Object|null} Collision info {componentId, componentName} if collision detected, null otherwise
+     * @private
+     */
+  }, {
+    key: "checkGatewayComponentCollision",
+    value: function checkGatewayComponentCollision(gateway) {
+      var _this$sceneViewer0;
+      if (!((_this$sceneViewer0 = this.sceneViewer) !== null && _this$sceneViewer0 !== void 0 && _this$sceneViewer0.scene) || !gateway) {
+        return null;
+      }
+
+      // Get gateway world position
+      var gatewayPos = new THREE__namespace.Vector3();
+      gateway.getWorldPosition(gatewayPos);
+      var collision = null;
+
+      // Traverse scene to find all components
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData19, _child$userData20;
+        if (collision) return; // Stop if collision already found
+
+        // Check if this is a component (equipment)
+        if (((_child$userData19 = child.userData) === null || _child$userData19 === void 0 ? void 0 : _child$userData19.objectType) === 'component' && (_child$userData20 = child.userData) !== null && _child$userData20 !== void 0 && _child$userData20.libraryId) {
+          // Try to get worldBoundingBox from userData first (most up-to-date)
+          var bbox = null;
+          if (child.userData.worldBoundingBox) {
+            // Use stored worldBoundingBox (array format: {min: [x,y,z], max: [x,y,z]})
+            bbox = new THREE__namespace.Box3(_construct(THREE__namespace.Vector3, _toConsumableArray(child.userData.worldBoundingBox.min)), _construct(THREE__namespace.Vector3, _toConsumableArray(child.userData.worldBoundingBox.max)));
+          } else {
+            // Fallback: compute from object
+            bbox = new THREE__namespace.Box3().setFromObject(child);
+          }
+
+          // Check if gateway position is inside the component's bounding box
+          if (bbox.containsPoint(gatewayPos)) {
+            console.log('⚠️ TransformOperationsManager: Gateway position inside component bounding box:', child.userData.libraryId || child.name || child.uuid);
+            collision = {
+              componentId: child.uuid,
+              componentName: child.name || child.userData.libraryId || 'Unknown'
+            };
+            return;
+          }
+        }
+      });
+      return collision;
+    }
+
     /**
      * Calculate the minimum distance between two line segments in 3D space
      * @param {THREE.Vector3} p1 - Start point of first segment
@@ -20294,10 +20770,10 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "snapSegmentConnectorsToNearbyEndpoints",
     value: function snapSegmentConnectorsToNearbyEndpoints(movedSegment) {
-      var _this$sceneViewer8,
-        _this$sceneViewer9,
-        _this3 = this;
-      if (!movedSegment || !((_this$sceneViewer8 = this.sceneViewer) !== null && _this$sceneViewer8 !== void 0 && _this$sceneViewer8.scene)) {
+      var _this$sceneViewer1,
+        _this$sceneViewer10,
+        _this5 = this;
+      if (!movedSegment || !((_this$sceneViewer1 = this.sceneViewer) !== null && _this$sceneViewer1 !== void 0 && _this$sceneViewer1.scene)) {
         return [];
       }
       console.log('🔗 Finding adjacent segments connected to moved segment...');
@@ -20305,8 +20781,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Get the moved segment's connectors
       var movedConnectors = [];
       movedSegment.traverse(function (child) {
-        var _child$userData15;
-        if (((_child$userData15 = child.userData) === null || _child$userData15 === void 0 ? void 0 : _child$userData15.objectType) === 'segment-connector') {
+        var _child$userData21;
+        if (((_child$userData21 = child.userData) === null || _child$userData21 === void 0 ? void 0 : _child$userData21.objectType) === 'segment-connector') {
           movedConnectors.push(child);
         }
       });
@@ -20319,7 +20795,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       var newEndpoints = this.calculateSegmentEndpoints(movedSegment);
 
       // Check scene data for connections involving the moved segment's connectors
-      var connections = ((_this$sceneViewer9 = this.sceneViewer) === null || _this$sceneViewer9 === void 0 || (_this$sceneViewer9 = _this$sceneViewer9.currentSceneData) === null || _this$sceneViewer9 === void 0 ? void 0 : _this$sceneViewer9.connections) || [];
+      var connections = ((_this$sceneViewer10 = this.sceneViewer) === null || _this$sceneViewer10 === void 0 || (_this$sceneViewer10 = _this$sceneViewer10.currentSceneData) === null || _this$sceneViewer10 === void 0 ? void 0 : _this$sceneViewer10.connections) || [];
       var movedConnectorIds = movedConnectors.map(function (c) {
         return c.uuid;
       });
@@ -20354,7 +20830,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Find the adjacent connector in the scene
         var adjacentConnector = null;
         var adjacentSegment = null;
-        _this3.sceneViewer.scene.traverse(function (object) {
+        _this5.sceneViewer.scene.traverse(function (object) {
           var _object$userData;
           if (object.uuid === pair.adjacentConnectorId && ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.objectType) === 'segment-connector') {
             adjacentConnector = object;
@@ -20376,8 +20852,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Get all connectors of the adjacent segment
         var adjacentConnectors = [];
         adjacentSegment.traverse(function (child) {
-          var _child$userData16;
-          if (((_child$userData16 = child.userData) === null || _child$userData16 === void 0 ? void 0 : _child$userData16.objectType) === 'segment-connector') {
+          var _child$userData22;
+          if (((_child$userData22 = child.userData) === null || _child$userData22 === void 0 ? void 0 : _child$userData22.objectType) === 'segment-connector') {
             adjacentConnectors.push(child);
           }
         });
@@ -20403,12 +20879,12 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // 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 = _this3.constrainPositionToOrthogonal(pair.newPosition, stationaryWorldPos, adjacentSegment);
+        var constrainedPosition = _this5.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)
         // Pass movedSegment as activeSegment context so zero-length removal knows which segment to extend
-        _this3.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, constrainedPosition, stationaryWorldPos, movedSegment);
+        _this5.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, constrainedPosition, stationaryWorldPos, movedSegment);
 
         // CRITICAL: After recreating the mesh, BOTH connectors need to be repositioned
         // because the segment's center and rotation have changed
@@ -20417,13 +20893,13 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         var movingLocalPos = adjacentSegment.worldToLocal(constrainedPosition.clone());
         movingConnector.position.copy(movingLocalPos);
         movingConnector.updateMatrixWorld(true);
-        _this3.updateConnectorPositionInSceneData(movingConnector, constrainedPosition, adjacentSegment);
+        _this5.updateConnectorPositionInSceneData(movingConnector, constrainedPosition, adjacentSegment);
 
         // Position stationary connector at its original world position
         var stationaryLocalPos = adjacentSegment.worldToLocal(stationaryWorldPos.clone());
         stationaryConnector.position.copy(stationaryLocalPos);
         stationaryConnector.updateMatrixWorld(true);
-        _this3.updateConnectorPositionInSceneData(stationaryConnector, stationaryWorldPos, adjacentSegment);
+        _this5.updateConnectorPositionInSceneData(stationaryConnector, stationaryWorldPos, adjacentSegment);
 
         // Record this connection as satisfied
         satisfiedConnections.push({
@@ -20473,8 +20949,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "updateComponentPositionInSceneData",
     value: function updateComponentPositionInSceneData(component) {
-      var _this$sceneViewer0;
-      if (!((_this$sceneViewer0 = this.sceneViewer) !== null && _this$sceneViewer0 !== void 0 && (_this$sceneViewer0 = _this$sceneViewer0.currentSceneData) !== null && _this$sceneViewer0 !== void 0 && _this$sceneViewer0.scene)) {
+      var _this$sceneViewer11;
+      if (!((_this$sceneViewer11 = this.sceneViewer) !== null && _this$sceneViewer11 !== void 0 && (_this$sceneViewer11 = _this$sceneViewer11.currentSceneData) !== null && _this$sceneViewer11 !== void 0 && _this$sceneViewer11.scene)) {
         console.warn('⚠️ Cannot update component position: currentSceneData not available');
         return;
       }
@@ -20500,8 +20976,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Also update child connectors' positions if they exist
         if (sceneDataComponent.children) {
           sceneDataComponent.children.forEach(function (child) {
-            var _child$userData17;
-            if (((_child$userData17 = child.userData) === null || _child$userData17 === void 0 ? void 0 : _child$userData17.objectType) === 'connector') {
+            var _child$userData23;
+            if (((_child$userData23 = child.userData) === null || _child$userData23 === void 0 ? void 0 : _child$userData23.objectType) === 'connector') {
               // Find the actual connector object in the scene
               var connectorObj = component.children.find(function (c) {
                 var _c$userData;
@@ -20537,9 +21013,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "updateConnectorPositionInSceneData",
     value: function updateConnectorPositionInSceneData(connector, worldPosition, parentSegment) {
-      var _this$sceneViewer1;
+      var _this$sceneViewer12;
       // Update scene data if available
-      if (!((_this$sceneViewer1 = this.sceneViewer) !== null && _this$sceneViewer1 !== void 0 && (_this$sceneViewer1 = _this$sceneViewer1.currentSceneData) !== null && _this$sceneViewer1 !== void 0 && _this$sceneViewer1.scene)) {
+      if (!((_this$sceneViewer12 = this.sceneViewer) !== null && _this$sceneViewer12 !== void 0 && (_this$sceneViewer12 = _this$sceneViewer12.currentSceneData) !== null && _this$sceneViewer12 !== void 0 && _this$sceneViewer12.scene)) {
         return;
       }
       var cleanPosition = function cleanPosition(value) {
@@ -20830,8 +21306,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Check if either external connector belongs to the active segment
         var activeSegmentConnectors = [];
         activeSegment.traverse(function (child) {
-          var _child$userData18;
-          if (((_child$userData18 = child.userData) === null || _child$userData18 === void 0 ? void 0 : _child$userData18.objectType) === 'segment-connector') {
+          var _child$userData24;
+          if (((_child$userData24 = child.userData) === null || _child$userData24 === void 0 ? void 0 : _child$userData24.objectType) === 'segment-connector') {
             activeSegmentConnectors.push(child.uuid);
           }
         });
@@ -20879,8 +21355,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
               // Get all connectors of the active segment
               var activeConnectors = [];
               activeSegment.traverse(function (child) {
-                var _child$userData19;
-                if (((_child$userData19 = child.userData) === null || _child$userData19 === void 0 ? void 0 : _child$userData19.objectType) === 'segment-connector') {
+                var _child$userData25;
+                if (((_child$userData25 = child.userData) === null || _child$userData25 === void 0 ? void 0 : _child$userData25.objectType) === 'segment-connector') {
                   activeConnectors.push(child);
                 }
               });
@@ -25104,7 +25580,7 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             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
+            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, cylinder // Pass the segment so elbow can be added as a child
             );
           }
         }
@@ -25119,11 +25595,11 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
      * @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
+     * @param {THREE.Object3D} segment - The parent segment to add the elbow to as a child
      */
   }, {
     key: "createAndAddElbowIfNeeded",
-    value: function createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, scene) {
+    value: function createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, segment) {
       // Only check if there are at least 2 more points ahead
       if (j >= pathPoints.length - 2) {
         return;
@@ -25138,11 +25614,12 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
       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);
+
+      // Create simple sphere elbow (efficient geometry)
+      var sphereRadius = 0.1;
+      var sphereSegments = 16;
+      var sphereGeometry = new THREE__namespace.SphereGeometry(sphereRadius, sphereSegments, sphereSegments);
+      var elbow = new THREE__namespace.Mesh(sphereGeometry, pipeMaterial);
       elbow.castShadow = true;
       elbow.receiveShadow = true;
 
@@ -25172,72 +25649,32 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
           }
         }
       };
-      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;
-      }
-    }
+      // Calculate elbow position in segment's local space
+      // The elbow is at the end point of the segment (pathPoints[j + 1])
+      // We need to convert this world position to segment's local space
 
-    /**
-     * 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();
+      // Get the elbow position in world space
+      var elbowWorldPos = pathPoints[j + 1].clone();
 
-      // 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;
+      // Convert world position to segment's local space
+      // First, get the segment's world position
+      var segmentWorldPos = segment.position.clone();
 
-      // Calculate the offset distance from the joint point
-      var offset = curveRadius;
+      // Calculate the offset from segment center to elbow in world space
+      var localOffset = elbowWorldPos.clone().sub(segmentWorldPos);
 
-      // 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));
+      // Convert the offset to segment's local coordinate system
+      // We need to apply the inverse of the segment's rotation
+      var inverseQuaternion = segment.quaternion.clone().invert();
+      localOffset.applyQuaternion(inverseQuaternion);
 
-      // 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();
+      // Set elbow position in local space
+      elbow.position.copy(localOffset);
 
-      // Create a quadratic bezier curve (simpler than cubic for 90° bends)
-      var curve = new THREE__namespace.QuadraticBezierCurve3(curveStart, controlPoint, curveEnd);
-      return curve;
+      // Add elbow as a child of the segment
+      segment.add(elbow);
+      console.log("\u2705 Elbow sphere added as child of segment at local position (".concat(localOffset.x.toFixed(2), ", ").concat(localOffset.y.toFixed(2), ", ").concat(localOffset.z.toFixed(2), ")"));
     }
 
     /**
@@ -26405,7 +26842,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     // ============================================================================
 
     /**
-     * Enrich sceneData with worldBoundingBox for segments
+     * Enrich sceneData with worldBoundingBox for segments and components
      * Connectors remain with just position information
      * @param {Object} sceneData - Original scene data
      * @returns {Object} Enriched scene data (shallow copy with modifications)
@@ -26422,9 +26859,9 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
         return enriched;
       }
 
-      // Process children to add worldBoundingBox to segments
+      // Process children to add worldBoundingBox to segments and components
       enriched.children = sceneData.children.map(function (child) {
-        // Only enrich segments (check if objectType is 'segment' in userData)
+        // Enrich segments (check if objectType is 'segment' in userData)
         if (child.userData && child.userData.objectType === 'segment') {
           // Find the actual segment object in the scene
           var segmentObject = _this3.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
@@ -26447,7 +26884,31 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           }
         }
 
-        // For non-segments (including connectors), return as-is
+        // Enrich components (check if objectType is 'component' in userData)
+        if (child.userData && child.userData.objectType === 'component') {
+          // Find the actual component object in the scene
+          var componentObject = _this3.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
+          if (componentObject) {
+            // Compute world bounding box
+            var _worldBBox = new THREE__namespace.Box3().setFromObject(componentObject);
+            console.log("\uD83D\uDD04 Updated worldBoundingBox for component ".concat(child.uuid, ": min=[").concat(_worldBBox.min.x.toFixed(2), ", ").concat(_worldBBox.min.y.toFixed(2), ", ").concat(_worldBBox.min.z.toFixed(2), "], max=[").concat(_worldBBox.max.x.toFixed(2), ", ").concat(_worldBBox.max.y.toFixed(2), ", ").concat(_worldBBox.max.z.toFixed(2), "]"));
+
+            // Return enriched component data with worldBoundingBox in userData
+            // Note: pathfinder expects arrays [x, y, z] format for min/max
+            return _objectSpread2(_objectSpread2({}, child), {}, {
+              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+                worldBoundingBox: {
+                  min: [_worldBBox.min.x, _worldBBox.min.y, _worldBBox.min.z],
+                  max: [_worldBBox.max.x, _worldBBox.max.y, _worldBBox.max.z]
+                }
+              })
+            });
+          } else {
+            console.warn("\u26A0\uFE0F Could not find component object in scene: ".concat(child.uuid));
+          }
+        }
+
+        // For non-segments and non-components (including connectors), return as-is
         return child;
       });
       return enriched;
@@ -33427,7 +33888,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.55
+   * @version 0.1.60
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.