@2112-lab/central-plant 0.1.54 → 0.1.55

package/dist/bundle/index.js

@@ -19070,6 +19070,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       component.updateMatrix();
       component.updateMatrixWorld(true);
 
+      // Update component position in currentSceneData
+      this.updateComponentPositionInSceneData(component);
+
       // Check if component is underground and fix if needed (based on settings)
       var checkUnderground = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.settingsManager) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.getSetting('scene', 'checkUnderground');
       if (checkUnderground) {
@@ -19214,7 +19217,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "validateTranslateSegmentCollisions",
     value: function validateTranslateSegmentCollisions(segment, axis, value) {
-      var _this$sceneViewer2;
+      var _segment$userData4, _segment$userData5;
       // Store original position for reverting
       var originalPosition = segment.position[axis];
 
@@ -19223,6 +19226,14 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       segment.updateMatrix();
       segment.updateMatrixWorld(true);
 
+      // IMPORTANT: Update stored endpoints if they exist, since position changed
+      // This ensures checkSegmentIntersection uses the correct translated endpoints
+      if ((_segment$userData4 = segment.userData) !== null && _segment$userData4 !== void 0 && (_segment$userData4 = _segment$userData4.endpoints) !== null && _segment$userData4 !== void 0 && _segment$userData4.startOffset && (_segment$userData5 = segment.userData) !== null && _segment$userData5 !== void 0 && (_segment$userData5 = _segment$userData5.endpoints) !== null && _segment$userData5 !== void 0 && _segment$userData5.endOffset) {
+        // Endpoints are stored as offsets from center, so they don't need updating
+        // The getSegmentEndpoints method will automatically use the new position
+        console.log("\uD83D\uDD0D Checking collisions with translated position: ".concat(axis, "=").concat(segment.position[axis].toFixed(3)));
+      }
+
       // Check for collision with component connectors along the segment's path
       var connectorCollision = this.checkSegmentPathConnectorCollision(segment);
       if (connectorCollision) {
@@ -19252,26 +19263,21 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         return false;
       }
 
-      // Check if translationalOverrideForAutomaticSegments is enabled
-      var translationalOverride = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.managers) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.settingsManager) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.getSetting('scene', 'translationalOverrideForAutomaticSegments');
-
-      // If override is disabled (false), check for intersections with computed segments
-      if (translationalOverride === false) {
-        console.log('🔍 Checking for intersections with computed segments (translationalOverrideForAutomaticSegments is disabled)');
+      // ALWAYS check for segment-to-segment intersections
+      console.log('🔍 Checking for intersections with other segments...');
 
-        // Check if the translated segment intersects with any computed segments
-        var hasIntersection = this.checkSegmentIntersection(segment);
-        console.log("\uD83D\uDD04 translateSegment() hasIntersection:", hasIntersection);
-        if (hasIntersection) {
-          // Revert the translation
-          segment.position[axis] = originalPosition;
-          segment.updateMatrix();
-          segment.updateMatrixWorld(true);
-          console.warn("\u26A0\uFE0F translateSegment(): Translation canceled - segment would intersect with computed segment(s)");
-          return false;
-        }
-        console.log('✅ No intersections detected, proceeding with translation');
+      // Check if the translated segment intersects with any other segments
+      var hasIntersection = this.checkSegmentIntersection(segment);
+      console.log("\uD83D\uDD04 translateSegment() hasIntersection:", hasIntersection);
+      if (hasIntersection) {
+        // Revert the translation
+        segment.position[axis] = originalPosition;
+        segment.updateMatrix();
+        segment.updateMatrixWorld(true);
+        console.warn("\u26A0\uFE0F translateSegment(): Translation canceled - segment would intersect with other segment(s)");
+        return false;
       }
+      console.log('✅ No intersections detected, proceeding with translation');
 
       // Revert the temporary translation
       segment.position[axis] = originalPosition;
@@ -19733,9 +19739,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "findConnectorsAtPositions",
     value: function findConnectorsAtPositions(positions) {
-      var _this$sceneViewer3;
+      var _this$sceneViewer2;
       var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.15;
-      if (!((_this$sceneViewer3 = this.sceneViewer) !== null && _this$sceneViewer3 !== void 0 && _this$sceneViewer3.scene)) {
+      if (!((_this$sceneViewer2 = this.sceneViewer) !== null && _this$sceneViewer2 !== void 0 && _this$sceneViewer2.scene)) {
         return [];
       }
       var foundConnectors = [];
@@ -19779,10 +19785,10 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "updateSegmentConnectorPositions",
     value: function updateSegmentConnectorPositions(segment) {
-      var _this$sceneViewer4,
+      var _this$sceneViewer3,
         _this = this;
       console.log("updateSegmentConnectorPositions started:", segment);
-      if (!segment || !((_this$sceneViewer4 = this.sceneViewer) !== null && _this$sceneViewer4 !== void 0 && (_this$sceneViewer4 = _this$sceneViewer4.currentSceneData) !== null && _this$sceneViewer4 !== void 0 && _this$sceneViewer4.scene)) {
+      if (!segment || !((_this$sceneViewer3 = this.sceneViewer) !== null && _this$sceneViewer3 !== void 0 && (_this$sceneViewer3 = _this$sceneViewer3.currentSceneData) !== null && _this$sceneViewer3 !== void 0 && _this$sceneViewer3.scene)) {
         console.warn('⚠️ updateSegmentConnectorPositions(): Missing segment or scene data');
         return;
       }
@@ -19833,24 +19839,25 @@ var TransformOperationsManager = /*#__PURE__*/function () {
     }
 
     /**
-     * Check if a segment intersects with any computed segments in the scene
-     * Uses segment-to-segment distance calculation, excluding endpoint connections
+     * 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)
      * @param {THREE.Object3D} segment - The segment to check for intersections
-     * @returns {boolean} True if segment intersects with any computed segment (not just touching at ends)
+     * @returns {boolean} True if segment intersects with any segment
      * @private
      */
   }, {
     key: "checkSegmentIntersection",
     value: function checkSegmentIntersection(segment) {
-      var _this$sceneViewer5,
+      var _this$sceneViewer4,
         _this2 = this;
-      if (!((_this$sceneViewer5 = this.sceneViewer) !== null && _this$sceneViewer5 !== void 0 && _this$sceneViewer5.scene)) {
+      if (!((_this$sceneViewer4 = this.sceneViewer) !== null && _this$sceneViewer4 !== void 0 && _this$sceneViewer4.scene)) {
         return false;
       }
 
-      // Get endpoints of the segment being checked
-      var segmentEndpoints = this.calculateSegmentEndpoints(segment);
-      var segmentRadius = segment.geometry.parameters.radiusTop || 0.05;
+      // Get endpoints of the segment being checked (use stored endpoints if available)
+      var segmentEndpoints = this.getSegmentEndpoints(segment);
 
       // Track if any intersection was found
       var hasIntersection = false;
@@ -19863,41 +19870,74 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           return;
         }
 
-        // Only check computed segments (isDeclared === false or undefined)
-        if (((_child$userData9 = child.userData) === null || _child$userData9 === void 0 ? void 0 : _child$userData9.objectType) === 'segment' && ((_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.isDeclared) !== true) {
-          // Get endpoints of the computed segment
-          var computedEndpoints = _this2.calculateSegmentEndpoints(child);
-          var computedRadius = child.geometry.parameters.radiusTop || 0.05;
+        // Only check computed segments in the scene
+        if (((_child$userData9 = child.userData) === null || _child$userData9 === void 0 ? void 0 : _child$userData9.objectType) === 'segment' && (_child$userData0 = child.userData) !== null && _child$userData0 !== void 0 && _child$userData0.isDeclared) {
+          var _segment$userData6, _child$userData1, _segment$userData7, _child$userData10;
+          // Check if segments are part of the same connection path
+          var sameConnection = ((_segment$userData6 = segment.userData) === null || _segment$userData6 === void 0 ? void 0 : _segment$userData6.pathFrom) === ((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.pathFrom) && ((_segment$userData7 = segment.userData) === null || _segment$userData7 === void 0 ? void 0 : _segment$userData7.pathTo) === ((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.pathTo);
 
-          // Combined radius threshold - segments intersect if closer than this
-          var combinedRadius = segmentRadius + computedRadius;
+          // Get endpoints of the other segment (use stored endpoints if available)
+          var otherEndpoints = _this2.getSegmentEndpoints(child);
 
-          // First, check if segments are connected at endpoints
-          // This is a cheaper check than full segment-to-segment distance
-          var endpointTolerance = 0.55; // Generous tolerance for endpoint connections
+          // Grid tolerance for endpoint comparisons (0.5 grid system)
+          var endpointTolerance = 0.01; // Very tight tolerance for grid-aligned segments
 
-          var d1 = segmentEndpoints.start.distanceTo(computedEndpoints.start);
-          var d2 = segmentEndpoints.start.distanceTo(computedEndpoints.end);
-          var d3 = segmentEndpoints.end.distanceTo(computedEndpoints.start);
-          var d4 = segmentEndpoints.end.distanceTo(computedEndpoints.end);
+          var d1 = segmentEndpoints.start.distanceTo(otherEndpoints.start);
+          var d2 = segmentEndpoints.start.distanceTo(otherEndpoints.end);
+          var d3 = segmentEndpoints.end.distanceTo(otherEndpoints.start);
+          var d4 = segmentEndpoints.end.distanceTo(otherEndpoints.end);
 
-          // Check if any endpoint of segment A is near any endpoint of segment B (they're connected)
-          var isConnectedAtEnds = d1 < endpointTolerance || d2 < endpointTolerance || d3 < endpointTolerance || d4 < endpointTolerance;
+          // Count how many endpoints are shared/touching
+          var sharedEndpointCount = 0;
+          if (d1 < endpointTolerance) sharedEndpointCount++;
+          if (d2 < endpointTolerance) sharedEndpointCount++;
+          if (d3 < endpointTolerance) sharedEndpointCount++;
+          if (d4 < endpointTolerance) sharedEndpointCount++;
 
-          // If connected at ends, skip this segment (no collision)
-          if (isConnectedAtEnds) {
-            console.log("\u2705 Segments connected at endpoints - skipping intersection check (min endpoint distance: ".concat(Math.min(d1, d2, d3, d4).toFixed(3), ")"));
+          // If segments share 2 or more endpoints, they're overlapping on the same line
+          if (sharedEndpointCount >= 2) {
+            console.log("\uD83D\uDD34 Overlapping segments detected - segments share ".concat(sharedEndpointCount, " endpoints"));
+            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), "]"));
+            hasIntersection = true;
             return;
           }
 
-          // Calculate the minimum distance between the two line segments
-          var distance = _this2.calculateSegmentToSegmentDistance(segmentEndpoints.start, segmentEndpoints.end, computedEndpoints.start, computedEndpoints.end);
+          // 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");
+              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");
+            }
+            return;
+          }
+
+          // No shared endpoints - check if segments cross or overlap
+          var distance = _this2.calculateSegmentToSegmentDistance(segmentEndpoints.start, segmentEndpoints.end, otherEndpoints.start, otherEndpoints.end);
 
-          // Only flag as intersection if segments are closer than combined radius
-          if (distance < combinedRadius) {
-            console.log("\uD83D\uDD34 Intersection detected with computed segment: ".concat(child.uuid || child.name));
-            console.log("   Distance: ".concat(distance.toFixed(3), ", Combined radius: ").concat(combinedRadius.toFixed(3)));
-            console.log("   Endpoint distances: [".concat(d1.toFixed(3), ", ").concat(d2.toFixed(3), ", ").concat(d3.toFixed(3), ", ").concat(d4.toFixed(3), "]"));
+          // 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
+            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;
+            }
+            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), "]"));
+            console.log("   Distance: ".concat(distance.toFixed(6)));
             hasIntersection = true;
           }
         }
@@ -19905,6 +19945,32 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return hasIntersection;
     }
 
+    /**
+     * Get segment endpoints, using stored userData.endpoints if available, otherwise calculate
+     * @param {THREE.Object3D} segment - The segment object
+     * @returns {Object} Object with start and end Vector3 points
+     * @private
+     */
+  }, {
+    key: "getSegmentEndpoints",
+    value: function getSegmentEndpoints(segment) {
+      var _segment$userData0, _segment$userData1;
+      // Check if segment has stored endpoints in userData
+      if ((_segment$userData0 = segment.userData) !== null && _segment$userData0 !== void 0 && (_segment$userData0 = _segment$userData0.endpoints) !== null && _segment$userData0 !== void 0 && _segment$userData0.startOffset && (_segment$userData1 = segment.userData) !== null && _segment$userData1 !== void 0 && (_segment$userData1 = _segment$userData1.endpoints) !== null && _segment$userData1 !== void 0 && _segment$userData1.endOffset) {
+        // Reconstruct world positions from stored offsets
+        var centerPoint = segment.position;
+        var startOffset = segment.userData.endpoints.startOffset;
+        var endOffset = segment.userData.endpoints.endOffset;
+        return {
+          start: new THREE__namespace.Vector3(centerPoint.x + startOffset.x, centerPoint.y + startOffset.y, centerPoint.z + startOffset.z),
+          end: new THREE__namespace.Vector3(centerPoint.x + endOffset.x, centerPoint.y + endOffset.y, centerPoint.z + endOffset.z)
+        };
+      }
+
+      // Fallback to calculating endpoints from geometry
+      return this.calculateSegmentEndpoints(segment);
+    }
+
     /**
      * 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
@@ -19914,8 +19980,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "checkSegmentPathConnectorCollision",
     value: function checkSegmentPathConnectorCollision(segment) {
-      var _this$sceneViewer6;
-      if (!((_this$sceneViewer6 = this.sceneViewer) !== null && _this$sceneViewer6 !== void 0 && _this$sceneViewer6.scene) || !segment) {
+      var _this$sceneViewer5;
+      if (!((_this$sceneViewer5 = this.sceneViewer) !== null && _this$sceneViewer5 !== void 0 && _this$sceneViewer5.scene) || !segment) {
         return null;
       }
       var collisionRadius = 0.5; // Radius around connector that triggers collision
@@ -19929,11 +19995,11 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all component connectors
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData1;
+        var _child$userData11;
         if (collision) return; // Stop if collision already found
 
         // Check if this is a component connector (not a segment-connector)
-        if (((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.objectType) === 'connector') {
+        if (((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType) === 'connector') {
           // Get world position of connector
           var connectorWorldPos = new THREE__namespace.Vector3();
           child.getWorldPosition(connectorWorldPos);
@@ -19954,8 +20020,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
           // Handle degenerate case (zero-length segment)
           if (segmentLengthSquared < 1e-10) {
-            var _distance = startPoint.distanceTo(connectorWorldPos);
-            if (_distance <= collisionRadius) {
+            var _distance2 = startPoint.distanceTo(connectorWorldPos);
+            if (_distance2 <= collisionRadius) {
               // Find the parent component
               var component = child.parent;
               while (component && !((_component$userData2 = component.userData) !== null && _component$userData2 !== void 0 && _component$userData2.libraryId)) {
@@ -19975,7 +20041,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
                   y: startPoint.y,
                   z: startPoint.z
                 },
-                distance: _distance
+                distance: _distance2
               };
             }
             return;
@@ -20029,8 +20095,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "checkComponentConnectorCollision",
     value: function checkComponentConnectorCollision(newPosition) {
-      var _this$sceneViewer7;
-      if (!((_this$sceneViewer7 = this.sceneViewer) !== null && _this$sceneViewer7 !== void 0 && _this$sceneViewer7.scene)) {
+      var _this$sceneViewer6;
+      if (!((_this$sceneViewer6 = this.sceneViewer) !== null && _this$sceneViewer6 !== void 0 && _this$sceneViewer6.scene)) {
         return null;
       }
       var tolerance = 0.01; // Small tolerance for floating-point comparison
@@ -20038,9 +20104,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all component connectors
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData10;
+        var _child$userData12;
         // Check if this is a component connector (not a segment-connector)
-        if (((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.objectType) === 'connector') {
+        if (((_child$userData12 = child.userData) === null || _child$userData12 === void 0 ? void 0 : _child$userData12.objectType) === 'connector') {
           // Get world position of connector
           var connectorWorldPos = new THREE__namespace.Vector3();
           child.getWorldPosition(connectorWorldPos);
@@ -20086,8 +20152,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "checkSegmentComponentBoundingBoxCollision",
     value: function checkSegmentComponentBoundingBoxCollision(segment) {
-      var _this$sceneViewer8;
-      if (!((_this$sceneViewer8 = this.sceneViewer) !== null && _this$sceneViewer8 !== void 0 && _this$sceneViewer8.scene) || !segment) {
+      var _this$sceneViewer7;
+      if (!((_this$sceneViewer7 = this.sceneViewer) !== null && _this$sceneViewer7 !== void 0 && _this$sceneViewer7.scene) || !segment) {
         return null;
       }
 
@@ -20097,11 +20163,11 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all components
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData11, _child$userData12;
+        var _child$userData13, _child$userData14;
         if (collision) return; // Stop if collision already found
 
         // Check if this is a component (equipment)
-        if (((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType) === 'component' && (_child$userData12 = child.userData) !== null && _child$userData12 !== void 0 && _child$userData12.libraryId) {
+        if (((_child$userData13 = child.userData) === null || _child$userData13 === void 0 ? void 0 : _child$userData13.objectType) === 'component' && (_child$userData14 = child.userData) !== null && _child$userData14 !== void 0 && _child$userData14.libraryId) {
           // Create bounding box for the component
           var componentBBox = new THREE__namespace.Box3().setFromObject(child);
 
@@ -20228,10 +20294,10 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "snapSegmentConnectorsToNearbyEndpoints",
     value: function snapSegmentConnectorsToNearbyEndpoints(movedSegment) {
-      var _this$sceneViewer9,
-        _this$sceneViewer0,
+      var _this$sceneViewer8,
+        _this$sceneViewer9,
         _this3 = this;
-      if (!movedSegment || !((_this$sceneViewer9 = this.sceneViewer) !== null && _this$sceneViewer9 !== void 0 && _this$sceneViewer9.scene)) {
+      if (!movedSegment || !((_this$sceneViewer8 = this.sceneViewer) !== null && _this$sceneViewer8 !== void 0 && _this$sceneViewer8.scene)) {
         return [];
       }
       console.log('🔗 Finding adjacent segments connected to moved segment...');
@@ -20239,8 +20305,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Get the moved segment's connectors
       var movedConnectors = [];
       movedSegment.traverse(function (child) {
-        var _child$userData13;
-        if (((_child$userData13 = child.userData) === null || _child$userData13 === void 0 ? void 0 : _child$userData13.objectType) === 'segment-connector') {
+        var _child$userData15;
+        if (((_child$userData15 = child.userData) === null || _child$userData15 === void 0 ? void 0 : _child$userData15.objectType) === 'segment-connector') {
           movedConnectors.push(child);
         }
       });
@@ -20253,7 +20319,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       var newEndpoints = this.calculateSegmentEndpoints(movedSegment);
 
       // Check scene data for connections involving the moved segment's connectors
-      var connections = ((_this$sceneViewer0 = this.sceneViewer) === null || _this$sceneViewer0 === void 0 || (_this$sceneViewer0 = _this$sceneViewer0.currentSceneData) === null || _this$sceneViewer0 === void 0 ? void 0 : _this$sceneViewer0.connections) || [];
+      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 movedConnectorIds = movedConnectors.map(function (c) {
         return c.uuid;
       });
@@ -20310,8 +20376,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Get all connectors of the adjacent segment
         var adjacentConnectors = [];
         adjacentSegment.traverse(function (child) {
-          var _child$userData14;
-          if (((_child$userData14 = child.userData) === null || _child$userData14 === void 0 ? void 0 : _child$userData14.objectType) === 'segment-connector') {
+          var _child$userData16;
+          if (((_child$userData16 = child.userData) === null || _child$userData16 === void 0 ? void 0 : _child$userData16.objectType) === 'segment-connector') {
             adjacentConnectors.push(child);
           }
         });
@@ -20399,6 +20465,68 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       this.updateConnectorPositionInSceneData(connector, worldPosition, parentSegment);
     }
 
+    /**
+     * Update component position in currentSceneData after translation
+     * @param {THREE.Object3D} component - The component that was translated
+     * @private
+     */
+  }, {
+    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)) {
+        console.warn('⚠️ Cannot update component position: currentSceneData not available');
+        return;
+      }
+      var cleanPosition = function cleanPosition(value) {
+        return Math.abs(value) < 1e-10 ? 0 : value;
+      };
+
+      // Find the component in scene data
+      var sceneDataComponent = this.sceneViewer.currentSceneData.scene.children.find(function (child) {
+        var _component$userData5;
+        return child.uuid === component.uuid || child.uuid === ((_component$userData5 = component.userData) === null || _component$userData5 === void 0 ? void 0 : _component$userData5.originalUuid);
+      });
+      if (sceneDataComponent) {
+        // Update position object for components (different from connectors which use array)
+        if (!sceneDataComponent.position) {
+          sceneDataComponent.position = {};
+        }
+        sceneDataComponent.position.x = cleanPosition(component.position.x);
+        sceneDataComponent.position.y = cleanPosition(component.position.y);
+        sceneDataComponent.position.z = cleanPosition(component.position.z);
+        console.log("\u2705 Updated component ".concat(component.uuid, " position in scene data to [").concat(component.position.x, ", ").concat(component.position.y, ", ").concat(component.position.z, "]"));
+
+        // 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') {
+              // Find the actual connector object in the scene
+              var connectorObj = component.children.find(function (c) {
+                var _c$userData;
+                return c.uuid === child.uuid || ((_c$userData = c.userData) === null || _c$userData === void 0 ? void 0 : _c$userData.originalUuid) === child.uuid;
+              });
+              if (connectorObj) {
+                // Get world position of connector
+                var worldPos = new THREE__namespace.Vector3();
+                connectorObj.getWorldPosition(worldPos);
+
+                // Update connector's position in userData as array
+                if (!child.userData) {
+                  child.userData = {};
+                }
+                child.userData.position = [cleanPosition(worldPos.x), cleanPosition(worldPos.y), cleanPosition(worldPos.z)];
+                console.log("  \u21B3 Updated child connector ".concat(child.uuid, " position to [").concat(child.userData.position.join(', '), "]"));
+              }
+            }
+          });
+        }
+      } else {
+        console.warn("\u26A0\uFE0F Component ".concat(component.uuid, " not found in scene data"));
+      }
+    }
+
     /**
      * Update a connector's position in scene data
      * @param {THREE.Object3D} connector - The connector to update
@@ -20681,8 +20809,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Remove segment from scene data
       if (currentSceneData.scene && currentSceneData.scene.children) {
         var segmentIndex = currentSceneData.scene.children.findIndex(function (child) {
-          var _segment$userData4;
-          return child.uuid === segment.uuid || child.uuid === ((_segment$userData4 = segment.userData) === null || _segment$userData4 === void 0 ? void 0 : _segment$userData4.originalUuid);
+          var _segment$userData10;
+          return child.uuid === segment.uuid || child.uuid === ((_segment$userData10 = segment.userData) === null || _segment$userData10 === void 0 ? void 0 : _segment$userData10.originalUuid);
         });
         if (segmentIndex !== -1) {
           currentSceneData.scene.children.splice(segmentIndex, 1);
@@ -20702,8 +20830,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Check if either external connector belongs to the active segment
         var activeSegmentConnectors = [];
         activeSegment.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$userData18;
+          if (((_child$userData18 = child.userData) === null || _child$userData18 === void 0 ? void 0 : _child$userData18.objectType) === 'segment-connector') {
             activeSegmentConnectors.push(child.uuid);
           }
         });
@@ -20751,8 +20879,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
               // Get all connectors of the active segment
               var activeConnectors = [];
               activeSegment.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$userData19;
+                if (((_child$userData19 = child.userData) === null || _child$userData19 === void 0 ? void 0 : _child$userData19.objectType) === 'segment-connector') {
                   activeConnectors.push(child);
                 }
               });
@@ -24564,365 +24692,6 @@ var PathData = /*#__PURE__*/function () {
   }]);
 }();
 
-/**
- * PathIntersectionDetector - Detects intersections between pipe paths
- * 
- * This class handles all intersection detection logic for both computed paths
- * (from pathfinding) and manual segments (user-positioned pipes).
- * 
- * @class PathIntersectionDetector
- */
-var PathIntersectionDetector = /*#__PURE__*/function () {
-  /**
-   * Create a new PathIntersectionDetector
-   * @param {Object} sceneViewer - Reference to the scene viewer
-   */
-  function PathIntersectionDetector(sceneViewer) {
-    _classCallCheck(this, PathIntersectionDetector);
-    this.sceneViewer = sceneViewer;
-  }
-
-  /**
-   * Check for intersections between paths
-   * @param {Array} paths - Array of path objects from pathfinder
-   * @param {number} tolerance - Distance tolerance for considering pipes as intersecting (default: 0.2)
-   * @param {boolean} includeManualSegments - Whether to include manual segments in the check (default: true)
-   * @returns {Object} Intersection results
-   * @property {boolean} hasIntersections - Whether any intersections were found
-   * @property {Array<Object>} intersections - Array of intersection details
-   * @property {number} count - Total number of intersections found
-   */
-  return _createClass(PathIntersectionDetector, [{
-    key: "checkPathIntersections",
-    value: function checkPathIntersections(paths) {
-      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.2;
-      var includeManualSegments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-      var intersections = [];
-
-      // Convert all paths to line segments for comparison
-      var pathSegments = paths.map(function (pathData, pathIndex) {
-        if (!pathData.path || pathData.path.length < 2) {
-          return null;
-        }
-        var segments = [];
-        var pathPoints = pathData.path.map(function (point) {
-          if (point instanceof THREE__namespace.Vector3) {
-            return point.clone();
-          } else if (Array.isArray(point)) {
-            return new THREE__namespace.Vector3().fromArray(point);
-          } else if (point.x !== undefined && point.y !== undefined && point.z !== undefined) {
-            return new THREE__namespace.Vector3(point.x, point.y, point.z);
-          }
-          return null;
-        }).filter(function (p) {
-          return p !== null;
-        });
-        for (var i = 0; i < pathPoints.length - 1; i++) {
-          segments.push({
-            start: pathPoints[i],
-            end: pathPoints[i + 1],
-            pathIndex: pathIndex,
-            segmentIndex: i,
-            pathFrom: pathData.from,
-            pathTo: pathData.to,
-            isFirstSegment: i === 0,
-            isLastSegment: i === pathPoints.length - 2,
-            isManual: false // Computed path segment
-          });
-        }
-        return segments;
-      }).filter(function (s) {
-        return s !== null;
-      }).flat();
-
-      // Add manual segments if requested
-      if (includeManualSegments) {
-        var manualSegments = this._collectManualSegments(pathSegments.length);
-        pathSegments.push.apply(pathSegments, _toConsumableArray(manualSegments));
-        console.log("\uD83D\uDCE6 Added ".concat(manualSegments.length, " manual segment(s) to intersection check"));
-      }
-      console.log("\uD83D\uDD0D Checking ".concat(pathSegments.length, " segments for intersections..."));
-
-      // Check each pair of segments
-      for (var i = 0; i < pathSegments.length; i++) {
-        for (var j = i + 1; j < pathSegments.length; j++) {
-          var seg1 = pathSegments[i];
-          var seg2 = pathSegments[j];
-
-          // Skip if segments are from the same path
-          if (seg1.pathIndex === seg2.pathIndex) {
-            continue;
-          }
-
-          // Check if segments intersect
-          var intersection = this._checkLineSegmentIntersection(seg1.start, seg1.end, seg2.start, seg2.end, tolerance);
-          if (intersection) {
-            // Check if this is a shared endpoint (connector/gateway)
-            // Paths naturally touch at shared connectors - this is not an intersection
-            var endpointTolerance = 0.01; // Very small tolerance for endpoint matching
-            var touchingAtEndpoint = this._areSegmentsTouchingAtSharedEndpoint(seg1, seg2, endpointTolerance);
-            if (touchingAtEndpoint) {
-              console.log("\u2139\uFE0F Segments share endpoint (not an intersection): ".concat(seg1.pathFrom, " \u2194 ").concat(seg2.pathFrom));
-              continue; // Skip this - it's a valid shared connection point
-            }
-            intersections.push({
-              path1: {
-                from: seg1.pathFrom,
-                to: seg1.pathTo,
-                segmentIndex: seg1.segmentIndex,
-                isManual: seg1.isManual
-              },
-              path2: {
-                from: seg2.pathFrom,
-                to: seg2.pathTo,
-                segmentIndex: seg2.segmentIndex,
-                isManual: seg2.isManual
-              },
-              point: intersection.point,
-              distance: intersection.distance,
-              type: intersection.type
-            });
-            var seg1Type = seg1.isManual ? 'manual' : 'computed';
-            var seg2Type = seg2.isManual ? 'manual' : 'computed';
-            console.log("\u26A0\uFE0F Intersection found between paths:\n            Path 1 (".concat(seg1Type, "): ").concat(seg1.pathFrom, " \u2192 ").concat(seg1.pathTo, " (segment ").concat(seg1.segmentIndex, ")\n            Path 2 (").concat(seg2Type, "): ").concat(seg2.pathFrom, " \u2192 ").concat(seg2.pathTo, " (segment ").concat(seg2.segmentIndex, ")\n            Distance: ").concat(intersection.distance.toFixed(4), "\n            Type: ").concat(intersection.type));
-          }
-        }
-      }
-      var result = {
-        hasIntersections: intersections.length > 0,
-        intersections: intersections,
-        count: intersections.length
-      };
-      if (result.hasIntersections) {
-        console.log("\uD83D\uDEA8 Found ".concat(result.count, " intersection(s) between paths"));
-      } else {
-        console.log("\u2705 No path intersections detected");
-      }
-      return result;
-    }
-
-    /**
-     * Collect manual segments from the scene and convert them to path segments format
-     * @private
-     * @param {number} startingPathIndex - The starting index for manual segment paths
-     * @returns {Array} Array of segment objects in the same format as computed paths
-     */
-  }, {
-    key: "_collectManualSegments",
-    value: function _collectManualSegments(startingPathIndex) {
-      var _this = this;
-      var manualSegments = [];
-      var sceneViewer = this.sceneViewer;
-      var pathIndex = startingPathIndex;
-
-      // Traverse the scene to find manual segments (lowercase "Segment-")
-      sceneViewer.scene.traverse(function (obj) {
-        var _obj$userData, _obj$userData2;
-        if (obj.uuid && obj.uuid.startsWith('Segment-') && ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'segment' && ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.isDeclared) === true) {
-          // Calculate segment endpoints from the cylinder geometry
-          var endpoints = _this._calculateSegmentEndpoints(obj);
-
-          // Create segment object in the same format as computed paths
-          manualSegments.push({
-            start: endpoints.start,
-            end: endpoints.end,
-            pathIndex: pathIndex,
-            segmentIndex: 0,
-            // Manual segments are single-segment paths
-            pathFrom: obj.userData.pathFrom || obj.uuid,
-            pathTo: obj.userData.pathTo || obj.uuid,
-            isFirstSegment: true,
-            isLastSegment: true,
-            isManual: true,
-            // Flag to identify manual segments
-            segmentUuid: obj.uuid
-          });
-          pathIndex++;
-          console.log("\uD83D\uDCE6 Collected manual segment: ".concat(obj.uuid));
-        }
-      });
-      return manualSegments;
-    }
-
-    /**
-     * Calculate the start and end points of a pipe segment in world coordinates
-     * @private
-     * @param {THREE.Object3D} segment - The pipe segment
-     * @returns {Object} Object with start and end points
-     */
-  }, {
-    key: "_calculateSegmentEndpoints",
-    value: function _calculateSegmentEndpoints(segment) {
-      // Get the segment's geometry to determine its length and orientation
-      var geometry = segment.geometry;
-      var length = geometry.parameters.height || 1;
-
-      // Calculate start and end points based on segment position and orientation
-      var startPoint = new THREE__namespace.Vector3();
-      var endPoint = new THREE__namespace.Vector3();
-
-      // Get the segment's direction vector
-      var direction = new THREE__namespace.Vector3(0, 1, 0);
-      direction.applyQuaternion(segment.quaternion);
-
-      // Calculate start point (half length back from center)
-      startPoint.copy(segment.position).sub(direction.clone().multiplyScalar(length / 2));
-
-      // Calculate end point (half length forward from center)
-      endPoint.copy(segment.position).add(direction.clone().multiplyScalar(length / 2));
-      return {
-        start: startPoint,
-        end: endPoint
-      };
-    }
-
-    /**
-     * Check if two segments are touching at a shared endpoint (connector/gateway)
-     * @private
-     * @param {Object} seg1 - First segment
-     * @param {Object} seg2 - Second segment
-     * @param {number} tolerance - Distance tolerance for considering points as the same
-     * @returns {boolean} True if segments share an endpoint
-     */
-  }, {
-    key: "_areSegmentsTouchingAtSharedEndpoint",
-    value: function _areSegmentsTouchingAtSharedEndpoint(seg1, seg2, tolerance) {
-      // Check all possible endpoint combinations
-      var endpoints = [
-      // seg1.start with seg2 endpoints
-      {
-        p1: seg1.start,
-        p2: seg2.start,
-        isSeg1Start: true,
-        isSeg2Start: true
-      }, {
-        p1: seg1.start,
-        p2: seg2.end,
-        isSeg1Start: true,
-        isSeg2Start: false
-      },
-      // seg1.end with seg2 endpoints
-      {
-        p1: seg1.end,
-        p2: seg2.start,
-        isSeg1Start: false,
-        isSeg2Start: true
-      }, {
-        p1: seg1.end,
-        p2: seg2.end,
-        isSeg1Start: false,
-        isSeg2Start: false
-      }];
-      for (var _i = 0, _endpoints = endpoints; _i < _endpoints.length; _i++) {
-        var _endpoints$_i = _endpoints[_i],
-          p1 = _endpoints$_i.p1,
-          p2 = _endpoints$_i.p2,
-          isSeg1Start = _endpoints$_i.isSeg1Start,
-          isSeg2Start = _endpoints$_i.isSeg2Start;
-        var distance = p1.distanceTo(p2);
-        if (distance <= tolerance) {
-          // Verify this is actually an endpoint of the path (not just any segment point)
-          var isSeg1Endpoint = isSeg1Start && seg1.isFirstSegment || !isSeg1Start && seg1.isLastSegment;
-          var isSeg2Endpoint = isSeg2Start && seg2.isFirstSegment || !isSeg2Start && seg2.isLastSegment;
-
-          // Only count as shared endpoint if at least one is a path endpoint
-          // (This handles both connector-to-connector and connector-to-gateway cases)
-          if (isSeg1Endpoint || isSeg2Endpoint) {
-            return true;
-          }
-        }
-      }
-      return false;
-    }
-
-    /**
-     * Check if two line segments intersect or come within tolerance distance
-     * @private
-     * @param {THREE.Vector3} p1 - Start of first segment
-     * @param {THREE.Vector3} p2 - End of first segment
-     * @param {THREE.Vector3} p3 - Start of second segment
-     * @param {THREE.Vector3} p4 - End of second segment
-     * @param {number} tolerance - Distance tolerance
-     * @returns {Object|null} Intersection details or null
-     */
-  }, {
-    key: "_checkLineSegmentIntersection",
-    value: function _checkLineSegmentIntersection(p1, p2, p3, p4, tolerance) {
-      // Calculate closest points on two line segments
-      var d1 = new THREE__namespace.Vector3().subVectors(p2, p1); // Direction of segment 1
-      var d2 = new THREE__namespace.Vector3().subVectors(p4, p3); // Direction of segment 2
-      var r = new THREE__namespace.Vector3().subVectors(p1, p3);
-      var a = d1.dot(d1);
-      var b = d1.dot(d2);
-      var c = d2.dot(d2);
-      var d = d1.dot(r);
-      var e = d2.dot(r);
-      var denom = a * c - b * b;
-
-      // Check if lines are parallel
-      if (Math.abs(denom) < 1e-10) {
-        // Lines are parallel, check if they're close enough
-        var distToLine = this._distancePointToLineSegment(p3, p1, p2);
-        if (distToLine <= tolerance) {
-          return {
-            point: p3.clone(),
-            distance: distToLine,
-            type: 'parallel'
-          };
-        }
-        return null;
-      }
-
-      // Calculate parameters for closest points
-      var s = (b * e - c * d) / denom;
-      var t = (a * e - b * d) / denom;
-
-      // Clamp to segment bounds
-      s = Math.max(0, Math.min(1, s));
-      t = Math.max(0, Math.min(1, t));
-
-      // Calculate closest points
-      var closestPoint1 = new THREE__namespace.Vector3().addVectors(p1, d1.clone().multiplyScalar(s));
-      var closestPoint2 = new THREE__namespace.Vector3().addVectors(p3, d2.clone().multiplyScalar(t));
-
-      // Calculate distance between closest points
-      var distance = closestPoint1.distanceTo(closestPoint2);
-
-      // Check if within tolerance
-      if (distance <= tolerance) {
-        var midPoint = new THREE__namespace.Vector3().addVectors(closestPoint1, closestPoint2).multiplyScalar(0.5);
-        return {
-          point: midPoint,
-          distance: distance,
-          type: distance < 0.01 ? 'crossing' : 'near'
-        };
-      }
-      return null;
-    }
-
-    /**
-     * Calculate distance from a point to a line segment
-     * @private
-     * @param {THREE.Vector3} point - The point
-     * @param {THREE.Vector3} lineStart - Start of line segment
-     * @param {THREE.Vector3} lineEnd - End of line segment
-     * @returns {number} Distance to line segment
-     */
-  }, {
-    key: "_distancePointToLineSegment",
-    value: function _distancePointToLineSegment(point, lineStart, lineEnd) {
-      var line = new THREE__namespace.Vector3().subVectors(lineEnd, lineStart);
-      var lineLength = line.length();
-      if (lineLength < 1e-10) {
-        return point.distanceTo(lineStart);
-      }
-      var t = Math.max(0, Math.min(1, new THREE__namespace.Vector3().subVectors(point, lineStart).dot(line) / (lineLength * lineLength)));
-      var projection = new THREE__namespace.Vector3().addVectors(lineStart, line.multiplyScalar(t));
-      return point.distanceTo(projection);
-    }
-  }]);
-}();
-
 /**
  * SceneDataManager
  * Utility class for managing scene data transformations and queries
@@ -24935,118 +24704,12 @@ var SceneDataManager = /*#__PURE__*/function () {
   }
 
   /**
-   * Get simplified scene data for pathfinding
-   * Collects all objects with objectType, filters out computed objects,
-   * and calculates world bounding boxes
-   * @returns {Object} Simplified scene data with children array
+   * Helper method to find an object in scene data by UUID
+   * @param {Object} sceneData - Scene data to search
+   * @param {string} uuid - UUID to find
+   * @returns {Object|null} Found object or null
    */
   return _createClass(SceneDataManager, [{
-    key: "getSimplifiedSceneData",
-    value: function getSimplifiedSceneData() {
-      // Collect all objects with objectType (flattened list from scene traversal)
-      // Filter out ALL computed objects - only include declared/source objects
-      var sceneDataNew = [];
-      this.sceneViewer.scene.traverse(function (obj) {
-        if (obj.userData && obj.userData.objectType) {
-          // Skip computed gateways (only include declared/manual gateways)
-          if (obj.userData.objectType === 'gateway' && !obj.userData.isDeclared) {
-            return;
-          }
-          sceneDataNew.push(obj);
-        }
-      });
-      console.log('🔗 [SceneDataManager] sceneDataNew (flattened):', sceneDataNew);
-
-      // Calculate world bounding boxes for each object individually (after flattening)
-      // This way we don't need to worry about children - each object is standalone
-      var simplifiedSceneData = {};
-      simplifiedSceneData.children = sceneDataNew.map(function (obj) {
-        var _obj$children;
-        var uuid = obj.uuid;
-
-        // Calculate world bounding box for this individual object
-        var worldBoundingBox = null;
-
-        // For meshes, calculate bbox from geometry only (ignoring children)
-        if (obj.isMesh && obj.geometry) {
-          try {
-            // Compute bounding box from geometry in world space
-            var bbox = new THREE__namespace.Box3();
-            obj.geometry.computeBoundingBox();
-            if (obj.geometry.boundingBox) {
-              // Transform local bbox to world space
-              bbox.copy(obj.geometry.boundingBox);
-              bbox.applyMatrix4(obj.matrixWorld);
-
-              // Only include valid bounding boxes
-              // Check if all components of min and max are finite numbers
-              var isValidBBox = !bbox.isEmpty() && isFinite(bbox.min.x) && isFinite(bbox.min.y) && isFinite(bbox.min.z) && isFinite(bbox.max.x) && isFinite(bbox.max.y) && isFinite(bbox.max.z);
-              if (isValidBBox) {
-                worldBoundingBox = {
-                  min: bbox.min.toArray(),
-                  max: bbox.max.toArray()
-                };
-              } else {
-                console.warn("\u26A0\uFE0F Invalid bounding box for ".concat(uuid, ", skipping"));
-              }
-            }
-          } catch (error) {
-            console.warn("\u26A0\uFE0F Failed to calculate bounding box for ".concat(uuid, ":"), error);
-          }
-        }
-        // For groups or objects with children, use setFromObject but only on this object
-        else if (obj.isGroup || ((_obj$children = obj.children) === null || _obj$children === void 0 ? void 0 : _obj$children.length) > 0) {
-          try {
-            var _bbox = new THREE__namespace.Box3().setFromObject(obj);
-
-            // Check if all components of min and max are finite numbers
-            var _isValidBBox = !_bbox.isEmpty() && isFinite(_bbox.min.x) && isFinite(_bbox.min.y) && isFinite(_bbox.min.z) && isFinite(_bbox.max.x) && isFinite(_bbox.max.y) && isFinite(_bbox.max.z);
-            if (_isValidBBox) {
-              worldBoundingBox = {
-                min: _bbox.min.toArray(),
-                max: _bbox.max.toArray()
-              };
-            }
-          } catch (error) {
-            console.warn("\u26A0\uFE0F Failed to calculate bounding box for ".concat(uuid, ":"), error);
-          }
-        }
-        var results = {
-          uuid: uuid,
-          userData: _objectSpread2(_objectSpread2({}, obj.userData), worldBoundingBox && {
-            worldBoundingBox: worldBoundingBox
-          })
-        };
-
-        // For connectors and gateways, add world position
-        if (obj.userData.objectType.includes('connector') || obj.userData.objectType === 'gateway') {
-          var worldPosition = new THREE__namespace.Vector3();
-          obj.getWorldPosition(worldPosition);
-          results.userData.position = [worldPosition.x, worldPosition.y, worldPosition.z];
-
-          // Differentiate component connectors from segment connectors for pathfinder
-          // Component connectors are children of components
-          if (obj.userData.objectType === 'connector') {
-            var _parent$userData;
-            // Check if parent is a component (not a segment)
-            var parent = obj.parent;
-            if (parent && ((_parent$userData = parent.userData) === null || _parent$userData === void 0 ? void 0 : _parent$userData.objectType) === 'component') {
-              results.userData.objectType = 'component-connector';
-            }
-          }
-        }
-        return results;
-      });
-      return simplifiedSceneData;
-    }
-
-    /**
-     * Helper method to find an object in scene data by UUID
-     * @param {Object} sceneData - Scene data to search
-     * @param {string} uuid - UUID to find
-     * @returns {Object|null} Found object or null
-     */
-  }, {
     key: "findObjectInSceneData",
     value: function findObjectInSceneData(sceneData, uuid) {
       var _searchChildren = function searchChildren(children) {
@@ -25384,7 +25047,8 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             }
             var cylinderGeometry = new THREE__namespace.CylinderGeometry(pipeRadius, pipeRadius, length, 16, 1, false);
             var cylinder = new THREE__namespace.Mesh(cylinderGeometry, pipeMaterial);
-            cylinder.position.copy(start).add(end).multiplyScalar(0.5);
+            var centerPoint = new THREE__namespace.Vector3().copy(start).add(end).multiplyScalar(0.5);
+            cylinder.position.copy(centerPoint);
             var quaternion = new THREE__namespace.Quaternion();
             var up = new THREE__namespace.Vector3(0, 1, 0);
             quaternion.setFromUnitVectors(up, direction.clone().normalize());
@@ -25405,6 +25069,10 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             var isLastSegment = j === pathPoints.length - 2;
             var isImmutable = fromHasDirection && isFirstSegment || toHasDirection && isLastSegment;
 
+            // Calculate relative endpoint offsets from center point
+            var startOffset = new THREE__namespace.Vector3().subVectors(start, centerPoint);
+            var endOffset = new THREE__namespace.Vector3().subVectors(end, centerPoint);
+
             // Add userData to make pipe segments selectable and for tooltip display
             cylinder.userData = {
               objectType: 'segment',
@@ -25412,7 +25080,21 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
               segmentIndex: globalSegmentIndex,
               pathFrom: pathData.from,
               pathTo: pathData.to,
-              immutable: isImmutable // Mark segments connected to component connectors as immutable
+              immutable: isImmutable,
+              // Mark segments connected to component connectors as immutable
+              // Store endpoint offsets relative to center point for reconstruction
+              endpoints: {
+                startOffset: {
+                  x: startOffset.x,
+                  y: startOffset.y,
+                  z: startOffset.z
+                },
+                endOffset: {
+                  x: endOffset.x,
+                  y: endOffset.y,
+                  z: endOffset.z
+                }
+              }
             };
 
             // Increment global segment counter
@@ -26651,9 +26333,6 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
       }
     }
 
-    // Initialize intersection detector
-    _this.intersectionDetector = new PathIntersectionDetector(sceneViewer);
-
     // Initialize rendering manager
     _this.renderingManager = new PathRenderingManager(sceneViewer);
     _this.registerDisposable(_this.renderingManager);
@@ -26725,17 +26404,67 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     // END NEW ADAPTER METHODS
     // ============================================================================
 
+    /**
+     * Enrich sceneData with worldBoundingBox for segments
+     * Connectors remain with just position information
+     * @param {Object} sceneData - Original scene data
+     * @returns {Object} Enriched scene data (shallow copy with modifications)
+     * @private
+     */
+  }, {
+    key: "_enrichSceneDataWithBoundingBoxes",
+    value: function _enrichSceneDataWithBoundingBoxes(sceneData) {
+      var _this3 = this;
+      // Create a shallow copy of sceneData structure
+      var enriched = _objectSpread2({}, sceneData);
+      if (!sceneData.children || !Array.isArray(sceneData.children)) {
+        console.warn('⚠️ sceneData has no children array');
+        return enriched;
+      }
+
+      // Process children to add worldBoundingBox to segments
+      enriched.children = sceneData.children.map(function (child) {
+        // Only 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);
+          if (segmentObject) {
+            // Compute world bounding box
+            var worldBBox = new THREE__namespace.Box3().setFromObject(segmentObject);
+
+            // Return enriched segment 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 segment object in scene: ".concat(child.uuid));
+          }
+        }
+
+        // For non-segments (including connectors), return as-is
+        return child;
+      });
+      return enriched;
+    }
+
     /**
      * Core pathfinding logic shared across initialization and updates
      */
   }, {
     key: "_executePathfinding",
-    value: function () {
+    value: (function () {
       var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(sceneData, connections) {
         var options,
           _options$context,
           context,
           connectionsCopy,
+          enrichedSceneData,
           sceneDataCopy,
           pathfindingResult,
           _args = arguments;
@@ -26752,26 +26481,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               console.log("\uD83D\uDD04 Updated matrix world for ".concat(context, " pathfinding execution"));
 
               // Deep copy connections to prevent pathfinder from mutating the original
-              connectionsCopy = JSON.parse(JSON.stringify(connections));
-              sceneDataCopy = JSON.parse(JSON.stringify(sceneData));
+              connectionsCopy = JSON.parse(JSON.stringify(connections)); // Enrich sceneData with worldBoundingBox for segments before deep copy
+              enrichedSceneData = this._enrichSceneDataWithBoundingBoxes(sceneData);
+              sceneDataCopy = JSON.parse(JSON.stringify(enrichedSceneData));
               console.log("[Pathfinder] sceneDataCopy:", sceneDataCopy);
 
-              // const simplifiedSceneData = JSON.parse(JSON.stringify( this.getSimplifiedSceneData() ));
-
-              // // Take snapshot before pathfinding execution (capture Three.js scene)
-              // this.snapshotManager.takeSnapshot(
-              //   this.sceneViewer.scene,  // Pass the actual Three.js scene
-              //   connectionsCopy, 
-              //   context
-              // );
-
-              // console.log('[Pathfinder] simplifiedSceneData length at creation:', simplifiedSceneData.children?.length);
-              // console.log('[Pathfinder] simplifiedSceneData (deep clone for inspection):', JSON.parse(JSON.stringify(simplifiedSceneData)));   
-
-              // // Add debugging for pathfinder input
-              // console.log('🔍 PATHFINDER DEBUGGING:');
-              // console.log('🔗 [Pathfinder] Connections:', JSON.parse(JSON.stringify(connectionsCopy))); 
-
               // Find paths using v1.0.17 API (sceneData and connections separately)
               // Pass deep copy to ensure pathfinder cannot mutate original connections
               pathfindingResult = this.pathfinder.findPaths(sceneDataCopy, connectionsCopy);
@@ -26780,79 +26494,6 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               console.log('Rewired connections:', JSON.parse(JSON.stringify(pathfindingResult.rewiredConnections)));
               console.log("intersectionCheck input:", pathfindingResult.paths);
 
-              // // Check for path intersections (including manual segments)
-              // const intersectionCheck = this.checkPathIntersections(pathfindingResult.paths, 0.2, true);
-              // pathfindingResult.intersections = intersectionCheck;
-
-              // console.log("intersectionCheck:", intersectionCheck);
-              // console.log("intersectionCheck.hasIntersections:", intersectionCheck.hasIntersections);
-
-              // // Handle intersection detection - undo last operation if intersections found
-              // // Skip this if we're already in the middle of an undo operation
-              // if (intersectionCheck.hasIntersections && !this.isUndoInProgress) {
-              //   console.warn('⚠️ Path intersections detected! Attempting to undo last operation...');
-
-              //   // Set flag to prevent recursive undo attempts
-              //   this.isUndoInProgress = true;
-
-              //   // Access operationHistoryManager through sceneViewer.managers.operationHistory
-              //   const operationHistoryManager = this.sceneViewer?.managers?.operationHistory;
-
-              //   if (operationHistoryManager) {
-              //     const lastOp = operationHistoryManager.getLastOperation();
-
-              //     if (lastOp) {
-              //       console.warn(`⚠️ Intersection caused by operation: ${lastOp.operationName}`, lastOp.params);
-
-              //       // Attempt to undo the operation FIRST (before removing computed objects)
-              //       // This is important because undo needs to find the segment that was moved
-              //       const undoSuccess = operationHistoryManager.undoLastOperation();
-
-              //       if (undoSuccess) {
-              //         console.log('✅ Successfully undid operation that caused intersection');
-
-              //         // Now remove the buggy computed objects that were created with the invalid state
-              //         console.log('🗑️ Removing buggy computed objects after undo...');
-              //         this.removeComputedObjects();
-
-              //         // Re-run pathfinding after undo to restore valid state
-              //         console.log('🔄 Re-running pathfinding after undo to restore clean state...');
-
-              //         // Recursively call _executePathfinding with the corrected scene state
-              //         // This is safe because we've undone the operation, so we won't get into an infinite loop
-              //         const correctedResult = await this._executePathfinding(
-              //           sceneData,
-              //           connections,
-              //           { ...options, context: `${context} (After Undo)` }
-              //         );
-
-              //         // Mark that we performed an undo and return the corrected result
-              //         correctedResult.undoPerformed = true;
-              //         correctedResult.undoneOperation = lastOp;
-
-              //         // Clear the undo flag before returning
-              //         this.isUndoInProgress = false;
-
-              //         return correctedResult;
-              //       } else {
-              //         console.error('❌ Failed to undo operation that caused intersection');
-              //         pathfindingResult.undoFailed = true;
-              //         // Clear the undo flag even on failure
-              //         this.isUndoInProgress = false;
-              //       }
-              //     } else {
-              //       console.warn('⚠️ No operation in history to undo');
-              //       this.isUndoInProgress = false;
-              //     }
-              //   } else {
-              //     console.error('❌ OperationHistoryManager not available for undo');
-              //     console.error('  Available managers:', Object.keys(this.sceneViewer?.managers || {}));
-              //     this.isUndoInProgress = false;
-              //   }
-              // } else if (intersectionCheck.hasIntersections && this.isUndoInProgress) {
-              //   console.log('⏭️ Skipping intersection handling - undo already in progress');
-              // }
-
               // Create gateways in the scene if requested
               if (options.createGateways && pathfindingResult.gateways) {
                 this.renderingManager.createGateways(pathfindingResult);
@@ -26869,7 +26510,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
         return _executePathfinding2.apply(this, arguments);
       }
       return _executePathfinding;
-    }()
+    }())
   }, {
     key: "getSimplifiedSceneData",
     value: function getSimplifiedSceneData() {
@@ -26960,25 +26601,6 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
       console.log("\u2705 Removed ".concat(objectsToRemove.length, " computed objects from scene (segments, elbows, and gateways)"));
     }
 
-    /**
-     * Check for intersections between paths
-     * Delegates to PathIntersectionDetector for the actual detection logic
-     * @param {Array} paths - Array of path objects from pathfinder
-     * @param {number} tolerance - Distance tolerance for considering pipes as intersecting (default: 0.2)
-     * @param {boolean} includeManualSegments - Whether to include manual segments in the check (default: true)
-     * @returns {Object} Intersection results
-     * @property {boolean} hasIntersections - Whether any intersections were found
-     * @property {Array<Object>} intersections - Array of intersection details
-     * @property {number} count - Total number of intersections found
-     */
-  }, {
-    key: "checkPathIntersections",
-    value: function checkPathIntersections(paths) {
-      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.2;
-      var includeManualSegments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-      return this.intersectionDetector.checkPathIntersections(paths, tolerance, includeManualSegments);
-    }
-
     /**
      * Update pathfinding after object transforms
      */
@@ -33805,7 +33427,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.54
+   * @version 0.1.55
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -38011,7 +37633,6 @@ exports.KeyboardControlsManager = KeyboardControlsManager;
 exports.ModelManager = ModelManager;
 exports.OperationHistoryManager = OperationHistoryManager;
 exports.PathData = PathData;
-exports.PathIntersectionDetector = PathIntersectionDetector;
 exports.PathfindingManager = PathfindingManager;
 exports.PerformanceMonitorManager = PerformanceMonitorManager;
 exports.Rendering2D = rendering2D;