@2112-lab/central-plant 0.1.49 → 0.1.50

package/dist/bundle/index.js

@@ -5014,11 +5014,15 @@ var TransformControlsManager = /*#__PURE__*/function () {
                         _this9.selectedObjects[selectedIndex] = segment;
                         console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
                       }
-                      console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(i + 1, "/").concat(segments.length, "):"), {
-                        deltaX: deltaX,
-                        deltaY: deltaY,
-                        deltaZ: deltaZ
-                      });
+                      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)) {
@@ -5145,11 +5149,15 @@ var TransformControlsManager = /*#__PURE__*/function () {
                         _this9.selectedObjects[selectedIndex] = segment;
                         console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
                       }
-                      console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(_i + 1, "/").concat(segments.length, "):"), {
-                        deltaX: deltaX,
-                        deltaY: deltaY,
-                        deltaZ: deltaZ
-                      });
+                      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)) {
@@ -5291,17 +5299,24 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 deltaZ: deltaZ
               });
             case 21:
-              // Reset the multi-selection group transform
-              this.multiSelectionGroup.position.set(0, 0, 0);
-              this.multiSelectionGroup.rotation.set(0, 0, 0);
-              this.multiSelectionGroup.scale.set(1, 1, 1);
+              // 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');
+              }
 
               // 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
-              this.updateMultiSelection();
+              // Update the multi-selection display with new positions (only if we still have selected objects)
+              if (this.selectedObjects.length > 0) {
+                this.updateMultiSelection();
+              }
               console.log("\u2705 Multi-selection transform applied");
             case 22:
               return _context3.a(2);
@@ -19259,17 +19274,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // ALWAYS update connector positions after segment movement (first or subsequent moves)
       this.updateSegmentConnectorPositions(segment);
-
-      // NEW: Update adjacent manual segments to follow this segment's new position
-      var maintainedConnections = this.snapSegmentConnectorsToNearbyEndpoints(segment);
-
-      // NOTE: We do NOT remove connections from scene data
-      // The connections remain valid - the manual segments are maintaining those connections
-      // The pathfinding algorithm should detect that connectors are at the same position
-      // and skip creating computed segments for them
-      if (maintainedConnections.length > 0) {
-        console.log("\u2139\uFE0F ".concat(maintainedConnections.length, " connection(s) maintained by manual segments"));
-      }
+      this.snapSegmentConnectorsToNearbyEndpoints(segment);
 
       // Store transform parameters using the OperationHistoryManager BEFORE updatePaths
       // This is critical so that intersection detection can undo the operation
@@ -19286,9 +19291,6 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // UNLESS skipPathUpdate is true (for batch operations)
       if (!skipPathUpdate) {
         console.log('🔄 Regenerating paths to create connecting pipe segments...');
-        if (maintainedConnections.length > 0) {
-          console.log("\u2139\uFE0F Manual segments are maintaining connections - pathfinding should skip connectors at same position");
-        }
         try {
           if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
             this.sceneViewer.updatePaths();
@@ -20333,8 +20335,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
     }
 
     /**
-     * Recreate segment mesh with new length based on connector positions
-     * @param {THREE.Object3D} segment - The segment to recreate
+     * Adjust segment geometry and transform to match new endpoint positions
+     * @param {THREE.Object3D} segment - The segment to adjust
      * @param {Array<THREE.Object3D>} connectors - The segment's connectors
      * @param {THREE.Vector3} endPoint1 - Explicit world position for first endpoint (optional)
      * @param {THREE.Vector3} endPoint2 - Explicit world position for second endpoint (optional)
@@ -20348,7 +20350,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       var endPoint2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
       var activeSegment = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
       if (!segment || connectors.length !== 2) {
-        console.warn('⚠️ Cannot recreate segment: invalid segment or connectors');
+        console.warn('⚠️ Cannot adjust segment: invalid segment or connectors');
         return;
       }
       var _connectors = _slicedToArray(connectors, 2),
@@ -20391,21 +20393,28 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         this._removeZeroLengthSegment(segment, connectors, activeSegment);
         return;
       }
-      console.log("\uD83D\uDD27 Recreating segment with new length: ".concat(newLength.toFixed(3), " (was ").concat(segment.geometry.parameters.height.toFixed(3), ")"));
+      var oldLength = segment.geometry.parameters.height;
+      console.log("\uD83D\uDD27 Adjusting segment geometry: ".concat(oldLength.toFixed(3), " \u2192 ").concat(newLength.toFixed(3)));
 
-      // Store old geometry and material references
-      var oldGeometry = segment.geometry;
-      segment.material;
-      var pipeRadius = oldGeometry.parameters.radiusTop || 0.1;
+      // Only recreate geometry if length has changed significantly
+      if (Math.abs(newLength - oldLength) > 1e-6) {
+        var oldGeometry = segment.geometry;
+        var pipeRadius = oldGeometry.parameters.radiusTop || 0.1;
 
-      // Create new cylinder geometry with updated length
-      var newGeometry = new THREE__namespace.CylinderGeometry(pipeRadius, pipeRadius, newLength, 16, 1, false);
+        // Create new cylinder geometry with updated length
+        var newGeometry = new THREE__namespace.CylinderGeometry(pipeRadius, pipeRadius, newLength, 16, 1, false);
 
-      // Update segment mesh
-      segment.geometry = newGeometry;
+        // Replace geometry
+        segment.geometry = newGeometry;
+
+        // Dispose old geometry
+        oldGeometry.dispose();
+      }
+
+      // Update segment position to new center
       segment.position.copy(newCenter);
 
-      // Calculate and apply rotation
+      // Calculate and apply rotation to align with new direction
       var quaternion = new THREE__namespace.Quaternion();
       var up = new THREE__namespace.Vector3(0, 1, 0);
       quaternion.setFromUnitVectors(up, direction.clone().normalize());
@@ -20414,12 +20423,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Update matrices
       segment.updateMatrix();
       segment.updateMatrixWorld(true);
-
-      // Dispose old geometry
-      if (oldGeometry && oldGeometry !== newGeometry) {
-        oldGeometry.dispose();
-      }
-      console.log("\u2705 Segment mesh recreated: new length = ".concat(newLength.toFixed(3), ", center = [").concat(newCenter.x.toFixed(2), ", ").concat(newCenter.y.toFixed(2), ", ").concat(newCenter.z.toFixed(2), "]"));
+      console.log("\u2705 Segment adjusted: length = ".concat(newLength.toFixed(3), ", center = [").concat(newCenter.x.toFixed(2), ", ").concat(newCenter.y.toFixed(2), ", ").concat(newCenter.z.toFixed(2), "]"));
     }
 
     /**
@@ -25217,8 +25221,30 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function createPipePaths(paths, crosscubeTextureSet) {
       var _this3 = this;
       var sceneViewer = this.sceneViewer;
-      var globalSegmentIndex = 0; // Counter for globally unique segment indices
 
+      // Find the highest segment index currently in use (both computed SEGMENT-X and manual Segment-X)
+      var maxExistingIndex = -1;
+      sceneViewer.scene.traverse(function (obj) {
+        if (obj.uuid) {
+          // Check for computed segments: SEGMENT-123
+          var computedMatch = obj.uuid.match(/^SEGMENT-(\d+)$/);
+          if (computedMatch) {
+            var index = parseInt(computedMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, index);
+          }
+
+          // Check for manual segments: Segment-123
+          var manualMatch = obj.uuid.match(/^Segment-(\d+)$/);
+          if (manualMatch) {
+            var _index = parseInt(manualMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, _index);
+          }
+        }
+      });
+
+      // Start counter after the highest existing index to prevent UUID conflicts
+      var globalSegmentIndex = maxExistingIndex + 1;
+      console.log("\uD83D\uDD22 Starting segment index at ".concat(globalSegmentIndex, " (max existing: ").concat(maxExistingIndex, ")"));
       var pipeRadius = 0.1;
       var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
       paths.forEach(function (pathData, index) {
@@ -26564,13 +26590,6 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           connectionsCopy,
           simplifiedSceneData,
           pathfindingResult,
-          intersectionCheck,
-          _this$sceneViewer,
-          operationHistoryManager,
-          lastOp,
-          undoSuccess,
-          correctedResult,
-          _this$sceneViewer2,
           _args = arguments;
         return _regenerator().w(function (_context) {
           while (1) switch (_context.n) {
@@ -26605,93 +26624,79 @@ 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)
-              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)) {
-                _context.n = 8;
-                break;
-              }
-              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
-              operationHistoryManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.operationHistory;
-              if (!operationHistoryManager) {
-                _context.n = 6;
-                break;
-              }
-              lastOp = operationHistoryManager.getLastOperation();
-              if (!lastOp) {
-                _context.n = 4;
-                break;
-              }
-              console.warn("\u26A0\uFE0F Intersection caused by operation: ".concat(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
-              undoSuccess = operationHistoryManager.undoLastOperation();
-              if (!undoSuccess) {
-                _context.n = 2;
-                break;
-              }
-              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...');
+              // // 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');
+              // }
 
-              // 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
-              _context.n = 1;
-              return this._executePathfinding(sceneData, connections, _objectSpread2(_objectSpread2({}, options), {}, {
-                context: "".concat(context, " (After Undo)")
-              }));
-            case 1:
-              correctedResult = _context.v;
-              // 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 _context.a(2, correctedResult);
-            case 2:
-              console.error('❌ Failed to undo operation that caused intersection');
-              pathfindingResult.undoFailed = true;
-              // Clear the undo flag even on failure
-              this.isUndoInProgress = false;
-            case 3:
-              _context.n = 5;
-              break;
-            case 4:
-              console.warn('⚠️ No operation in history to undo');
-              this.isUndoInProgress = false;
-            case 5:
-              _context.n = 7;
-              break;
-            case 6:
-              console.error('❌ OperationHistoryManager not available for undo');
-              console.error('  Available managers:', Object.keys(((_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.managers) || {}));
-              this.isUndoInProgress = false;
-            case 7:
-              _context.n = 9;
-              break;
-            case 8:
-              if (intersectionCheck.hasIntersections && this.isUndoInProgress) {
-                console.log('⏭️ Skipping intersection handling - undo already in progress');
-              }
-            case 9:
               // Create gateways in the scene if requested
               if (options.createGateways && pathfindingResult.gateways) {
                 this.renderingManager.createGateways(pathfindingResult);
@@ -33756,7 +33761,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.49
+   * @version 0.1.50
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.

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

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

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

@@ -357,17 +357,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // ALWAYS update connector positions after segment movement (first or subsequent moves)
       this.updateSegmentConnectorPositions(segment);
-
-      // NEW: Update adjacent manual segments to follow this segment's new position
-      var maintainedConnections = this.snapSegmentConnectorsToNearbyEndpoints(segment);
-
-      // NOTE: We do NOT remove connections from scene data
-      // The connections remain valid - the manual segments are maintaining those connections
-      // The pathfinding algorithm should detect that connectors are at the same position
-      // and skip creating computed segments for them
-      if (maintainedConnections.length > 0) {
-        console.log("\u2139\uFE0F ".concat(maintainedConnections.length, " connection(s) maintained by manual segments"));
-      }
+      this.snapSegmentConnectorsToNearbyEndpoints(segment);
 
       // Store transform parameters using the OperationHistoryManager BEFORE updatePaths
       // This is critical so that intersection detection can undo the operation
@@ -384,9 +374,6 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // UNLESS skipPathUpdate is true (for batch operations)
       if (!skipPathUpdate) {
         console.log('🔄 Regenerating paths to create connecting pipe segments...');
-        if (maintainedConnections.length > 0) {
-          console.log("\u2139\uFE0F Manual segments are maintaining connections - pathfinding should skip connectors at same position");
-        }
         try {
           if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
             this.sceneViewer.updatePaths();
@@ -1431,8 +1418,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
     }
 
     /**
-     * Recreate segment mesh with new length based on connector positions
-     * @param {THREE.Object3D} segment - The segment to recreate
+     * Adjust segment geometry and transform to match new endpoint positions
+     * @param {THREE.Object3D} segment - The segment to adjust
      * @param {Array<THREE.Object3D>} connectors - The segment's connectors
      * @param {THREE.Vector3} endPoint1 - Explicit world position for first endpoint (optional)
      * @param {THREE.Vector3} endPoint2 - Explicit world position for second endpoint (optional)
@@ -1446,7 +1433,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       var endPoint2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
       var activeSegment = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
       if (!segment || connectors.length !== 2) {
-        console.warn('⚠️ Cannot recreate segment: invalid segment or connectors');
+        console.warn('⚠️ Cannot adjust segment: invalid segment or connectors');
         return;
       }
       var _connectors = _rollupPluginBabelHelpers.slicedToArray(connectors, 2),
@@ -1489,21 +1476,28 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         this._removeZeroLengthSegment(segment, connectors, activeSegment);
         return;
       }
-      console.log("\uD83D\uDD27 Recreating segment with new length: ".concat(newLength.toFixed(3), " (was ").concat(segment.geometry.parameters.height.toFixed(3), ")"));
+      var oldLength = segment.geometry.parameters.height;
+      console.log("\uD83D\uDD27 Adjusting segment geometry: ".concat(oldLength.toFixed(3), " \u2192 ").concat(newLength.toFixed(3)));
+
+      // Only recreate geometry if length has changed significantly
+      if (Math.abs(newLength - oldLength) > 1e-6) {
+        var oldGeometry = segment.geometry;
+        var pipeRadius = oldGeometry.parameters.radiusTop || 0.1;
 
-      // Store old geometry and material references
-      var oldGeometry = segment.geometry;
-      segment.material;
-      var pipeRadius = oldGeometry.parameters.radiusTop || 0.1;
+        // Create new cylinder geometry with updated length
+        var newGeometry = new THREE__namespace.CylinderGeometry(pipeRadius, pipeRadius, newLength, 16, 1, false);
 
-      // Create new cylinder geometry with updated length
-      var newGeometry = new THREE__namespace.CylinderGeometry(pipeRadius, pipeRadius, newLength, 16, 1, false);
+        // Replace geometry
+        segment.geometry = newGeometry;
 
-      // Update segment mesh
-      segment.geometry = newGeometry;
+        // Dispose old geometry
+        oldGeometry.dispose();
+      }
+
+      // Update segment position to new center
       segment.position.copy(newCenter);
 
-      // Calculate and apply rotation
+      // Calculate and apply rotation to align with new direction
       var quaternion = new THREE__namespace.Quaternion();
       var up = new THREE__namespace.Vector3(0, 1, 0);
       quaternion.setFromUnitVectors(up, direction.clone().normalize());
@@ -1512,12 +1506,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Update matrices
       segment.updateMatrix();
       segment.updateMatrixWorld(true);
-
-      // Dispose old geometry
-      if (oldGeometry && oldGeometry !== newGeometry) {
-        oldGeometry.dispose();
-      }
-      console.log("\u2705 Segment mesh recreated: new length = ".concat(newLength.toFixed(3), ", center = [").concat(newCenter.x.toFixed(2), ", ").concat(newCenter.y.toFixed(2), ", ").concat(newCenter.z.toFixed(2), "]"));
+      console.log("\u2705 Segment adjusted: length = ".concat(newLength.toFixed(3), ", center = [").concat(newCenter.x.toFixed(2), ", ").concat(newCenter.y.toFixed(2), ", ").concat(newCenter.z.toFixed(2), "]"));
     }
 
     /**

package/dist/cjs/src/managers/controls/transformControlsManager.js

@@ -1658,11 +1658,15 @@ var TransformControlsManager = /*#__PURE__*/function () {
                         _this9.selectedObjects[selectedIndex] = segment;
                         console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
                       }
-                      console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(i + 1, "/").concat(segments.length, "):"), {
-                        deltaX: deltaX,
-                        deltaY: deltaY,
-                        deltaZ: deltaZ
-                      });
+                      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)) {
@@ -1789,11 +1793,15 @@ var TransformControlsManager = /*#__PURE__*/function () {
                         _this9.selectedObjects[selectedIndex] = segment;
                         console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
                       }
-                      console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(_i + 1, "/").concat(segments.length, "):"), {
-                        deltaX: deltaX,
-                        deltaY: deltaY,
-                        deltaZ: deltaZ
-                      });
+                      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)) {
@@ -1935,17 +1943,24 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 deltaZ: deltaZ
               });
             case 21:
-              // Reset the multi-selection group transform
-              this.multiSelectionGroup.position.set(0, 0, 0);
-              this.multiSelectionGroup.rotation.set(0, 0, 0);
-              this.multiSelectionGroup.scale.set(1, 1, 1);
+              // 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');
+              }
 
               // 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
-              this.updateMultiSelection();
+              // Update the multi-selection display with new positions (only if we still have selected objects)
+              if (this.selectedObjects.length > 0) {
+                this.updateMultiSelection();
+              }
               console.log("\u2705 Multi-selection transform applied");
             case 22:
               return _context3.a(2);

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

@@ -180,8 +180,30 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function createPipePaths(paths, crosscubeTextureSet) {
       var _this3 = this;
       var sceneViewer = this.sceneViewer;
-      var globalSegmentIndex = 0; // Counter for globally unique segment indices
 
+      // Find the highest segment index currently in use (both computed SEGMENT-X and manual Segment-X)
+      var maxExistingIndex = -1;
+      sceneViewer.scene.traverse(function (obj) {
+        if (obj.uuid) {
+          // Check for computed segments: SEGMENT-123
+          var computedMatch = obj.uuid.match(/^SEGMENT-(\d+)$/);
+          if (computedMatch) {
+            var index = parseInt(computedMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, index);
+          }
+
+          // Check for manual segments: Segment-123
+          var manualMatch = obj.uuid.match(/^Segment-(\d+)$/);
+          if (manualMatch) {
+            var _index = parseInt(manualMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, _index);
+          }
+        }
+      });
+
+      // Start counter after the highest existing index to prevent UUID conflicts
+      var globalSegmentIndex = maxExistingIndex + 1;
+      console.log("\uD83D\uDD22 Starting segment index at ".concat(globalSegmentIndex, " (max existing: ").concat(maxExistingIndex, ")"));
       var pipeRadius = 0.1;
       var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
       paths.forEach(function (pathData, index) {

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

@@ -127,13 +127,6 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           connectionsCopy,
           simplifiedSceneData,
           pathfindingResult,
-          intersectionCheck,
-          _this$sceneViewer,
-          operationHistoryManager,
-          lastOp,
-          undoSuccess,
-          correctedResult,
-          _this$sceneViewer2,
           _args = arguments;
         return _rollupPluginBabelHelpers.regenerator().w(function (_context) {
           while (1) switch (_context.n) {
@@ -168,93 +161,79 @@ 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)
-              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)) {
-                _context.n = 8;
-                break;
-              }
-              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
-              operationHistoryManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.operationHistory;
-              if (!operationHistoryManager) {
-                _context.n = 6;
-                break;
-              }
-              lastOp = operationHistoryManager.getLastOperation();
-              if (!lastOp) {
-                _context.n = 4;
-                break;
-              }
-              console.warn("\u26A0\uFE0F Intersection caused by operation: ".concat(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
-              undoSuccess = operationHistoryManager.undoLastOperation();
-              if (!undoSuccess) {
-                _context.n = 2;
-                break;
-              }
-              console.log('✅ Successfully undid operation that caused intersection');
+              // // 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');
+              // }
 
-              // 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
-              _context.n = 1;
-              return this._executePathfinding(sceneData, connections, _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, options), {}, {
-                context: "".concat(context, " (After Undo)")
-              }));
-            case 1:
-              correctedResult = _context.v;
-              // 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 _context.a(2, correctedResult);
-            case 2:
-              console.error('❌ Failed to undo operation that caused intersection');
-              pathfindingResult.undoFailed = true;
-              // Clear the undo flag even on failure
-              this.isUndoInProgress = false;
-            case 3:
-              _context.n = 5;
-              break;
-            case 4:
-              console.warn('⚠️ No operation in history to undo');
-              this.isUndoInProgress = false;
-            case 5:
-              _context.n = 7;
-              break;
-            case 6:
-              console.error('❌ OperationHistoryManager not available for undo');
-              console.error('  Available managers:', Object.keys(((_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.managers) || {}));
-              this.isUndoInProgress = false;
-            case 7:
-              _context.n = 9;
-              break;
-            case 8:
-              if (intersectionCheck.hasIntersections && this.isUndoInProgress) {
-                console.log('⏭️ Skipping intersection handling - undo already in progress');
-              }
-            case 9:
               // Create gateways in the scene if requested
               if (options.createGateways && pathfindingResult.gateways) {
                 this.renderingManager.createGateways(pathfindingResult);

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

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

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

@@ -333,17 +333,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // ALWAYS update connector positions after segment movement (first or subsequent moves)
       this.updateSegmentConnectorPositions(segment);
-
-      // NEW: Update adjacent manual segments to follow this segment's new position
-      var maintainedConnections = this.snapSegmentConnectorsToNearbyEndpoints(segment);
-
-      // NOTE: We do NOT remove connections from scene data
-      // The connections remain valid - the manual segments are maintaining those connections
-      // The pathfinding algorithm should detect that connectors are at the same position
-      // and skip creating computed segments for them
-      if (maintainedConnections.length > 0) {
-        console.log("\u2139\uFE0F ".concat(maintainedConnections.length, " connection(s) maintained by manual segments"));
-      }
+      this.snapSegmentConnectorsToNearbyEndpoints(segment);
 
       // Store transform parameters using the OperationHistoryManager BEFORE updatePaths
       // This is critical so that intersection detection can undo the operation
@@ -360,9 +350,6 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // UNLESS skipPathUpdate is true (for batch operations)
       if (!skipPathUpdate) {
         console.log('🔄 Regenerating paths to create connecting pipe segments...');
-        if (maintainedConnections.length > 0) {
-          console.log("\u2139\uFE0F Manual segments are maintaining connections - pathfinding should skip connectors at same position");
-        }
         try {
           if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
             this.sceneViewer.updatePaths();
@@ -1407,8 +1394,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
     }
 
     /**
-     * Recreate segment mesh with new length based on connector positions
-     * @param {THREE.Object3D} segment - The segment to recreate
+     * Adjust segment geometry and transform to match new endpoint positions
+     * @param {THREE.Object3D} segment - The segment to adjust
      * @param {Array<THREE.Object3D>} connectors - The segment's connectors
      * @param {THREE.Vector3} endPoint1 - Explicit world position for first endpoint (optional)
      * @param {THREE.Vector3} endPoint2 - Explicit world position for second endpoint (optional)
@@ -1422,7 +1409,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       var endPoint2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
       var activeSegment = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
       if (!segment || connectors.length !== 2) {
-        console.warn('⚠️ Cannot recreate segment: invalid segment or connectors');
+        console.warn('⚠️ Cannot adjust segment: invalid segment or connectors');
         return;
       }
       var _connectors = _slicedToArray(connectors, 2),
@@ -1465,21 +1452,28 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         this._removeZeroLengthSegment(segment, connectors, activeSegment);
         return;
       }
-      console.log("\uD83D\uDD27 Recreating segment with new length: ".concat(newLength.toFixed(3), " (was ").concat(segment.geometry.parameters.height.toFixed(3), ")"));
+      var oldLength = segment.geometry.parameters.height;
+      console.log("\uD83D\uDD27 Adjusting segment geometry: ".concat(oldLength.toFixed(3), " \u2192 ").concat(newLength.toFixed(3)));
+
+      // Only recreate geometry if length has changed significantly
+      if (Math.abs(newLength - oldLength) > 1e-6) {
+        var oldGeometry = segment.geometry;
+        var pipeRadius = oldGeometry.parameters.radiusTop || 0.1;
 
-      // Store old geometry and material references
-      var oldGeometry = segment.geometry;
-      segment.material;
-      var pipeRadius = oldGeometry.parameters.radiusTop || 0.1;
+        // Create new cylinder geometry with updated length
+        var newGeometry = new THREE.CylinderGeometry(pipeRadius, pipeRadius, newLength, 16, 1, false);
 
-      // Create new cylinder geometry with updated length
-      var newGeometry = new THREE.CylinderGeometry(pipeRadius, pipeRadius, newLength, 16, 1, false);
+        // Replace geometry
+        segment.geometry = newGeometry;
 
-      // Update segment mesh
-      segment.geometry = newGeometry;
+        // Dispose old geometry
+        oldGeometry.dispose();
+      }
+
+      // Update segment position to new center
       segment.position.copy(newCenter);
 
-      // Calculate and apply rotation
+      // Calculate and apply rotation to align with new direction
       var quaternion = new THREE.Quaternion();
       var up = new THREE.Vector3(0, 1, 0);
       quaternion.setFromUnitVectors(up, direction.clone().normalize());
@@ -1488,12 +1482,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Update matrices
       segment.updateMatrix();
       segment.updateMatrixWorld(true);
-
-      // Dispose old geometry
-      if (oldGeometry && oldGeometry !== newGeometry) {
-        oldGeometry.dispose();
-      }
-      console.log("\u2705 Segment mesh recreated: new length = ".concat(newLength.toFixed(3), ", center = [").concat(newCenter.x.toFixed(2), ", ").concat(newCenter.y.toFixed(2), ", ").concat(newCenter.z.toFixed(2), "]"));
+      console.log("\u2705 Segment adjusted: length = ".concat(newLength.toFixed(3), ", center = [").concat(newCenter.x.toFixed(2), ", ").concat(newCenter.y.toFixed(2), ", ").concat(newCenter.z.toFixed(2), "]"));
     }
 
     /**

package/dist/esm/src/managers/controls/transformControlsManager.js

@@ -1634,11 +1634,15 @@ var TransformControlsManager = /*#__PURE__*/function () {
                         _this9.selectedObjects[selectedIndex] = segment;
                         console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
                       }
-                      console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(i + 1, "/").concat(segments.length, "):"), {
-                        deltaX: deltaX,
-                        deltaY: deltaY,
-                        deltaZ: deltaZ
-                      });
+                      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)) {
@@ -1765,11 +1769,15 @@ var TransformControlsManager = /*#__PURE__*/function () {
                         _this9.selectedObjects[selectedIndex] = segment;
                         console.log("\u2705 Updated selectedObjects[".concat(selectedIndex, "] with refreshed segment reference"));
                       }
-                      console.log("\uD83D\uDCE6 Segment ".concat(segment.name, " translated (").concat(_i + 1, "/").concat(segments.length, "):"), {
-                        deltaX: deltaX,
-                        deltaY: deltaY,
-                        deltaZ: deltaZ
-                      });
+                      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)) {
@@ -1911,17 +1919,24 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 deltaZ: deltaZ
               });
             case 21:
-              // Reset the multi-selection group transform
-              this.multiSelectionGroup.position.set(0, 0, 0);
-              this.multiSelectionGroup.rotation.set(0, 0, 0);
-              this.multiSelectionGroup.scale.set(1, 1, 1);
+              // 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');
+              }
 
               // 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
-              this.updateMultiSelection();
+              // Update the multi-selection display with new positions (only if we still have selected objects)
+              if (this.selectedObjects.length > 0) {
+                this.updateMultiSelection();
+              }
               console.log("\u2705 Multi-selection transform applied");
             case 22:
               return _context3.a(2);

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

@@ -156,8 +156,30 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function createPipePaths(paths, crosscubeTextureSet) {
       var _this3 = this;
       var sceneViewer = this.sceneViewer;
-      var globalSegmentIndex = 0; // Counter for globally unique segment indices
 
+      // Find the highest segment index currently in use (both computed SEGMENT-X and manual Segment-X)
+      var maxExistingIndex = -1;
+      sceneViewer.scene.traverse(function (obj) {
+        if (obj.uuid) {
+          // Check for computed segments: SEGMENT-123
+          var computedMatch = obj.uuid.match(/^SEGMENT-(\d+)$/);
+          if (computedMatch) {
+            var index = parseInt(computedMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, index);
+          }
+
+          // Check for manual segments: Segment-123
+          var manualMatch = obj.uuid.match(/^Segment-(\d+)$/);
+          if (manualMatch) {
+            var _index = parseInt(manualMatch[1], 10);
+            maxExistingIndex = Math.max(maxExistingIndex, _index);
+          }
+        }
+      });
+
+      // Start counter after the highest existing index to prevent UUID conflicts
+      var globalSegmentIndex = maxExistingIndex + 1;
+      console.log("\uD83D\uDD22 Starting segment index at ".concat(globalSegmentIndex, " (max existing: ").concat(maxExistingIndex, ")"));
       var pipeRadius = 0.1;
       var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
       paths.forEach(function (pathData, index) {

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

@@ -1,4 +1,4 @@
-import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, objectSpread2 as _objectSpread2 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import 'three';
 import { Pathfinder } from '@2112-lab/pathfinder';
 import { BaseDisposable } from '../../core/baseDisposable.js';
@@ -123,13 +123,6 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           connectionsCopy,
           simplifiedSceneData,
           pathfindingResult,
-          intersectionCheck,
-          _this$sceneViewer,
-          operationHistoryManager,
-          lastOp,
-          undoSuccess,
-          correctedResult,
-          _this$sceneViewer2,
           _args = arguments;
         return _regenerator().w(function (_context) {
           while (1) switch (_context.n) {
@@ -164,93 +157,79 @@ 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)
-              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)) {
-                _context.n = 8;
-                break;
-              }
-              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
-              operationHistoryManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.operationHistory;
-              if (!operationHistoryManager) {
-                _context.n = 6;
-                break;
-              }
-              lastOp = operationHistoryManager.getLastOperation();
-              if (!lastOp) {
-                _context.n = 4;
-                break;
-              }
-              console.warn("\u26A0\uFE0F Intersection caused by operation: ".concat(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
-              undoSuccess = operationHistoryManager.undoLastOperation();
-              if (!undoSuccess) {
-                _context.n = 2;
-                break;
-              }
-              console.log('✅ Successfully undid operation that caused intersection');
+              // // 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');
+              // }
 
-              // 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
-              _context.n = 1;
-              return this._executePathfinding(sceneData, connections, _objectSpread2(_objectSpread2({}, options), {}, {
-                context: "".concat(context, " (After Undo)")
-              }));
-            case 1:
-              correctedResult = _context.v;
-              // 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 _context.a(2, correctedResult);
-            case 2:
-              console.error('❌ Failed to undo operation that caused intersection');
-              pathfindingResult.undoFailed = true;
-              // Clear the undo flag even on failure
-              this.isUndoInProgress = false;
-            case 3:
-              _context.n = 5;
-              break;
-            case 4:
-              console.warn('⚠️ No operation in history to undo');
-              this.isUndoInProgress = false;
-            case 5:
-              _context.n = 7;
-              break;
-            case 6:
-              console.error('❌ OperationHistoryManager not available for undo');
-              console.error('  Available managers:', Object.keys(((_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.managers) || {}));
-              this.isUndoInProgress = false;
-            case 7:
-              _context.n = 9;
-              break;
-            case 8:
-              if (intersectionCheck.hasIntersections && this.isUndoInProgress) {
-                console.log('⏭️ Skipping intersection handling - undo already in progress');
-              }
-            case 9:
               // Create gateways in the scene if requested
               if (options.createGateways && pathfindingResult.gateways) {
                 this.renderingManager.createGateways(pathfindingResult);

package/package.json

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