@2112-lab/central-plant 0.1.25 → 0.1.26

package/dist/bundle/index.js

@@ -25865,8 +25865,8 @@ var CentralPlant = /*#__PURE__*/function () {
      * Update paths in the scene
      * @returns {boolean} True if paths were updated successfully, false otherwise
      * @description Triggers an update of all connection paths/pipes in the scene to reflect
-     * current component positions and connections. This should be called after moving components
-     * or adding/removing connections.
+     * current component positions and connections. This method ensures all scene data is
+     * synchronized before updating paths for guaranteed accuracy.
      * @example
      * // After moving components or changing connections
      * const success = centralPlant.updatePaths();
@@ -25882,8 +25882,15 @@ var CentralPlant = /*#__PURE__*/function () {
         return false;
       }
       try {
+        // Step 1: Ensure scene data is synchronized before updating paths
+        console.log('🔄 updatePaths(): Synchronizing scene data before path update...');
+        if (!this.syncSceneData()) {
+          console.warn('⚠️ updatePaths(): Scene data synchronization failed, proceeding with caution');
+        }
+
+        // Step 2: Update paths with synchronized data
         this.sceneViewer.updatePaths();
-        console.log('✅ updatePaths(): Paths updated successfully');
+        console.log('✅ updatePaths(): Paths updated successfully with synchronized data');
         return true;
       } catch (error) {
         console.error('❌ updatePaths(): Error updating paths:', error);
@@ -25891,6 +25898,262 @@ var CentralPlant = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * Synchronize scene data to ensure all component positions and properties are up-to-date
+     * @returns {boolean} True if synchronization was successful, false otherwise
+     * @description Updates the currentSceneData to match the actual Three.js scene state.
+     * This includes component positions, rotations, scales, and world bounding boxes.
+     * Should be called before operations that depend on accurate scene data.
+     * @example
+     * // Ensure scene data is current before pathfinding
+     * const success = centralPlant.syncSceneData();
+     * if (success) {
+     *   console.log('Scene data synchronized with Three.js scene');
+     * }
+     */
+  }, {
+    key: "syncSceneData",
+    value: function syncSceneData() {
+      var _this = this;
+      // Check if scene viewer and currentSceneData are available
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ syncSceneData(): Scene viewer or current scene data not available');
+        return false;
+      }
+      if (!this.sceneViewer.scene) {
+        console.warn('⚠️ syncSceneData(): Three.js scene not available');
+        return false;
+      }
+      try {
+        console.log('🔄 syncSceneData(): Starting scene data synchronization...');
+
+        // Get reference to currentSceneData
+        var currentSceneData = this.sceneViewer.currentSceneData;
+        if (!currentSceneData.scene || !currentSceneData.scene.object || !currentSceneData.scene.object.children) {
+          console.warn('⚠️ syncSceneData(): Invalid currentSceneData structure');
+          return false;
+        }
+
+        // Update each component in scene data to match Three.js scene
+        var updatedCount = 0;
+        currentSceneData.scene.object.children.forEach(function (sceneDataChild, index) {
+          // Find matching Three.js object
+          var matchingThreeObject = null;
+          _this.sceneViewer.scene.traverse(function (threeObject) {
+            var _sceneDataChild$userD, _threeObject$userData, _threeObject$userData2;
+            // Check various UUID matching strategies
+            if (threeObject.uuid === sceneDataChild.uuid || threeObject.uuid === ((_sceneDataChild$userD = sceneDataChild.userData) === null || _sceneDataChild$userD === void 0 ? void 0 : _sceneDataChild$userD.originalUuid) || ((_threeObject$userData = threeObject.userData) === null || _threeObject$userData === void 0 ? void 0 : _threeObject$userData.originalUuid) === sceneDataChild.uuid || ((_threeObject$userData2 = threeObject.userData) === null || _threeObject$userData2 === void 0 ? void 0 : _threeObject$userData2.hardcodedUuid) === sceneDataChild.uuid) {
+              matchingThreeObject = threeObject;
+            }
+          });
+          if (matchingThreeObject) {
+            // Update position, rotation, and scale
+            sceneDataChild.position = {
+              x: matchingThreeObject.position.x,
+              y: matchingThreeObject.position.y,
+              z: matchingThreeObject.position.z
+            };
+            sceneDataChild.rotation = {
+              x: matchingThreeObject.rotation.x,
+              y: matchingThreeObject.rotation.y,
+              z: matchingThreeObject.rotation.z
+            };
+            sceneDataChild.scale = {
+              x: matchingThreeObject.scale.x,
+              y: matchingThreeObject.scale.y,
+              z: matchingThreeObject.scale.z
+            };
+
+            // Update matrix
+            sceneDataChild.matrix = matchingThreeObject.matrix.elements;
+
+            // Update world bounding box
+            if (matchingThreeObject.isMesh) {
+              var boundingBox = new THREE__namespace.Box3().setFromObject(matchingThreeObject);
+              if (!sceneDataChild.userData) sceneDataChild.userData = {};
+              sceneDataChild.userData.worldBoundingBox = {
+                min: boundingBox.min.toArray(),
+                max: boundingBox.max.toArray()
+              };
+            }
+
+            // Sync children (connectors) if they exist
+            if (sceneDataChild.children && matchingThreeObject.children) {
+              sceneDataChild.children.forEach(function (sceneChild, childIndex) {
+                var matchingChild = matchingThreeObject.children.find(function (threeChild) {
+                  var _sceneChild$userData, _threeChild$userData;
+                  return threeChild.uuid === sceneChild.uuid || threeChild.uuid === ((_sceneChild$userData = sceneChild.userData) === null || _sceneChild$userData === void 0 ? void 0 : _sceneChild$userData.originalUuid) || ((_threeChild$userData = threeChild.userData) === null || _threeChild$userData === void 0 ? void 0 : _threeChild$userData.originalUuid) === sceneChild.uuid;
+                });
+                if (matchingChild) {
+                  var _matchingChild$userDa;
+                  // Update child position, rotation, and scale
+                  sceneChild.position = {
+                    x: matchingChild.position.x,
+                    y: matchingChild.position.y,
+                    z: matchingChild.position.z
+                  };
+                  sceneChild.rotation = {
+                    x: matchingChild.rotation.x,
+                    y: matchingChild.rotation.y,
+                    z: matchingChild.rotation.z
+                  };
+                  sceneChild.scale = {
+                    x: matchingChild.scale.x,
+                    y: matchingChild.scale.y,
+                    z: matchingChild.scale.z
+                  };
+
+                  // Update direction vector for connectors
+                  if ((_matchingChild$userDa = matchingChild.userData) !== null && _matchingChild$userDa !== void 0 && _matchingChild$userDa.direction) {
+                    if (!sceneChild.userData) sceneChild.userData = {};
+                    sceneChild.userData.direction = _toConsumableArray(matchingChild.userData.direction);
+                  }
+                }
+              });
+            }
+            updatedCount++;
+          } else {
+            console.warn("\u26A0\uFE0F syncSceneData(): No matching Three.js object found for scene data child: ".concat(sceneDataChild.uuid));
+          }
+        });
+
+        // Force recompute world bounding boxes for pathfinding accuracy
+        if (this.sceneViewer.pathfindingManager && typeof this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes === 'function') {
+          this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes(currentSceneData);
+          console.log('🔄 syncSceneData(): Recomputed world bounding boxes for pathfinding');
+        }
+        console.log("\u2705 syncSceneData(): Synchronized ".concat(updatedCount, " components successfully"));
+        return true;
+      } catch (error) {
+        console.error('❌ syncSceneData(): Error synchronizing scene data:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Force complete scene data synchronization using SceneOperationsManager
+     * @returns {boolean} True if forced synchronization was successful, false otherwise
+     * @description Uses the SceneOperationsManager's updateSceneDataAfterTransform method
+     * to update scene data for every component. This is more thorough than syncSceneData()
+     * and should be used when maximum accuracy is required.
+     * @example
+     * // Force complete synchronization before critical operations
+     * const success = centralPlant.forceSyncSceneData();
+     * if (success) {
+     *   console.log('Complete scene data synchronization completed');
+     * }
+     */
+  }, {
+    key: "forceSyncSceneData",
+    value: function forceSyncSceneData() {
+      var _this2 = this;
+      // Check if scene viewer and sceneOperationsManager are available
+      if (!this.sceneViewer || !this.sceneViewer.sceneOperationsManager) {
+        console.warn('⚠️ forceSyncSceneData(): Scene viewer or scene operations manager not available');
+        return false;
+      }
+      if (!this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ forceSyncSceneData(): Current scene data not available');
+        return false;
+      }
+      if (!this.sceneViewer.scene) {
+        console.warn('⚠️ forceSyncSceneData(): Three.js scene not available');
+        return false;
+      }
+      try {
+        console.log('🔄 forceSyncSceneData(): Starting forced scene data synchronization...');
+        var syncedCount = 0;
+        var currentSceneData = this.sceneViewer.currentSceneData;
+
+        // Traverse all objects in the Three.js scene and update their scene data
+        this.sceneViewer.scene.traverse(function (threeObject) {
+          // Only sync objects that have component-related userData
+          if (threeObject.userData && (threeObject.userData.componentType === 'component' || threeObject.userData.componentType === 'gateway' || threeObject.userData.libraryId)) {
+            console.log("\uD83D\uDD04 Syncing object: ".concat(threeObject.uuid, " (").concat(threeObject.userData.componentType || 'unknown', ")"));
+
+            // Use the existing updateSceneDataAfterTransform method
+            var success = _this2.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(threeObject, currentSceneData);
+            if (success) {
+              syncedCount++;
+            } else {
+              console.warn("\u26A0\uFE0F Failed to sync object: ".concat(threeObject.uuid));
+            }
+          }
+        });
+        console.log("\u2705 forceSyncSceneData(): Force synchronized ".concat(syncedCount, " objects successfully"));
+        return true;
+      } catch (error) {
+        console.error('❌ forceSyncSceneData(): Error during forced scene data synchronization:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Update paths with optional scene data synchronization level
+     * @param {string} [syncLevel='auto'] - Level of synchronization: 'none', 'basic', 'complete', or 'auto'
+     * @returns {boolean} True if paths were updated successfully, false otherwise
+     * @description Enhanced updatePaths method that allows choosing the level of scene data 
+     * synchronization before updating paths. The 'auto' level intelligently chooses based
+     * on scene complexity and recent changes.
+     * @example
+     * // Update paths with automatic synchronization (recommended)
+     * centralPlant.updatePathsWithSync('auto');
+     * 
+     * // Update paths with complete synchronization (most accurate)
+     * centralPlant.updatePathsWithSync('complete');
+     * 
+     * // Update paths without synchronization (fastest)
+     * centralPlant.updatePathsWithSync('none');
+     */
+  }, {
+    key: "updatePathsWithSync",
+    value: function updatePathsWithSync() {
+      var syncLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'auto';
+      if (!this.sceneViewer || !this.sceneViewer.updatePaths) {
+        console.warn('⚠️ updatePathsWithSync(): Scene viewer or updatePaths method not available');
+        return false;
+      }
+      try {
+        // Determine sync level automatically if needed
+        if (syncLevel === 'auto') {
+          var _this$transformHistor;
+          // Use basic sync by default, but upgrade to complete if recent transforms detected
+          syncLevel = (_this$transformHistor = this.transformHistory) !== null && _this$transformHistor !== void 0 && _this$transformHistor.lastTransform && Date.now() - new Date(this.transformHistory.lastTransform.timestamp).getTime() < 5000 ? 'complete' : 'basic';
+          console.log("\uD83E\uDD16 updatePathsWithSync(): Auto-selected sync level: ".concat(syncLevel));
+        }
+
+        // Perform synchronization based on level
+        var syncSuccess = true;
+        switch (syncLevel) {
+          case 'none':
+            console.log('⚡ updatePathsWithSync(): Skipping synchronization for speed');
+            break;
+          case 'basic':
+            console.log('🔄 updatePathsWithSync(): Performing basic scene data synchronization...');
+            syncSuccess = this.syncSceneData();
+            break;
+          case 'complete':
+            console.log('🔄 updatePathsWithSync(): Performing complete scene data synchronization...');
+            syncSuccess = this.forceSyncSceneData();
+            break;
+          default:
+            console.warn("\u26A0\uFE0F updatePathsWithSync(): Unknown sync level '".concat(syncLevel, "', defaulting to basic"));
+            syncSuccess = this.syncSceneData();
+        }
+        if (!syncSuccess && syncLevel !== 'none') {
+          console.warn('⚠️ updatePathsWithSync(): Scene data synchronization failed, proceeding with caution');
+        }
+
+        // Update paths
+        this.sceneViewer.updatePaths();
+        console.log("\u2705 updatePathsWithSync(): Paths updated successfully with '".concat(syncLevel, "' synchronization"));
+        return true;
+      } catch (error) {
+        console.error('❌ updatePathsWithSync(): Error updating paths with sync:', error);
+        return false;
+      }
+    }
+
     /**
      * Add a connection between two connector IDs to the connections list
      * @param {string} fromConnectorId - The UUID of the source connector

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

@@ -569,8 +569,8 @@ var CentralPlant = /*#__PURE__*/function () {
      * Update paths in the scene
      * @returns {boolean} True if paths were updated successfully, false otherwise
      * @description Triggers an update of all connection paths/pipes in the scene to reflect
-     * current component positions and connections. This should be called after moving components
-     * or adding/removing connections.
+     * current component positions and connections. This method ensures all scene data is
+     * synchronized before updating paths for guaranteed accuracy.
      * @example
      * // After moving components or changing connections
      * const success = centralPlant.updatePaths();
@@ -586,8 +586,15 @@ var CentralPlant = /*#__PURE__*/function () {
         return false;
       }
       try {
+        // Step 1: Ensure scene data is synchronized before updating paths
+        console.log('🔄 updatePaths(): Synchronizing scene data before path update...');
+        if (!this.syncSceneData()) {
+          console.warn('⚠️ updatePaths(): Scene data synchronization failed, proceeding with caution');
+        }
+
+        // Step 2: Update paths with synchronized data
         this.sceneViewer.updatePaths();
-        console.log('✅ updatePaths(): Paths updated successfully');
+        console.log('✅ updatePaths(): Paths updated successfully with synchronized data');
         return true;
       } catch (error) {
         console.error('❌ updatePaths(): Error updating paths:', error);
@@ -595,6 +602,262 @@ var CentralPlant = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * Synchronize scene data to ensure all component positions and properties are up-to-date
+     * @returns {boolean} True if synchronization was successful, false otherwise
+     * @description Updates the currentSceneData to match the actual Three.js scene state.
+     * This includes component positions, rotations, scales, and world bounding boxes.
+     * Should be called before operations that depend on accurate scene data.
+     * @example
+     * // Ensure scene data is current before pathfinding
+     * const success = centralPlant.syncSceneData();
+     * if (success) {
+     *   console.log('Scene data synchronized with Three.js scene');
+     * }
+     */
+  }, {
+    key: "syncSceneData",
+    value: function syncSceneData() {
+      var _this = this;
+      // Check if scene viewer and currentSceneData are available
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ syncSceneData(): Scene viewer or current scene data not available');
+        return false;
+      }
+      if (!this.sceneViewer.scene) {
+        console.warn('⚠️ syncSceneData(): Three.js scene not available');
+        return false;
+      }
+      try {
+        console.log('🔄 syncSceneData(): Starting scene data synchronization...');
+
+        // Get reference to currentSceneData
+        var currentSceneData = this.sceneViewer.currentSceneData;
+        if (!currentSceneData.scene || !currentSceneData.scene.object || !currentSceneData.scene.object.children) {
+          console.warn('⚠️ syncSceneData(): Invalid currentSceneData structure');
+          return false;
+        }
+
+        // Update each component in scene data to match Three.js scene
+        var updatedCount = 0;
+        currentSceneData.scene.object.children.forEach(function (sceneDataChild, index) {
+          // Find matching Three.js object
+          var matchingThreeObject = null;
+          _this.sceneViewer.scene.traverse(function (threeObject) {
+            var _sceneDataChild$userD, _threeObject$userData, _threeObject$userData2;
+            // Check various UUID matching strategies
+            if (threeObject.uuid === sceneDataChild.uuid || threeObject.uuid === ((_sceneDataChild$userD = sceneDataChild.userData) === null || _sceneDataChild$userD === void 0 ? void 0 : _sceneDataChild$userD.originalUuid) || ((_threeObject$userData = threeObject.userData) === null || _threeObject$userData === void 0 ? void 0 : _threeObject$userData.originalUuid) === sceneDataChild.uuid || ((_threeObject$userData2 = threeObject.userData) === null || _threeObject$userData2 === void 0 ? void 0 : _threeObject$userData2.hardcodedUuid) === sceneDataChild.uuid) {
+              matchingThreeObject = threeObject;
+            }
+          });
+          if (matchingThreeObject) {
+            // Update position, rotation, and scale
+            sceneDataChild.position = {
+              x: matchingThreeObject.position.x,
+              y: matchingThreeObject.position.y,
+              z: matchingThreeObject.position.z
+            };
+            sceneDataChild.rotation = {
+              x: matchingThreeObject.rotation.x,
+              y: matchingThreeObject.rotation.y,
+              z: matchingThreeObject.rotation.z
+            };
+            sceneDataChild.scale = {
+              x: matchingThreeObject.scale.x,
+              y: matchingThreeObject.scale.y,
+              z: matchingThreeObject.scale.z
+            };
+
+            // Update matrix
+            sceneDataChild.matrix = matchingThreeObject.matrix.elements;
+
+            // Update world bounding box
+            if (matchingThreeObject.isMesh) {
+              var boundingBox = new THREE__namespace.Box3().setFromObject(matchingThreeObject);
+              if (!sceneDataChild.userData) sceneDataChild.userData = {};
+              sceneDataChild.userData.worldBoundingBox = {
+                min: boundingBox.min.toArray(),
+                max: boundingBox.max.toArray()
+              };
+            }
+
+            // Sync children (connectors) if they exist
+            if (sceneDataChild.children && matchingThreeObject.children) {
+              sceneDataChild.children.forEach(function (sceneChild, childIndex) {
+                var matchingChild = matchingThreeObject.children.find(function (threeChild) {
+                  var _sceneChild$userData, _threeChild$userData;
+                  return threeChild.uuid === sceneChild.uuid || threeChild.uuid === ((_sceneChild$userData = sceneChild.userData) === null || _sceneChild$userData === void 0 ? void 0 : _sceneChild$userData.originalUuid) || ((_threeChild$userData = threeChild.userData) === null || _threeChild$userData === void 0 ? void 0 : _threeChild$userData.originalUuid) === sceneChild.uuid;
+                });
+                if (matchingChild) {
+                  var _matchingChild$userDa;
+                  // Update child position, rotation, and scale
+                  sceneChild.position = {
+                    x: matchingChild.position.x,
+                    y: matchingChild.position.y,
+                    z: matchingChild.position.z
+                  };
+                  sceneChild.rotation = {
+                    x: matchingChild.rotation.x,
+                    y: matchingChild.rotation.y,
+                    z: matchingChild.rotation.z
+                  };
+                  sceneChild.scale = {
+                    x: matchingChild.scale.x,
+                    y: matchingChild.scale.y,
+                    z: matchingChild.scale.z
+                  };
+
+                  // Update direction vector for connectors
+                  if ((_matchingChild$userDa = matchingChild.userData) !== null && _matchingChild$userDa !== void 0 && _matchingChild$userDa.direction) {
+                    if (!sceneChild.userData) sceneChild.userData = {};
+                    sceneChild.userData.direction = _rollupPluginBabelHelpers.toConsumableArray(matchingChild.userData.direction);
+                  }
+                }
+              });
+            }
+            updatedCount++;
+          } else {
+            console.warn("\u26A0\uFE0F syncSceneData(): No matching Three.js object found for scene data child: ".concat(sceneDataChild.uuid));
+          }
+        });
+
+        // Force recompute world bounding boxes for pathfinding accuracy
+        if (this.sceneViewer.pathfindingManager && typeof this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes === 'function') {
+          this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes(currentSceneData);
+          console.log('🔄 syncSceneData(): Recomputed world bounding boxes for pathfinding');
+        }
+        console.log("\u2705 syncSceneData(): Synchronized ".concat(updatedCount, " components successfully"));
+        return true;
+      } catch (error) {
+        console.error('❌ syncSceneData(): Error synchronizing scene data:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Force complete scene data synchronization using SceneOperationsManager
+     * @returns {boolean} True if forced synchronization was successful, false otherwise
+     * @description Uses the SceneOperationsManager's updateSceneDataAfterTransform method
+     * to update scene data for every component. This is more thorough than syncSceneData()
+     * and should be used when maximum accuracy is required.
+     * @example
+     * // Force complete synchronization before critical operations
+     * const success = centralPlant.forceSyncSceneData();
+     * if (success) {
+     *   console.log('Complete scene data synchronization completed');
+     * }
+     */
+  }, {
+    key: "forceSyncSceneData",
+    value: function forceSyncSceneData() {
+      var _this2 = this;
+      // Check if scene viewer and sceneOperationsManager are available
+      if (!this.sceneViewer || !this.sceneViewer.sceneOperationsManager) {
+        console.warn('⚠️ forceSyncSceneData(): Scene viewer or scene operations manager not available');
+        return false;
+      }
+      if (!this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ forceSyncSceneData(): Current scene data not available');
+        return false;
+      }
+      if (!this.sceneViewer.scene) {
+        console.warn('⚠️ forceSyncSceneData(): Three.js scene not available');
+        return false;
+      }
+      try {
+        console.log('🔄 forceSyncSceneData(): Starting forced scene data synchronization...');
+        var syncedCount = 0;
+        var currentSceneData = this.sceneViewer.currentSceneData;
+
+        // Traverse all objects in the Three.js scene and update their scene data
+        this.sceneViewer.scene.traverse(function (threeObject) {
+          // Only sync objects that have component-related userData
+          if (threeObject.userData && (threeObject.userData.componentType === 'component' || threeObject.userData.componentType === 'gateway' || threeObject.userData.libraryId)) {
+            console.log("\uD83D\uDD04 Syncing object: ".concat(threeObject.uuid, " (").concat(threeObject.userData.componentType || 'unknown', ")"));
+
+            // Use the existing updateSceneDataAfterTransform method
+            var success = _this2.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(threeObject, currentSceneData);
+            if (success) {
+              syncedCount++;
+            } else {
+              console.warn("\u26A0\uFE0F Failed to sync object: ".concat(threeObject.uuid));
+            }
+          }
+        });
+        console.log("\u2705 forceSyncSceneData(): Force synchronized ".concat(syncedCount, " objects successfully"));
+        return true;
+      } catch (error) {
+        console.error('❌ forceSyncSceneData(): Error during forced scene data synchronization:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Update paths with optional scene data synchronization level
+     * @param {string} [syncLevel='auto'] - Level of synchronization: 'none', 'basic', 'complete', or 'auto'
+     * @returns {boolean} True if paths were updated successfully, false otherwise
+     * @description Enhanced updatePaths method that allows choosing the level of scene data 
+     * synchronization before updating paths. The 'auto' level intelligently chooses based
+     * on scene complexity and recent changes.
+     * @example
+     * // Update paths with automatic synchronization (recommended)
+     * centralPlant.updatePathsWithSync('auto');
+     * 
+     * // Update paths with complete synchronization (most accurate)
+     * centralPlant.updatePathsWithSync('complete');
+     * 
+     * // Update paths without synchronization (fastest)
+     * centralPlant.updatePathsWithSync('none');
+     */
+  }, {
+    key: "updatePathsWithSync",
+    value: function updatePathsWithSync() {
+      var syncLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'auto';
+      if (!this.sceneViewer || !this.sceneViewer.updatePaths) {
+        console.warn('⚠️ updatePathsWithSync(): Scene viewer or updatePaths method not available');
+        return false;
+      }
+      try {
+        // Determine sync level automatically if needed
+        if (syncLevel === 'auto') {
+          var _this$transformHistor;
+          // Use basic sync by default, but upgrade to complete if recent transforms detected
+          syncLevel = (_this$transformHistor = this.transformHistory) !== null && _this$transformHistor !== void 0 && _this$transformHistor.lastTransform && Date.now() - new Date(this.transformHistory.lastTransform.timestamp).getTime() < 5000 ? 'complete' : 'basic';
+          console.log("\uD83E\uDD16 updatePathsWithSync(): Auto-selected sync level: ".concat(syncLevel));
+        }
+
+        // Perform synchronization based on level
+        var syncSuccess = true;
+        switch (syncLevel) {
+          case 'none':
+            console.log('⚡ updatePathsWithSync(): Skipping synchronization for speed');
+            break;
+          case 'basic':
+            console.log('🔄 updatePathsWithSync(): Performing basic scene data synchronization...');
+            syncSuccess = this.syncSceneData();
+            break;
+          case 'complete':
+            console.log('🔄 updatePathsWithSync(): Performing complete scene data synchronization...');
+            syncSuccess = this.forceSyncSceneData();
+            break;
+          default:
+            console.warn("\u26A0\uFE0F updatePathsWithSync(): Unknown sync level '".concat(syncLevel, "', defaulting to basic"));
+            syncSuccess = this.syncSceneData();
+        }
+        if (!syncSuccess && syncLevel !== 'none') {
+          console.warn('⚠️ updatePathsWithSync(): Scene data synchronization failed, proceeding with caution');
+        }
+
+        // Update paths
+        this.sceneViewer.updatePaths();
+        console.log("\u2705 updatePathsWithSync(): Paths updated successfully with '".concat(syncLevel, "' synchronization"));
+        return true;
+      } catch (error) {
+        console.error('❌ updatePathsWithSync(): Error updating paths with sync:', error);
+        return false;
+      }
+    }
+
     /**
      * Add a connection between two connector IDs to the connections list
      * @param {string} fromConnectorId - The UUID of the source connector

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

@@ -1,4 +1,4 @@
-import { createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { createClass as _createClass, objectSpread2 as _objectSpread2, toConsumableArray as _toConsumableArray, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { CentralPlantInternals } from './centralPlantInternals.js';
 import '../rendering/modelPreloader.js';
@@ -545,8 +545,8 @@ var CentralPlant = /*#__PURE__*/function () {
      * Update paths in the scene
      * @returns {boolean} True if paths were updated successfully, false otherwise
      * @description Triggers an update of all connection paths/pipes in the scene to reflect
-     * current component positions and connections. This should be called after moving components
-     * or adding/removing connections.
+     * current component positions and connections. This method ensures all scene data is
+     * synchronized before updating paths for guaranteed accuracy.
      * @example
      * // After moving components or changing connections
      * const success = centralPlant.updatePaths();
@@ -562,8 +562,15 @@ var CentralPlant = /*#__PURE__*/function () {
         return false;
       }
       try {
+        // Step 1: Ensure scene data is synchronized before updating paths
+        console.log('🔄 updatePaths(): Synchronizing scene data before path update...');
+        if (!this.syncSceneData()) {
+          console.warn('⚠️ updatePaths(): Scene data synchronization failed, proceeding with caution');
+        }
+
+        // Step 2: Update paths with synchronized data
         this.sceneViewer.updatePaths();
-        console.log('✅ updatePaths(): Paths updated successfully');
+        console.log('✅ updatePaths(): Paths updated successfully with synchronized data');
         return true;
       } catch (error) {
         console.error('❌ updatePaths(): Error updating paths:', error);
@@ -571,6 +578,262 @@ var CentralPlant = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * Synchronize scene data to ensure all component positions and properties are up-to-date
+     * @returns {boolean} True if synchronization was successful, false otherwise
+     * @description Updates the currentSceneData to match the actual Three.js scene state.
+     * This includes component positions, rotations, scales, and world bounding boxes.
+     * Should be called before operations that depend on accurate scene data.
+     * @example
+     * // Ensure scene data is current before pathfinding
+     * const success = centralPlant.syncSceneData();
+     * if (success) {
+     *   console.log('Scene data synchronized with Three.js scene');
+     * }
+     */
+  }, {
+    key: "syncSceneData",
+    value: function syncSceneData() {
+      var _this = this;
+      // Check if scene viewer and currentSceneData are available
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ syncSceneData(): Scene viewer or current scene data not available');
+        return false;
+      }
+      if (!this.sceneViewer.scene) {
+        console.warn('⚠️ syncSceneData(): Three.js scene not available');
+        return false;
+      }
+      try {
+        console.log('🔄 syncSceneData(): Starting scene data synchronization...');
+
+        // Get reference to currentSceneData
+        var currentSceneData = this.sceneViewer.currentSceneData;
+        if (!currentSceneData.scene || !currentSceneData.scene.object || !currentSceneData.scene.object.children) {
+          console.warn('⚠️ syncSceneData(): Invalid currentSceneData structure');
+          return false;
+        }
+
+        // Update each component in scene data to match Three.js scene
+        var updatedCount = 0;
+        currentSceneData.scene.object.children.forEach(function (sceneDataChild, index) {
+          // Find matching Three.js object
+          var matchingThreeObject = null;
+          _this.sceneViewer.scene.traverse(function (threeObject) {
+            var _sceneDataChild$userD, _threeObject$userData, _threeObject$userData2;
+            // Check various UUID matching strategies
+            if (threeObject.uuid === sceneDataChild.uuid || threeObject.uuid === ((_sceneDataChild$userD = sceneDataChild.userData) === null || _sceneDataChild$userD === void 0 ? void 0 : _sceneDataChild$userD.originalUuid) || ((_threeObject$userData = threeObject.userData) === null || _threeObject$userData === void 0 ? void 0 : _threeObject$userData.originalUuid) === sceneDataChild.uuid || ((_threeObject$userData2 = threeObject.userData) === null || _threeObject$userData2 === void 0 ? void 0 : _threeObject$userData2.hardcodedUuid) === sceneDataChild.uuid) {
+              matchingThreeObject = threeObject;
+            }
+          });
+          if (matchingThreeObject) {
+            // Update position, rotation, and scale
+            sceneDataChild.position = {
+              x: matchingThreeObject.position.x,
+              y: matchingThreeObject.position.y,
+              z: matchingThreeObject.position.z
+            };
+            sceneDataChild.rotation = {
+              x: matchingThreeObject.rotation.x,
+              y: matchingThreeObject.rotation.y,
+              z: matchingThreeObject.rotation.z
+            };
+            sceneDataChild.scale = {
+              x: matchingThreeObject.scale.x,
+              y: matchingThreeObject.scale.y,
+              z: matchingThreeObject.scale.z
+            };
+
+            // Update matrix
+            sceneDataChild.matrix = matchingThreeObject.matrix.elements;
+
+            // Update world bounding box
+            if (matchingThreeObject.isMesh) {
+              var boundingBox = new THREE.Box3().setFromObject(matchingThreeObject);
+              if (!sceneDataChild.userData) sceneDataChild.userData = {};
+              sceneDataChild.userData.worldBoundingBox = {
+                min: boundingBox.min.toArray(),
+                max: boundingBox.max.toArray()
+              };
+            }
+
+            // Sync children (connectors) if they exist
+            if (sceneDataChild.children && matchingThreeObject.children) {
+              sceneDataChild.children.forEach(function (sceneChild, childIndex) {
+                var matchingChild = matchingThreeObject.children.find(function (threeChild) {
+                  var _sceneChild$userData, _threeChild$userData;
+                  return threeChild.uuid === sceneChild.uuid || threeChild.uuid === ((_sceneChild$userData = sceneChild.userData) === null || _sceneChild$userData === void 0 ? void 0 : _sceneChild$userData.originalUuid) || ((_threeChild$userData = threeChild.userData) === null || _threeChild$userData === void 0 ? void 0 : _threeChild$userData.originalUuid) === sceneChild.uuid;
+                });
+                if (matchingChild) {
+                  var _matchingChild$userDa;
+                  // Update child position, rotation, and scale
+                  sceneChild.position = {
+                    x: matchingChild.position.x,
+                    y: matchingChild.position.y,
+                    z: matchingChild.position.z
+                  };
+                  sceneChild.rotation = {
+                    x: matchingChild.rotation.x,
+                    y: matchingChild.rotation.y,
+                    z: matchingChild.rotation.z
+                  };
+                  sceneChild.scale = {
+                    x: matchingChild.scale.x,
+                    y: matchingChild.scale.y,
+                    z: matchingChild.scale.z
+                  };
+
+                  // Update direction vector for connectors
+                  if ((_matchingChild$userDa = matchingChild.userData) !== null && _matchingChild$userDa !== void 0 && _matchingChild$userDa.direction) {
+                    if (!sceneChild.userData) sceneChild.userData = {};
+                    sceneChild.userData.direction = _toConsumableArray(matchingChild.userData.direction);
+                  }
+                }
+              });
+            }
+            updatedCount++;
+          } else {
+            console.warn("\u26A0\uFE0F syncSceneData(): No matching Three.js object found for scene data child: ".concat(sceneDataChild.uuid));
+          }
+        });
+
+        // Force recompute world bounding boxes for pathfinding accuracy
+        if (this.sceneViewer.pathfindingManager && typeof this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes === 'function') {
+          this.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes(currentSceneData);
+          console.log('🔄 syncSceneData(): Recomputed world bounding boxes for pathfinding');
+        }
+        console.log("\u2705 syncSceneData(): Synchronized ".concat(updatedCount, " components successfully"));
+        return true;
+      } catch (error) {
+        console.error('❌ syncSceneData(): Error synchronizing scene data:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Force complete scene data synchronization using SceneOperationsManager
+     * @returns {boolean} True if forced synchronization was successful, false otherwise
+     * @description Uses the SceneOperationsManager's updateSceneDataAfterTransform method
+     * to update scene data for every component. This is more thorough than syncSceneData()
+     * and should be used when maximum accuracy is required.
+     * @example
+     * // Force complete synchronization before critical operations
+     * const success = centralPlant.forceSyncSceneData();
+     * if (success) {
+     *   console.log('Complete scene data synchronization completed');
+     * }
+     */
+  }, {
+    key: "forceSyncSceneData",
+    value: function forceSyncSceneData() {
+      var _this2 = this;
+      // Check if scene viewer and sceneOperationsManager are available
+      if (!this.sceneViewer || !this.sceneViewer.sceneOperationsManager) {
+        console.warn('⚠️ forceSyncSceneData(): Scene viewer or scene operations manager not available');
+        return false;
+      }
+      if (!this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ forceSyncSceneData(): Current scene data not available');
+        return false;
+      }
+      if (!this.sceneViewer.scene) {
+        console.warn('⚠️ forceSyncSceneData(): Three.js scene not available');
+        return false;
+      }
+      try {
+        console.log('🔄 forceSyncSceneData(): Starting forced scene data synchronization...');
+        var syncedCount = 0;
+        var currentSceneData = this.sceneViewer.currentSceneData;
+
+        // Traverse all objects in the Three.js scene and update their scene data
+        this.sceneViewer.scene.traverse(function (threeObject) {
+          // Only sync objects that have component-related userData
+          if (threeObject.userData && (threeObject.userData.componentType === 'component' || threeObject.userData.componentType === 'gateway' || threeObject.userData.libraryId)) {
+            console.log("\uD83D\uDD04 Syncing object: ".concat(threeObject.uuid, " (").concat(threeObject.userData.componentType || 'unknown', ")"));
+
+            // Use the existing updateSceneDataAfterTransform method
+            var success = _this2.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(threeObject, currentSceneData);
+            if (success) {
+              syncedCount++;
+            } else {
+              console.warn("\u26A0\uFE0F Failed to sync object: ".concat(threeObject.uuid));
+            }
+          }
+        });
+        console.log("\u2705 forceSyncSceneData(): Force synchronized ".concat(syncedCount, " objects successfully"));
+        return true;
+      } catch (error) {
+        console.error('❌ forceSyncSceneData(): Error during forced scene data synchronization:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Update paths with optional scene data synchronization level
+     * @param {string} [syncLevel='auto'] - Level of synchronization: 'none', 'basic', 'complete', or 'auto'
+     * @returns {boolean} True if paths were updated successfully, false otherwise
+     * @description Enhanced updatePaths method that allows choosing the level of scene data 
+     * synchronization before updating paths. The 'auto' level intelligently chooses based
+     * on scene complexity and recent changes.
+     * @example
+     * // Update paths with automatic synchronization (recommended)
+     * centralPlant.updatePathsWithSync('auto');
+     * 
+     * // Update paths with complete synchronization (most accurate)
+     * centralPlant.updatePathsWithSync('complete');
+     * 
+     * // Update paths without synchronization (fastest)
+     * centralPlant.updatePathsWithSync('none');
+     */
+  }, {
+    key: "updatePathsWithSync",
+    value: function updatePathsWithSync() {
+      var syncLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'auto';
+      if (!this.sceneViewer || !this.sceneViewer.updatePaths) {
+        console.warn('⚠️ updatePathsWithSync(): Scene viewer or updatePaths method not available');
+        return false;
+      }
+      try {
+        // Determine sync level automatically if needed
+        if (syncLevel === 'auto') {
+          var _this$transformHistor;
+          // Use basic sync by default, but upgrade to complete if recent transforms detected
+          syncLevel = (_this$transformHistor = this.transformHistory) !== null && _this$transformHistor !== void 0 && _this$transformHistor.lastTransform && Date.now() - new Date(this.transformHistory.lastTransform.timestamp).getTime() < 5000 ? 'complete' : 'basic';
+          console.log("\uD83E\uDD16 updatePathsWithSync(): Auto-selected sync level: ".concat(syncLevel));
+        }
+
+        // Perform synchronization based on level
+        var syncSuccess = true;
+        switch (syncLevel) {
+          case 'none':
+            console.log('⚡ updatePathsWithSync(): Skipping synchronization for speed');
+            break;
+          case 'basic':
+            console.log('🔄 updatePathsWithSync(): Performing basic scene data synchronization...');
+            syncSuccess = this.syncSceneData();
+            break;
+          case 'complete':
+            console.log('🔄 updatePathsWithSync(): Performing complete scene data synchronization...');
+            syncSuccess = this.forceSyncSceneData();
+            break;
+          default:
+            console.warn("\u26A0\uFE0F updatePathsWithSync(): Unknown sync level '".concat(syncLevel, "', defaulting to basic"));
+            syncSuccess = this.syncSceneData();
+        }
+        if (!syncSuccess && syncLevel !== 'none') {
+          console.warn('⚠️ updatePathsWithSync(): Scene data synchronization failed, proceeding with caution');
+        }
+
+        // Update paths
+        this.sceneViewer.updatePaths();
+        console.log("\u2705 updatePathsWithSync(): Paths updated successfully with '".concat(syncLevel, "' synchronization"));
+        return true;
+      } catch (error) {
+        console.error('❌ updatePathsWithSync(): Error updating paths with sync:', error);
+        return false;
+      }
+    }
+
     /**
      * Add a connection between two connector IDs to the connections list
      * @param {string} fromConnectorId - The UUID of the source connector

package/package.json

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