@2112-lab/central-plant 0.3.47 → 0.3.48

package/dist/bundle/index.js

@@ -3720,41 +3720,36 @@ function computeFilteredBoundingBox(object) {
  */
 function computeIODeviceBoundingBoxes(componentObject) {
   var results = [];
-  var _iterator = _createForOfIteratorHelper(componentObject.children),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _child$userData;
-      var child = _step.value;
-      if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) !== 'io-device') continue;
-      var bbox = new THREE__namespace.Box3().setFromObject(child);
-      if (!bbox.isEmpty()) {
-        results.push({
-          uuid: child.uuid,
-          userData: {
-            objectType: 'io-device',
-            deviceId: child.userData.deviceId || null,
-            attachmentId: child.userData.attachmentId || null,
-            parentComponentId: child.userData.parentComponentId || componentObject.uuid
-          },
-          worldBoundingBox: {
-            min: [bbox.min.x, bbox.min.y, bbox.min.z],
-            max: [bbox.max.x, bbox.max.y, bbox.max.z]
-          }
-        });
-      }
+  componentObject.traverse(function (child) {
+    var _child$userData;
+    if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) !== 'io-device') return;
+    var bbox = new THREE__namespace.Box3().setFromObject(child);
+    var worldPos = new THREE__namespace.Vector3();
+    child.getWorldPosition(worldPos);
+    if (!bbox.isEmpty()) {
+      results.push({
+        uuid: child.uuid,
+        userData: {
+          objectType: 'io-device',
+          deviceId: child.userData.deviceId || null,
+          attachmentId: child.userData.attachmentId || null,
+          parentComponentId: child.userData.parentComponentId || componentObject.uuid,
+          // Sync position for pathfinder
+          position: [worldPos.x, worldPos.y, worldPos.z]
+        },
+        worldBoundingBox: {
+          min: [bbox.min.x, bbox.min.y, bbox.min.z],
+          max: [bbox.max.x, bbox.max.y, bbox.max.z]
+        }
+      });
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
+  });
   return results;
 }
 
 /**
  * Computes individual world-space bounding boxes for each connector child
- * of a component.
+ * of a component. Supports deep children (e.g. within GLB model hierarchy).
  * 
  * @param {THREE.Object3D} componentObject - The component's Three.js object
  * @returns {Array<{uuid: string, userData: Object, worldBoundingBox: {min: number[], max: number[]}}>}
@@ -3762,38 +3757,40 @@ function computeIODeviceBoundingBoxes(componentObject) {
  */
 function computeConnectorBoundingBoxes(componentObject) {
   var results = [];
-  var _iterator2 = _createForOfIteratorHelper(componentObject.children),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var _child$userData2;
-      var child = _step2.value;
-      if (((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.objectType) !== 'connector') continue;
-      var bbox = new THREE__namespace.Box3().setFromObject(child);
-
-      // Fallback if mesh is too small or empty (sometimes connectors are just points)
-      if (bbox.isEmpty() || bbox.getSize(new THREE__namespace.Vector3()).length() < 0.01) {
-        var worldPos = new THREE__namespace.Vector3();
-        child.getWorldPosition(worldPos);
-        var size = 0.1;
-        bbox.setFromCenterAndSize(worldPos, new THREE__namespace.Vector3(size, size, size));
+  componentObject.traverse(function (child) {
+    var _child$userData2;
+    if (((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.objectType) !== 'connector') return;
+    var bbox = new THREE__namespace.Box3().setFromObject(child);
+    var worldPos = new THREE__namespace.Vector3();
+    child.getWorldPosition(worldPos);
+
+    // Compute world-space direction vector (Crucial for rotation-aware pathfinding)
+    // Default to [0, 0, 1] if not specified (Standard for our coordinate system)
+    var localDirData = child.userData && Array.isArray(child.userData.direction) ? child.userData.direction : [0, 0, 1];
+    var localDir = new THREE__namespace.Vector3(localDirData[0], localDirData[1], localDirData[2]);
+    var worldQuat = new THREE__namespace.Quaternion();
+    child.getWorldQuaternion(worldQuat);
+    var worldDir = localDir.clone().applyQuaternion(worldQuat).normalize();
+
+    // Fallback if mesh is too small or empty (sometimes connectors are just points)
+    if (bbox.isEmpty() || bbox.getSize(new THREE__namespace.Vector3()).length() < 0.01) {
+      var size = 0.1;
+      bbox.setFromCenterAndSize(worldPos, new THREE__namespace.Vector3(size, size, size));
+    }
+    results.push({
+      uuid: child.uuid,
+      userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+        objectType: 'connector',
+        // Update both position AND direction for pathfinder
+        position: [worldPos.x, worldPos.y, worldPos.z],
+        direction: [worldDir.x, worldDir.y, worldDir.z]
+      }),
+      worldBoundingBox: {
+        min: [bbox.min.x, bbox.min.y, bbox.min.z],
+        max: [bbox.max.x, bbox.max.y, bbox.max.z]
       }
-      results.push({
-        uuid: child.uuid,
-        userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-          objectType: 'connector'
-        }),
-        worldBoundingBox: {
-          min: [bbox.min.x, bbox.min.y, bbox.min.z],
-          max: [bbox.max.x, bbox.max.y, bbox.max.z]
-        }
-      });
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
-  }
+    });
+  });
   return results;
 }
 
@@ -3893,11 +3890,11 @@ function createSelectionBoxHelpers(object) {
  * @param {THREE.Scene} scene - The scene (for finding objects by uuid)
  */
 function updateSelectionBoxHelpers(helpers, selectedObjects, scene) {
-  var _iterator3 = _createForOfIteratorHelper(helpers),
-    _step3;
+  var _iterator = _createForOfIteratorHelper(helpers),
+    _step;
   try {
     var _loop = function _loop() {
-      var helper = _step3.value;
+      var helper = _step.value;
       var _helper$userData = helper.userData,
         sourceObjectUuid = _helper$userData.sourceObjectUuid,
         isFiltered = _helper$userData.isFiltered,
@@ -3928,13 +3925,13 @@ function updateSelectionBoxHelpers(helpers, selectedObjects, scene) {
         helper.update();
       }
     };
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
       if (_loop()) continue;
     }
   } catch (err) {
-    _iterator3.e(err);
+    _iterator.e(err);
   } finally {
-    _iterator3.f();
+    _iterator.f();
   }
 }
 
@@ -3974,7 +3971,7 @@ var TransformControlsManager = /*#__PURE__*/function () {
     this.forceInvisible = false;
 
     // SceneViewer reference for event listening
-    this.sceneViewer = null;
+    this.sceneViewer = centralPlant ? centralPlant.sceneViewer : null;
     this._objectTransformedListener = null;
 
     // Event handlers storage
@@ -4176,23 +4173,28 @@ var TransformControlsManager = /*#__PURE__*/function () {
         _this2.transformState.isTransforming = true;
 
         // Store initial transforms for all selected objects
-        if (_this2.selectedObjects.length > 0 && _this2.multiSelectionGroup) {
+        if (_this2.selectedObjects.length > 0) {
           _this2.selectedObjects.forEach(function (obj) {
-            obj.userData._multiSelectOriginalPosition = obj.position.clone();
-            obj.userData._multiSelectOriginalRotation = obj.rotation.clone();
-            obj.userData._multiSelectOriginalScale = obj.scale.clone();
-          });
-
-          // Snapshot group position and helper geometry vertices so we can do
-          // cheap per-frame bbox translation without re-traversing the mesh hierarchy.
-          _this2._dragStartGroupPosition = _this2.multiSelectionGroup.position.clone();
-          _this2.boundingBoxHelpers.forEach(function (helper) {
-            var _helper$geometry;
-            var posAttr = (_helper$geometry = helper.geometry) === null || _helper$geometry === void 0 || (_helper$geometry = _helper$geometry.attributes) === null || _helper$geometry === void 0 ? void 0 : _helper$geometry.position;
-            if (posAttr) {
-              helper.userData._dragStartPositions = new Float32Array(posAttr.array);
+            obj.userData._dragStartRotation = obj.rotation.clone();
+            obj.userData._dragStartPosition = obj.position.clone();
+            if (_this2.multiSelectionGroup) {
+              obj.userData._multiSelectOriginalPosition = obj.position.clone();
+              obj.userData._multiSelectOriginalRotation = obj.rotation.clone();
+              obj.userData._multiSelectOriginalScale = obj.scale.clone();
             }
           });
+          if (_this2.multiSelectionGroup) {
+            // Snapshot group position and helper geometry vertices so we can do
+            // cheap per-frame bbox translation without re-traversing the mesh hierarchy.
+            _this2._dragStartGroupPosition = _this2.multiSelectionGroup.position.clone();
+            _this2.boundingBoxHelpers.forEach(function (helper) {
+              var _helper$geometry;
+              var posAttr = (_helper$geometry = helper.geometry) === null || _helper$geometry === void 0 || (_helper$geometry = _helper$geometry.attributes) === null || _helper$geometry === void 0 ? void 0 : _helper$geometry.position;
+              if (posAttr) {
+                helper.userData._dragStartPositions = new Float32Array(posAttr.array);
+              }
+            });
+          }
         }
 
         // Disable orbit controls during transformation
@@ -4209,7 +4211,7 @@ var TransformControlsManager = /*#__PURE__*/function () {
 
       // Transform end event
       this.eventHandlers.transformEnd = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
-        var hasComponents, _this2$selectedObject, sceneCompleteEvent;
+        var isTranslate, isRotate, hasComponents, _this2$selectedObject, sceneCompleteEvent;
         return _regenerator().w(function (_context) {
           while (1) switch (_context.n) {
             case 0:
@@ -4231,29 +4233,52 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 console.error('❌ Error in applyMultiSelectionTransform:', error);
               });
             case 1:
-              // applyMultiSelectionTransform() already calls updatePaths() once at the end
-              // so we skip the additional updatePaths() call below
-              console.log('✅ Multi-selection transform complete (updatePaths already called)');
+              console.log('✅ Multi-selection transform complete');
               _context.n = 3;
               break;
             case 2:
-              if (_this2.currentMode === 'translate' && _this2.sceneViewer && typeof _this2.sceneViewer.updatePaths === 'function') {
-                // Update paths after translation is complete
-                // Only if we translated components (not segments/gateways - they handle paths internally)
-                // This branch only executes when NOT in multi-selection mode
-                hasComponents = _this2.selectedObjects.some(function (obj) {
-                  return !isSegment(obj) && !isGateway(obj);
-                });
-                if (hasComponents) {
-                  console.log('🔄 Updating paths after component translation...');
-                  try {
-                    _this2.sceneViewer.updatePaths();
-                    console.log('✅ Paths updated successfully after translation');
-                  } catch (error) {
-                    console.error('❌ Error updating paths after translation:', error);
+              if (_this2.sceneViewer && typeof _this2.sceneViewer.updatePaths === 'function') {
+                // Update paths after transformation is complete (translation or rotation)
+                isTranslate = _this2.currentMode === 'translate';
+                isRotate = _this2.currentMode === 'rotate';
+                if (isTranslate || isRotate) {
+                  hasComponents = _this2.selectedObjects.some(function (obj) {
+                    return !isSegment(obj) && !isGateway(obj);
+                  });
+                  if (hasComponents) {
+                    console.log("\uD83D\uDD04 Updating paths after component ".concat(_this2.currentMode, "..."));
+                    try {
+                      // Ensure scene data is synced before updating paths
+                      _this2.selectedObjects.forEach(function (obj) {
+                        var _obj$userData;
+                        if (((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'component') {
+                          var _this2$sceneViewer$ma;
+                          var transformMgr = (_this2$sceneViewer$ma = _this2.sceneViewer.managers) === null || _this2$sceneViewer$ma === void 0 ? void 0 : _this2$sceneViewer$ma.transformOperationsManager;
+                          if (transformMgr) {
+                            if (isTranslate) {
+                              transformMgr.updateComponentPositionInSceneData(obj);
+                            }
+                            if (isRotate) {
+                              transformMgr.updateComponentRotationInSceneData(obj);
+
+                              // Calculate rotation delta for direction vector patching
+                              var startRot = obj.userData._dragStartRotation || obj.rotation;
+                              var deltaRad = obj.rotation.z - startRot.z;
+                              var deltaDeg = Math.round(THREE__namespace.MathUtils.radToDeg(deltaRad) / 90) * 90;
+                              if (deltaDeg !== 0) {
+                                console.log("\uD83E\uDDED Patching connector directions by ".concat(deltaDeg, " degrees after gizmo rotation"));
+                                transformMgr.updateConnectorDirections(obj, 'z', deltaDeg);
+                              }
+                            }
+                          }
+                        }
+                      });
+                      _this2.sceneViewer.updatePaths();
+                      console.log("\u2705 Paths updated successfully after ".concat(_this2.currentMode));
+                    } catch (error) {
+                      console.error("\u274C Error updating paths after ".concat(_this2.currentMode, ":"), error);
+                    }
                   }
-                } else {
-                  console.log('ℹ️ Skipping updatePaths - segments/gateways handle their own path updates');
                 }
               }
             case 3:
@@ -4384,8 +4409,8 @@ var TransformControlsManager = /*#__PURE__*/function () {
             var hit = _step.value;
             var _obj = hit.object;
             while (_obj) {
-              var _obj$userData2;
-              if (((_obj$userData2 = _obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.objectType) === 'io-device') {
+              var _obj$userData3;
+              if (((_obj$userData3 = _obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.objectType) === 'io-device') {
                 ioDeviceObject = _obj;
                 break;
               }
@@ -4408,8 +4433,8 @@ var TransformControlsManager = /*#__PURE__*/function () {
         var parentUuid = null;
         var obj = ioDeviceObject.parent;
         while (obj) {
-          var _obj$userData;
-          if (((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'component') {
+          var _obj$userData2;
+          if (((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.objectType) === 'component') {
             parentUuid = obj.userData.originalUuid || obj.uuid;
             break;
           }
@@ -4486,8 +4511,8 @@ var TransformControlsManager = /*#__PURE__*/function () {
               var hit = _step2.value;
               var obj = hit.object;
               while (obj) {
-                var _obj$userData3;
-                if (((_obj$userData3 = obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.objectType) === 'io-device') {
+                var _obj$userData4;
+                if (((_obj$userData4 = obj.userData) === null || _obj$userData4 === void 0 ? void 0 : _obj$userData4.objectType) === 'io-device') {
                   _this4.callbacks.onIODeviceClick(obj);
                   return;
                 }
@@ -6148,8 +6173,8 @@ var TransformControlsManager = /*#__PURE__*/function () {
     key: "_updateSegmentReference",
     value: function _updateSegmentReference(oldSegment, newSegment, index) {
       var selectedIndex = this.selectedObjects.findIndex(function (obj) {
-        var _obj$userData4;
-        return obj.uuid === oldSegment.uuid || ((_obj$userData4 = obj.userData) === null || _obj$userData4 === void 0 ? void 0 : _obj$userData4.originalUuid) === oldSegment.uuid;
+        var _obj$userData5;
+        return obj.uuid === oldSegment.uuid || ((_obj$userData5 = obj.userData) === null || _obj$userData5 === void 0 ? void 0 : _obj$userData5.originalUuid) === oldSegment.uuid;
       });
       if (selectedIndex !== -1 && newSegment) {
         // Clear bounding box cache
@@ -6257,7 +6282,7 @@ var TransformControlsManager = /*#__PURE__*/function () {
               componentId = component.uuid || ((_component$userData = component.userData) === null || _component$userData === void 0 ? void 0 : _component$userData.originalUuid);
               _context6.n = 3;
               return this._translateObjectOnAxes(componentId, deltaX, deltaY, deltaZ, threshold, throttleDelay, AXIS_THROTTLE, function (id, axis, delta) {
-                return _this0.centralPlant.translate(id, axis, delta);
+                return _this0.centralPlant.translate(id, axis, delta, true);
               });
             case 3:
               console.log("\uD83D\uDD27 Component ".concat(component.name, " translated (").concat(i + 1, "/").concat(components.length, ")"));
@@ -6356,6 +6381,17 @@ var TransformControlsManager = /*#__PURE__*/function () {
       if (this.selectedObjects.length > 0) {
         this.updateMultiSelection();
       }
+
+      // Trigger pathfinding update once after all objects in the batch are translated
+      if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
+        var hasComponentsOrSegments = this.selectedObjects.some(function (obj) {
+          return !isGateway(obj);
+        });
+        if (hasComponentsOrSegments) {
+          console.log('🔄 Triggering batched pathfinding update after multi-object translation...');
+          this.sceneViewer.updatePaths();
+        }
+      }
       console.log("\u2705 Multi-selection transform applied");
     }
 
@@ -11881,6 +11917,11 @@ var SceneExportManager = /*#__PURE__*/function () {
       // Helper function to convert Three.js object to minimal JSON format
       var convertObjectToJson = function convertObjectToJson(threeObject) {
         var _threeObject$name, _threeObject$userData, _threeObject$userData2, _threeObject$userData3, _threeObject$userData4, _threeObject$userData5, _threeObject$userData6, _threeObject$userData7, _threeObject$userData8, _threeObject$userData9, _threeObject$userData0, _threeObject$userData1, _threeObject$userData10;
+        // Ensure world matrices are updated for this subtree before exporting
+        if (threeObject.updateMatrixWorld) {
+          threeObject.updateMatrixWorld(true);
+        }
+
         // Skip certain objects that shouldn't be exported
         if (!threeObject || (_threeObject$name = threeObject.name) !== null && _threeObject$name !== void 0 && _threeObject$name.includes('Polyline') ||
         // Skip pipe paths
@@ -12038,19 +12079,23 @@ var SceneExportManager = /*#__PURE__*/function () {
               }
             });
           } else if (((_threeObject$userData11 = threeObject.userData) === null || _threeObject$userData11 === void 0 ? void 0 : _threeObject$userData11.objectType) === 'component') {
-            // For components, only export connectors that have objectType='connector'
-            // Standard dictionary-injected connectors should be exported so connections work on re-import
-            threeObject.children.forEach(function (child) {
+            // For components, export all connectors (including deep children within GLFs)
+            threeObject.traverse(function (child) {
               var _child$userData2;
               if (((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.objectType) === 'connector') {
+                // Calculate position relative to component root
+                var componentMatrixWorldInverse = threeObject.matrixWorld.clone().invert();
+                var childWorldPos = new THREE__namespace.Vector3();
+                child.getWorldPosition(childWorldPos);
+                var relativePos = childWorldPos.applyMatrix4(componentMatrixWorldInverse);
                 exportableChildren.push({
                   uuid: child.uuid,
                   name: child.name,
                   type: 'Mesh',
                   position: {
-                    x: roundIfClose(child.position.x),
-                    y: roundIfClose(child.position.y),
-                    z: roundIfClose(child.position.z)
+                    x: roundIfClose(relativePos.x),
+                    y: roundIfClose(relativePos.y),
+                    z: roundIfClose(relativePos.z)
                   },
                   userData: _objectSpread2({}, child.userData)
                 });
@@ -19901,7 +19946,7 @@ var ComponentManager = /*#__PURE__*/function () {
     key: "addComponentToScene",
     value: (function () {
       var _addComponentToScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(componentData) {
-        var _gltfScene$userData, uuid, componentDictionary, libraryComponent, position, gltfScene, componentMesh, event, _t, _t2;
+        var _gltfScene$userData, uuid, componentDictionary, libraryComponent, position, gltfScene, componentMesh, connectorIndex, event, _t, _t2;
         return _regenerator().w(function (_context) {
           while (1) switch (_context.n) {
             case 0:
@@ -20005,6 +20050,7 @@ var ComponentManager = /*#__PURE__*/function () {
               }
 
               // Enable shadows for all meshes in the component
+              connectorIndex = 0;
               componentMesh.traverse(function (child) {
                 if (child.isMesh) {
                   child.castShadow = true;
@@ -20014,12 +20060,19 @@ var ComponentManager = /*#__PURE__*/function () {
                   }
 
                   // Set connector properties for connectors within the component
-                  if (child.name && child.name.toLowerCase().includes('connector')) {
+                  if (child.name && child.name.toLowerCase().includes('connector') || child.userData && child.userData.objectType === 'connector') {
+                    connectorIndex++;
                     if (!child.userData) {
                       child.userData = {};
                     }
                     child.userData.objectType = 'connector';
-                    console.log("\uD83D\uDD27 Set objectType='connector' for: ".concat(child.name));
+
+                    // Assign a predictable, stable UUID to the connector
+                    // This ensures connections made in the sandbox survive export/import
+                    var connectorUuid = "".concat(uuid, "-CONNECTOR-").concat(connectorIndex);
+                    child.uuid = connectorUuid;
+                    child.userData.originalUuid = connectorUuid;
+                    console.log("\uD83D\uDD27 Set predictable connector UUID: ".concat(connectorUuid, " for: ").concat(child.name));
                   }
                 }
               });
@@ -21214,12 +21267,14 @@ var TransformOperationsManager = /*#__PURE__*/function () {
    * @param {string} componentId - The UUID of the component to translate
    * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
    * @param {number} value - The value to translate by
+   * @param {boolean} [skipPathUpdate=false] - Whether to skip triggering pathfinding after translation
    * @returns {boolean} True if translation was successful, false otherwise
    */
   return _createClass(TransformOperationsManager, [{
     key: "translateComponent",
     value: function translateComponent(componentId, axis, value) {
       var _this$sceneViewer$man, _this$sceneViewer;
+      var skipPathUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
       // Store transform parameters using the OperationHistoryManager
       if ((_this$sceneViewer$man = this.sceneViewer.managers) !== null && _this$sceneViewer$man !== void 0 && _this$sceneViewer$man.operationHistoryManager) {
         this.sceneViewer.managers.operationHistoryManager.addToOperationHistory('translateComponent', {
@@ -21287,7 +21342,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       }
 
       // Auto-update paths if enabled (matches behavior of translateSegment and translateGateway)
-      if (this.sceneViewer.shouldUpdatePaths) {
+      if (!skipPathUpdate && this.sceneViewer.shouldUpdatePaths) {
         try {
           if (this.sceneViewer && typeof this.sceneViewer.updatePaths === 'function') {
             this.sceneViewer.updatePaths();
@@ -21298,6 +21353,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         } catch (error) {
           console.error('❌ Error auto-updating paths:', error);
         }
+      } else if (skipPathUpdate) {
+        console.log('ℹ️ skipPathUpdate is true: skipping automatic path update');
       }
 
       // Emit transform event if available
@@ -23116,11 +23173,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           sceneDataComponent.children.forEach(function (child) {
             var _child$userData21;
             if (((_child$userData21 = child.userData) === null || _child$userData21 === void 0 ? void 0 : _child$userData21.objectType) === 'connector') {
-              // Find the actual connector object in the scene
-              var connectorObj = component.children.find(function (c) {
-                var _c$userData;
-                return c.uuid === child.uuid || ((_c$userData = c.userData) === null || _c$userData === void 0 ? void 0 : _c$userData.originalUuid) === child.uuid;
-              });
+              // Find the actual connector object in the scene (recursive search for nested connectors)
+              var connectorObj = component.getObjectByProperty('uuid', child.uuid) || component.getObjectByProperty('name', child.uuid);
               if (connectorObj) {
                 // Get world position of connector
                 var worldPos = new THREE__namespace.Vector3();
@@ -23179,11 +23233,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           sceneDataComponent.children.forEach(function (child) {
             var _child$userData22;
             if (((_child$userData22 = child.userData) === null || _child$userData22 === void 0 ? void 0 : _child$userData22.objectType) === 'connector') {
-              // Find the actual connector object in the scene
-              var connectorObj = component.children.find(function (c) {
-                var _c$userData2;
-                return c.uuid === child.uuid || ((_c$userData2 = c.userData) === null || _c$userData2 === void 0 ? void 0 : _c$userData2.originalUuid) === child.uuid;
-              });
+              // Find the actual connector object in the scene (recursive search for nested connectors)
+              var connectorObj = component.getObjectByProperty('uuid', child.uuid) || component.getObjectByProperty('name', child.uuid);
               if (connectorObj) {
                 var _connectorObj$userDat;
                 // Get world position of connector
@@ -29109,10 +29160,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_matrixHash",
     value: function _matrixHash(obj) {
+      // Force matrix update to ensure we're looking at the latest data
+      obj.updateMatrixWorld(true);
       var e = obj.matrixWorld.elements;
-      // Use position (12-14) + first diagonal entries (0,5,10) — covers
-      // translation AND rotation/scale changes with minimal work.
-      return "".concat(e[0].toFixed(5), ",").concat(e[5].toFixed(5), ",").concat(e[10].toFixed(5), ",").concat(e[12].toFixed(5), ",").concat(e[13].toFixed(5), ",").concat(e[14].toFixed(5));
+      // Just hash the position/rotation/scale part of the matrix (12 elements)
+      return "".concat(e[0].toFixed(3), ",").concat(e[1].toFixed(3), ",").concat(e[2].toFixed(3), ",").concat(e[4].toFixed(3), ",").concat(e[5].toFixed(3), ",").concat(e[6].toFixed(3), ",").concat(e[8].toFixed(3), ",").concat(e[9].toFixed(3), ",").concat(e[10].toFixed(3), ",").concat(e[12].toFixed(3), ",").concat(e[13].toFixed(3), ",").concat(e[14].toFixed(3));
     }
 
     /**
@@ -29130,11 +29182,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
      * Compute a lightweight fingerprint of the pathfinding inputs so that
      * consecutive identical runs can be skipped entirely.
      *
-     * The fingerprint captures:
-     *  • The connections list (from / to pairs)
-     *  • The world transform of every top-level child in sceneData
-     *
-     * @param {Object} sceneData  - scene data object with .children
+     * @param {Object} sceneData  - scene object or manifest
      * @param {Array}  connections - array of {from, to}
      * @returns {string}
      * @private
@@ -29142,277 +29190,241 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_computePathfindingFingerprint",
     value: function _computePathfindingFingerprint(sceneData, connections) {
+      var _this3 = this;
       var parts = [];
 
       // 1. Connections (sorted so order doesn't matter)
-      parts.push(connections.map(function (c) {
+      parts.push((connections || []).map(function (c) {
         return "".concat(c.from, "->").concat(c.to);
       }).sort().join(','));
 
-      // 2. World transforms of every referenced scene object
-      if (sceneData.children) {
-        var _iterator = _createForOfIteratorHelper(sceneData.children),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var child = _step.value;
-            var obj = this.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
-            if (obj) {
-              parts.push("".concat(child.uuid, ":").concat(this._matrixHash(obj)));
-            } else {
-              var _p$x, _p$y, _p$z;
-              // Object only in data, not in scene — include its serialised position
-              var p = child.position || {};
-              parts.push("".concat(child.uuid, ":").concat(((_p$x = p.x) !== null && _p$x !== void 0 ? _p$x : 0).toFixed(5), ",").concat(((_p$y = p.y) !== null && _p$y !== void 0 ? _p$y : 0).toFixed(5), ",").concat(((_p$z = p.z) !== null && _p$z !== void 0 ? _p$z : 0).toFixed(5)));
-            }
+      // 2. World transforms of every referenced scene object (recursive)
+      var _addTransformsRecursive = function addTransformsRecursive(node) {
+        if (node.uuid) {
+          var obj = _this3.sceneViewer.scene.getObjectByProperty('uuid', node.uuid);
+          if (obj) {
+            parts.push("".concat(node.uuid, ":").concat(_this3._matrixHash(obj)));
+          } else {
+            var _p$x, _p$y, _p$z;
+            // Object only in data, not in scene — include its serialised position
+            var p = node.position || {};
+            parts.push("".concat(node.uuid, ":").concat(((_p$x = p.x) !== null && _p$x !== void 0 ? _p$x : 0).toFixed(5), ",").concat(((_p$y = p.y) !== null && _p$y !== void 0 ? _p$y : 0).toFixed(5), ",").concat(((_p$z = p.z) !== null && _p$z !== void 0 ? _p$z : 0).toFixed(5)));
           }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
         }
+
+        // Handle both flattened array and nested Three.js JSON structures
+        var children = node.children || node.object && node.object.children;
+        if (children && Array.isArray(children)) {
+          children.forEach(_addTransformsRecursive);
+        }
+      };
+      if (sceneData) {
+        _addTransformsRecursive(sceneData);
       }
       return parts.join('|');
     }
 
     /**
-     * Enrich sceneData with worldBoundingBox for segments and components
-     * Connectors remain with just position information.
-     *
-     * Uses _bboxCache to avoid recomputing filtered / io-device bboxes
-     * when the underlying object's world matrix has not changed.
-     *
-     * @param {Object} sceneData - Original scene data
-     * @returns {Object} Enriched scene data (shallow copy with modifications)
+     * Enrich scene data with world-space bounding boxes and positions for collision avoidance
+     * @param {Object|Array} sceneData - Original scene data or array of children
+     * @returns {Object|Array} Enriched scene data (shallow copy with modifications)
      * @private
      */
   }, {
     key: "_enrichSceneDataWithBoundingBoxes",
     value: function _enrichSceneDataWithBoundingBoxes(sceneData) {
-      var _this3 = this;
-      // Create a shallow copy of sceneData structure
-      var enriched = _objectSpread2({}, sceneData);
-      if (!sceneData.children || !Array.isArray(sceneData.children)) {
-        console.warn('⚠️ sceneData has no children array');
-        return enriched;
-      }
-
-      // Process children to add worldBoundingBox to segments and components
-      enriched.children = sceneData.children.map(function (child) {
-        // Enrich segments (check if objectType is 'segment' in userData)
-        if (child.userData && child.userData.objectType === 'segment') {
-          // Find the actual segment object in the scene
-          var segmentObject = _this3.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
+      var _this4 = this;
+      if (!sceneData) return sceneData;
+
+      // Recursive helper to enrich a node and its children
+      var _enrichNode = function enrichNode(node) {
+        if (!node) return node;
+        var enrichedNode = _objectSpread2({}, node);
+
+        // Skip computed objects ( elbows etc )
+        if (node.userData && (node.userData.isComputed === true || node.userData.objectType === 'elbow')) {
+          return node;
+        }
+
+        // ── Enrich Segments ──
+        if (node.userData && node.userData.objectType === 'segment') {
+          var segmentObject = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.uuid);
           if (segmentObject) {
-            // ── Cache check ──
-            var hash = _this3._matrixHash(segmentObject);
-            var cached = _this3._bboxCache.get(child.uuid);
+            var hash = _this4._matrixHash(segmentObject);
+            var cached = _this4._bboxCache.get(node.uuid);
             if (cached && cached.matrixHash === hash && cached.segmentBBox) {
-              return _objectSpread2(_objectSpread2({}, child), {}, {
-                userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-                  worldBoundingBox: cached.segmentBBox
-                })
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+                worldBoundingBox: cached.segmentBBox
               });
-            }
-
-            // Compute world bounding box
-            var worldBBox = new THREE__namespace.Box3().setFromObject(segmentObject);
-            var bboxData = {
-              min: [worldBBox.min.x, worldBBox.min.y, worldBBox.min.z],
-              max: [worldBBox.max.x, worldBBox.max.y, worldBBox.max.z]
-            };
-
-            // Store in cache
-            _this3._bboxCache.set(child.uuid, {
-              matrixHash: hash,
-              segmentBBox: bboxData
-            });
-            return _objectSpread2(_objectSpread2({}, child), {}, {
-              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+            } else {
+              var worldBBox = new THREE__namespace.Box3().setFromObject(segmentObject);
+              var bboxData = {
+                min: [worldBBox.min.x, worldBBox.min.y, worldBBox.min.z],
+                max: [worldBBox.max.x, worldBBox.max.y, worldBBox.max.z]
+              };
+              _this4._bboxCache.set(node.uuid, {
+                matrixHash: hash,
+                segmentBBox: bboxData
+              });
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
                 worldBoundingBox: bboxData
-              })
-            });
-          } else {
-            console.warn("\u26A0\uFE0F Could not find segment object in scene: ".concat(child.uuid));
+              });
+            }
           }
         }
 
-        // Enrich components (check if objectType is 'component' in userData)
-        if (child.userData && child.userData.objectType === 'component') {
-          // Find the actual component object in the scene
-          var componentObject = _this3.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
+        // ── Enrich Components ──
+        else if (node.userData && node.userData.objectType === 'component') {
+          var componentObject = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.uuid);
           if (componentObject) {
-            // ── Cache check ──
-            var _hash = _this3._matrixHash(componentObject);
-            var _cached = _this3._bboxCache.get(child.uuid);
+            componentObject.updateMatrixWorld(true);
+            var _hash = _this4._matrixHash(componentObject);
+            var _cached = _this4._bboxCache.get(node.uuid);
             if (_cached && _cached.matrixHash === _hash && _cached.filteredBBox) {
-              // Rebuild enriched child from cached data
-              var _enrichedChild = _objectSpread2(_objectSpread2({}, child), {}, {
-                userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-                  worldBoundingBox: _cached.filteredBBox
-                })
+              enrichedNode.position = {
+                x: componentObject.position.x,
+                y: componentObject.position.y,
+                z: componentObject.position.z
+              };
+              enrichedNode.rotation = {
+                x: THREE__namespace.MathUtils.radToDeg(componentObject.rotation.x),
+                y: THREE__namespace.MathUtils.radToDeg(componentObject.rotation.y),
+                z: THREE__namespace.MathUtils.radToDeg(componentObject.rotation.z)
+              };
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+                worldBoundingBox: _cached.filteredBBox,
+                position: [componentObject.position.x, componentObject.position.y, componentObject.position.z]
               });
-              if (_cached.ioDeviceBBoxes && _cached.ioDeviceBBoxes.length > 0) {
-                if (!_enrichedChild.children) _enrichedChild.children = [];
-                _cached.ioDeviceBBoxes.forEach(function (deviceBBox) {
-                  var existingIndex = _enrichedChild.children.findIndex(function (c) {
-                    return c.uuid === deviceBBox.uuid;
-                  });
-                  if (existingIndex >= 0) {
-                    _enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex]), {}, {
-                      userData: _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex].userData), {}, {
-                        objectType: 'io-device',
-                        worldBoundingBox: deviceBBox.worldBoundingBox
-                      })
-                    });
-                  } else {
-                    _enrichedChild.children.push({
-                      uuid: deviceBBox.uuid,
-                      userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
-                        worldBoundingBox: deviceBBox.worldBoundingBox
-                      }),
-                      children: []
-                    });
-                  }
+
+              // Re-merge cached connectors and devices if they exist
+              if (!enrichedNode.children) enrichedNode.children = [];
+              if (_cached.connectorBBoxes) {
+                _cached.connectorBBoxes.forEach(function (conn) {
+                  return _this4._mergeEnrichedChild(enrichedNode.children, conn);
                 });
               }
-
-              // Also reinject connectors from cache
-              if (_cached.connectorBBoxes && _cached.connectorBBoxes.length > 0) {
-                if (!_enrichedChild.children) _enrichedChild.children = [];
-                _cached.connectorBBoxes.forEach(function (connBBox) {
-                  var existingIndex = _enrichedChild.children.findIndex(function (c) {
-                    return c.uuid === connBBox.uuid;
-                  });
-                  if (existingIndex >= 0) {
-                    _enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex]), {}, {
-                      userData: _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex].userData), {}, {
-                        worldBoundingBox: connBBox.worldBoundingBox
-                      })
-                    });
-                  } else {
-                    _enrichedChild.children.push({
-                      uuid: connBBox.uuid,
-                      userData: _objectSpread2(_objectSpread2({}, connBBox.userData), {}, {
-                        worldBoundingBox: connBBox.worldBoundingBox
-                      }),
-                      children: []
-                    });
-                  }
+              if (_cached.ioDeviceBBoxes) {
+                _cached.ioDeviceBBoxes.forEach(function (dev) {
+                  return _this4._mergeEnrichedChild(enrichedNode.children, dev);
                 });
               }
-              return _enrichedChild;
+            } else {
+              var filteredBBox = computeFilteredBoundingBox(componentObject, ['io-device', 'connector']);
+              var _bboxData = {
+                min: [filteredBBox.min.x, filteredBBox.min.y, filteredBBox.min.z],
+                max: [filteredBBox.max.x, filteredBBox.max.y, filteredBBox.max.z]
+              };
+              enrichedNode.position = {
+                x: componentObject.position.x,
+                y: componentObject.position.y,
+                z: componentObject.position.z
+              };
+              enrichedNode.rotation = {
+                x: THREE__namespace.MathUtils.radToDeg(componentObject.rotation.x),
+                y: THREE__namespace.MathUtils.radToDeg(componentObject.rotation.y),
+                z: THREE__namespace.MathUtils.radToDeg(componentObject.rotation.z)
+              };
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+                worldBoundingBox: _bboxData,
+                position: [componentObject.position.x, componentObject.position.y, componentObject.position.z]
+              });
+              var connectorBBoxes = computeConnectorBoundingBoxes(componentObject);
+              var ioDeviceBBoxes = computeIODeviceBoundingBoxes(componentObject);
+              if (!enrichedNode.children) enrichedNode.children = [];
+              connectorBBoxes.forEach(function (conn) {
+                return _this4._mergeEnrichedChild(enrichedNode.children, conn);
+              });
+              ioDeviceBBoxes.forEach(function (dev) {
+                return _this4._mergeEnrichedChild(enrichedNode.children, dev);
+              });
+              _this4._bboxCache.set(node.uuid, {
+                matrixHash: _hash,
+                filteredBBox: _bboxData,
+                ioDeviceBBoxes: ioDeviceBBoxes,
+                connectorBBoxes: connectorBBoxes
+              });
             }
+          }
+        }
 
-            // Compute FILTERED bounding box — excludes io-device and connector subtrees
-            // so the component body bbox is tight-fitting and doesn't envelop attached devices
-            var filteredBBox = computeFilteredBoundingBox(componentObject, ['io-device', 'connector']);
-            console.log("\uD83D\uDD04 Updated worldBoundingBox for component ".concat(child.uuid, " (filtered): min=[").concat(filteredBBox.min.x.toFixed(2), ", ").concat(filteredBBox.min.y.toFixed(2), ", ").concat(filteredBBox.min.z.toFixed(2), "], max=[").concat(filteredBBox.max.x.toFixed(2), ", ").concat(filteredBBox.max.y.toFixed(2), ", ").concat(filteredBBox.max.z.toFixed(2), "]"));
-            var _bboxData = {
-              min: [filteredBBox.min.x, filteredBBox.min.y, filteredBBox.min.z],
-              max: [filteredBBox.max.x, filteredBBox.max.y, filteredBBox.max.z]
+        // ── Enrich Standalone Objects (Gateways/Connectors) ──
+        else if (node.userData && (node.userData.objectType === 'gateway' || node.userData.objectType === 'connector')) {
+          var _node$userData;
+          var object = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.uuid) || _this4.sceneViewer.scene.getObjectByProperty('uuid', (_node$userData = node.userData) === null || _node$userData === void 0 ? void 0 : _node$userData.originalUuid);
+          if (object) {
+            var worldPos = new THREE__namespace.Vector3();
+            object.getWorldPosition(worldPos);
+            enrichedNode.position = {
+              x: worldPos.x,
+              y: worldPos.y,
+              z: worldPos.z
             };
-
-            // Build the enriched component entry
-            var enrichedChild = _objectSpread2(_objectSpread2({}, child), {}, {
-              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-                worldBoundingBox: _bboxData
-              })
+            enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+              position: [worldPos.x, worldPos.y, worldPos.z]
             });
 
-            // Compute separate bounding boxes for each attached io-device
-            var ioDeviceBBoxes = computeIODeviceBoundingBoxes(componentObject);
-            if (ioDeviceBBoxes.length > 0) {
-              // Ensure children array exists (may already contain connectors)
-              if (!enrichedChild.children) {
-                enrichedChild.children = [];
-              }
-
-              // Inject io-device entries with their own worldBoundingBox
-              ioDeviceBBoxes.forEach(function (deviceBBox) {
-                var existingIndex = enrichedChild.children.findIndex(function (c) {
-                  return c.uuid === deviceBBox.uuid;
-                });
-                if (existingIndex >= 0) {
-                  enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex]), {}, {
-                    userData: _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex].userData), {}, {
-                      objectType: 'io-device',
-                      worldBoundingBox: deviceBBox.worldBoundingBox
-                    })
-                  });
-                } else {
-                  enrichedChild.children.push({
-                    uuid: deviceBBox.uuid,
-                    userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
-                      worldBoundingBox: deviceBBox.worldBoundingBox
-                    }),
-                    children: []
-                  });
-                }
-                console.log("\uD83D\uDCE6 Injected io-device bbox for ".concat(deviceBBox.uuid, ": min=[").concat(deviceBBox.worldBoundingBox.min.map(function (v) {
-                  return v.toFixed(2);
-                }).join(', '), "], max=[").concat(deviceBBox.worldBoundingBox.max.map(function (v) {
-                  return v.toFixed(2);
-                }).join(', '), "]"));
-              });
-              console.log("\uD83D\uDCE6 Injected ".concat(ioDeviceBBoxes.length, " io-device bounding box(es) for component ").concat(child.uuid));
-            }
-
-            // PHASE 2: Enrich Connectors (CRITICAL for pathfinding API)
-            // Also compute world bounding boxes for connectors and inject into children.
-            // This ensures endpoints have world coordinates in sceneDataCopy.
-            var connectorBBoxes = computeConnectorBoundingBoxes(componentObject);
-            if (connectorBBoxes.length > 0) {
-              if (!enrichedChild.children) enrichedChild.children = [];
-              connectorBBoxes.forEach(function (connBBox) {
-                var existingIndex = enrichedChild.children.findIndex(function (c) {
-                  return c.uuid === connBBox.uuid;
-                });
-                if (existingIndex >= 0) {
-                  enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex]), {}, {
-                    userData: _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex].userData), {}, {
-                      worldBoundingBox: connBBox.worldBoundingBox
-                    })
-                  });
-                } else {
-                  enrichedChild.children.push({
-                    uuid: connBBox.uuid,
-                    userData: _objectSpread2(_objectSpread2({}, connBBox.userData), {}, {
-                      worldBoundingBox: connBBox.worldBoundingBox
-                    }),
-                    children: []
-                  });
-                }
-              });
+            // If it's a connector, also sync direction
+            if (node.userData.objectType === 'connector') {
+              var worldDir = new THREE__namespace.Vector3(0, 0, 1);
+              if (node.userData.direction) worldDir.set(node.userData.direction[0], node.userData.direction[1], node.userData.direction[2]);
+              worldDir.applyQuaternion(object.getWorldQuaternion(new THREE__namespace.Quaternion())).normalize();
+              enrichedNode.userData.direction = [worldDir.x, worldDir.y, worldDir.z];
             }
-
-            // Store in cache
-            _this3._bboxCache.set(child.uuid, {
-              matrixHash: _hash,
-              filteredBBox: _bboxData,
-              ioDeviceBBoxes: ioDeviceBBoxes,
-              connectorBBoxes: connectorBBoxes
-            });
-            return enrichedChild;
-          } else {
-            console.warn("\u26A0\uFE0F Could not find component object in scene: ".concat(child.uuid));
           }
         }
 
-        // For non-segments and non-components (including connectors), return as-is
-        return child;
-      });
-      return enriched;
+        // Recurse into children
+        if (node.children && Array.isArray(node.children)) {
+          enrichedNode.children = node.children.map(_enrichNode);
+        }
+        return enrichedNode;
+      };
+
+      // Handle root being an array or object
+      if (Array.isArray(sceneData)) {
+        return sceneData.map(_enrichNode);
+      } else if (sceneData.children && Array.isArray(sceneData.children)) {
+        var enrichedRoot = _objectSpread2({}, sceneData);
+        enrichedRoot.children = sceneData.children.map(_enrichNode);
+        return enrichedRoot;
+      } else {
+        return _enrichNode(sceneData);
+      }
     }
 
     /**
-     * Core pathfinding logic shared across initialization and updates
+     * Helper to merge an enriched child (connector/device) into a children array
+     * @private
      */
+  }, {
+    key: "_mergeEnrichedChild",
+    value: function _mergeEnrichedChild(childrenArray, enrichedData) {
+      var existingIndex = childrenArray.findIndex(function (c) {
+        return c.uuid === enrichedData.uuid;
+      });
+      var nodeToMerge = {
+        uuid: enrichedData.uuid,
+        position: {
+          x: enrichedData.userData.position[0],
+          y: enrichedData.userData.position[1],
+          z: enrichedData.userData.position[2]
+        },
+        userData: _objectSpread2(_objectSpread2({}, enrichedData.userData), {}, {
+          worldBoundingBox: enrichedData.worldBoundingBox
+        }),
+        children: []
+      };
+      if (existingIndex >= 0) {
+        childrenArray[existingIndex] = _objectSpread2(_objectSpread2({}, childrenArray[existingIndex]), nodeToMerge);
+      } else {
+        childrenArray.push(nodeToMerge);
+      }
+    }
   }, {
     key: "_executePathfinding",
-    value: (function () {
+    value: function () {
       var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(sceneData, connections) {
-        var _this4 = this,
+        var _this5 = this,
           _sceneDataCopy$childr,
           _sceneDataCopy$childr2,
           _pathfindingResult$pa,
@@ -29424,6 +29436,12 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           totalStart,
           inputGenStart,
           enrichedSceneData,
+          _from$userData,
+          _to$userData,
+          firstConn,
+          findEndpoint,
+          from,
+          to,
           connectionsCopy,
           sceneDataCopy,
           algoStart,
@@ -29440,6 +29458,10 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           while (1) switch (_context.n) {
             case 0:
               options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+              // Fallback to sceneData connections if not explicitly provided (e.g. during transform updates)
+              if (!connections && sceneData && sceneData.connections) {
+                connections = sceneData.connections;
+              }
               options.createGateways, _options$context = options.context, context = _options$context === void 0 ? 'Pathfinding' : _options$context;
               timers = {};
               totalStart = performance.now(); // Create pathfinder instance with configuration only
@@ -29468,7 +29490,50 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               console.log("\uD83D\uDD04 Updated matrix world for ".concat(context, " pathfinding execution"));
 
               // Enrich sceneData with worldBoundingBox for segments before deep copy
-              enrichedSceneData = this._enrichSceneDataWithBoundingBoxes(sceneData); // Deep copy connections and sceneData to prevent pathfinder from mutating the original
+              enrichedSceneData = this._enrichSceneDataWithBoundingBoxes(sceneData); // DEBUG: Log first connection endpoints in enriched data
+              if (connections && connections.length > 0 && enrichedSceneData.children) {
+                firstConn = connections[0];
+                findEndpoint = function findEndpoint(uuid) {
+                  var _iterator = _createForOfIteratorHelper(enrichedSceneData.children),
+                    _step;
+                  try {
+                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                      var child = _step.value;
+                      if (child.uuid === uuid) return child;
+                      if (child.children) {
+                        var _iterator2 = _createForOfIteratorHelper(child.children),
+                          _step2;
+                        try {
+                          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                            var nested = _step2.value;
+                            if (nested.uuid === uuid) return nested;
+                          }
+                        } catch (err) {
+                          _iterator2.e(err);
+                        } finally {
+                          _iterator2.f();
+                        }
+                      }
+                    }
+                  } catch (err) {
+                    _iterator.e(err);
+                  } finally {
+                    _iterator.f();
+                  }
+                  return null;
+                };
+                from = findEndpoint(firstConn.from);
+                to = findEndpoint(firstConn.to);
+                console.log("\uD83D\uDCE1 [DEBUG] Pathfinding from ".concat(firstConn.from, " to ").concat(firstConn.to));
+                if (from) console.log("   From BBox: min=[".concat((_from$userData = from.userData) === null || _from$userData === void 0 || (_from$userData = _from$userData.worldBoundingBox) === null || _from$userData === void 0 || (_from$userData = _from$userData.min) === null || _from$userData === void 0 ? void 0 : _from$userData.map(function (v) {
+                  return v.toFixed(2);
+                }), "]"));
+                if (to) console.log("   To BBox: min=[".concat((_to$userData = to.userData) === null || _to$userData === void 0 || (_to$userData = _to$userData.worldBoundingBox) === null || _to$userData === void 0 || (_to$userData = _to$userData.min) === null || _to$userData === void 0 ? void 0 : _to$userData.map(function (v) {
+                  return v.toFixed(2);
+                }), "]"));
+              }
+
+              // Deep copy connections and sceneData to prevent pathfinder from mutating the original
               connectionsCopy = structuredClone(connections);
               sceneDataCopy = structuredClone(enrichedSceneData);
               timers.inputGeneration = performance.now() - inputGenStart;
@@ -29499,7 +29564,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               if (pathfindingResult.paths) {
                 pathfindingResult.paths.forEach(function (path) {
                   var pathId = "".concat(path.from, "-->").concat(path.to);
-                  _this4._getOrCreatePathData(pathId, path.from, path.to);
+                  _this5._getOrCreatePathData(pathId, path.from, path.to);
                 });
               }
               timers.pathRendering = performance.now() - renderStart;
@@ -29532,7 +29597,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
         return _executePathfinding2.apply(this, arguments);
       }
       return _executePathfinding;
-    }())
+    }()
   }, {
     key: "getSimplifiedSceneData",
     value: function getSimplifiedSceneData() {
@@ -29571,7 +29636,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_propagateFlowAttributesAndApplyVisualizations",
     value: function _propagateFlowAttributesAndApplyVisualizations(connections, pathfindingResult) {
-      var _this5 = this,
+      var _this6 = this,
         _this$sceneViewer;
       if (!Array.isArray(connections) || !pathfindingResult) return;
 
@@ -29599,7 +29664,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
         var subPathIds = new Set(originalToSubPaths.get(origId) || []);
         subPathIds.add(origId);
         subPathIds.forEach(function (subPathId) {
-          var pd = _this5.pathDataStore.get(subPathId);
+          var pd = _this6.pathDataStore.get(subPathId);
           if (pd && Object.keys(pd.flowAttributes).length === 0) {
             Object.entries(conn.flowAttributes).forEach(function (_ref2) {
               var _ref3 = _slicedToArray(_ref2, 2),
@@ -29663,7 +29728,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "initializePathfinder",
     value: (function () {
       var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(data, crosscubeTextureSet) {
-        var _this6 = this;
+        var _this7 = this;
         var pathfindingResult;
         return _regenerator().w(function (_context2) {
           while (1) switch (_context2.n) {
@@ -29677,7 +29742,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
                 data.connections.forEach(function (conn) {
                   if (conn.flowAttributes && _typeof(conn.flowAttributes) === 'object') {
                     var pathId = "".concat(conn.from, "-->").concat(conn.to);
-                    var pd = _this6._getOrCreatePathData(pathId, conn.from, conn.to);
+                    var pd = _this7._getOrCreatePathData(pathId, conn.from, conn.to);
                     Object.entries(conn.flowAttributes).forEach(function (_ref6) {
                       var _ref7 = _slicedToArray(_ref6, 2),
                         key = _ref7[0],
@@ -29795,33 +29860,47 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "updatePathfindingAfterTransform",
     value: (function () {
       var _updatePathfindingAfterTransform = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(currentSceneData) {
-        var fingerprint, result;
+        var _currentSceneData$sce;
+        var fingerprint, dataRoot, connections, result;
         return _regenerator().w(function (_context3) {
           while (1) switch (_context3.n) {
             case 0:
+              if (!(!currentSceneData || !currentSceneData.scene)) {
+                _context3.n = 1;
+                break;
+              }
+              console.warn('⚠️ updatePathfindingAfterTransform: Invalid scene data');
+              return _context3.a(2, null);
+            case 1:
               // ── Skip-unchanged-paths check ──────────────────────────────────
               // Ensure matrices are fresh so the fingerprint is accurate.
               this.sceneViewer.scene.updateMatrixWorld(true);
               fingerprint = this._computePathfindingFingerprint(currentSceneData.scene, currentSceneData.connections);
+              console.log("\uD83D\uDD0D Pathfinding update check. Fingerprint: ".concat(fingerprint.substring(0, 50), "..."));
               if (!(fingerprint === this._lastPathfindingFingerprint && this._lastPathfindingResult)) {
-                _context3.n = 1;
+                _context3.n = 2;
                 break;
               }
               console.log('⏭️  Pathfinding skipped — inputs unchanged since last run');
               return _context3.a(2, this._lastPathfindingResult);
-            case 1:
+            case 2:
+              // Clear the cache for the specific fingerprint mismatch to ensure fresh enrichment
+              this.invalidateBBoxCache();
+
               // Remove all existing paths from the scene
               this.removeComputedObjects();
               console.log('🔄 Starting pathfinding with updated scene data...');
 
-              // Note: Matrix updates and bounding box recomputation now handled in _executePathfinding
+              // Robust root discovery for different manifest structures
+              dataRoot = ((_currentSceneData$sce = currentSceneData.scene) === null || _currentSceneData$sce === void 0 ? void 0 : _currentSceneData$sce.object) || currentSceneData.scene || currentSceneData;
+              connections = currentSceneData.connections || []; // Note: Matrix updates and bounding box recomputation now handled in _executePathfinding
               // Use shared pathfinding logic (no gateways needed for transform updates)
-              _context3.n = 2;
-              return this._executePathfinding(currentSceneData.scene, currentSceneData.connections, {
+              _context3.n = 3;
+              return this._executePathfinding(dataRoot, connections, {
                 createGateways: true,
                 context: 'Transform Update'
               });
-            case 2:
+            case 3:
               result = _context3.v;
               // Re-apply flow attribute colors (new materials are created on each execution)
               this._propagateFlowAttributesAndApplyVisualizations(currentSceneData.connections, result);
@@ -31727,36 +31806,58 @@ var ModelManager = /*#__PURE__*/function () {
      * @param {THREE.Object3D} targetMesh - The mesh whose connectors to preserve
      * @param {string} parentUuid - The UUID of the parent component
      */
+    /**
+     * Identifies all connector objects within a model hierarchy and prepares them
+     * to be preserved when the model is replaced or modified.
+     * Uses traverse() to find connectors at any depth in the hierarchy.
+     * @param {THREE.Object3D} targetMesh - The root of the model to search
+     * @param {string} parentUuid - The UUID of the parent component
+     * @returns {Array<THREE.Object3D>} Array of cloned and prepared connector objects
+     */
   }, {
     key: "_preserveConnectorChildren",
     value: function _preserveConnectorChildren(targetMesh, parentUuid) {
       var _this = this;
       var connectorChildren = [];
-      targetMesh.children.forEach(function (child, index) {
+      var connectorIndex = 0;
+
+      // Use traverse to find connectors at ANY depth in the hierarchy
+      targetMesh.traverse(function (child) {
         var _child$userData;
         var isConnectorGeometry = child.geometry && (child.geometry.uuid === 'CONNECTOR-GEO' || child.geometry.type === 'SphereGeometry' && child.geometry.parameters);
         var isConnectorByName = child.name && child.name.toLowerCase().includes('connector');
-        // Also recognise connectors declared via userData (e.g. inline connectors from SAMPLE_1.json
-        // whose geometry may be a fallback BufferGeometry rather than a SphereGeometry).
         var isConnectorByUserData = ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) === 'connector';
         if (isConnectorGeometry && isConnectorByName || isConnectorByUserData) {
+          connectorIndex++;
+
           // Ensure userData exists and has worldBoundingBox
           if (!child.userData) child.userData = {};
           if (!child.userData.worldBoundingBox) {
             child.userData.worldBoundingBox = _this._calculateWorldBoundingBox(child);
           }
 
-          // Clone and preserve critical userData
+          // Clone the connector
           var clonedConnector = child.clone();
 
-          // Generate proper connector UUID based on parent component UUID
-          // Format: COMPONENT-UUID-CONNECTOR-INDEX (matching JSON import pattern)
-          var connectorUuid = "".concat(parentUuid, "-CONNECTOR-").concat(index + 1);
+          // CRITICAL: Convert nested world position to root-relative position
+          // This ensures the connector stays in the same place when re-added as a direct child of targetMesh
+          var targetInverse = targetMesh.matrixWorld.clone().invert();
+          var worldPos = new THREE__namespace.Vector3();
+          child.getWorldPosition(worldPos);
+          clonedConnector.position.copy(worldPos.applyMatrix4(targetInverse));
+
+          // Get hardcoded UUID if it exists (e.g. from JSON mesh placeholder)
+          // This ensures compatibility with existing scene JSON naming conventions
+          var existingUuid = getHardcodedUuid(child);
+
+          // Generate fallback UUID only if existing one isn't already parent-prefixed
+          // Format: COMPONENT-UUID-CONNECTOR-INDEX (stable fallback)
+          var connectorUuid = existingUuid && existingUuid.includes(parentUuid) ? existingUuid : "".concat(parentUuid, "-CONNECTOR-").concat(connectorIndex);
           clonedConnector.uuid = connectorUuid;
           if (child.userData) {
             clonedConnector.userData = _objectSpread2({}, child.userData);
 
-            // Deep copy critical data - handle both array [x,y,z] and object {x,y,z} formats
+            // Deep copy critical data
             if (child.userData.worldBoundingBox) {
               var wbb = child.userData.worldBoundingBox;
               clonedConnector.userData.worldBoundingBox = {
@@ -31765,7 +31866,6 @@ var ModelManager = /*#__PURE__*/function () {
               };
             }
             if (child.userData.direction) {
-              // Handle both array [x,y,z] and object {x,y,z} formats
               if (Array.isArray(child.userData.direction)) {
                 clonedConnector.userData.direction = _toConsumableArray(child.userData.direction);
               } else if (_typeof(child.userData.direction) === 'object') {
@@ -31777,11 +31877,12 @@ var ModelManager = /*#__PURE__*/function () {
 
             // Set originalUuid to match the actual uuid (maintains consistency)
             clonedConnector.userData.originalUuid = connectorUuid;
-            clonedConnector.userData.objectType = child.userData.objectType || (child.name.toLowerCase().includes('connector') ? 'connector' : 'gateway');
+            clonedConnector.userData.objectType = child.userData.objectType || 'connector';
           }
           connectorChildren.push(clonedConnector);
         }
       });
+      console.log("\uD83D\uDEE1\uFE0F Preserved ".concat(connectorChildren.length, " connector(s) for component ").concat(parentUuid));
       return connectorChildren;
     }
 
@@ -34212,24 +34313,29 @@ var SceneOperationsManager = /*#__PURE__*/function () {
           children: [] // Initialize children array
         };
 
-        // Collect children that are connectors
-        if (componentModel.children) {
-          componentModel.children.forEach(function (child) {
-            if (child.userData && child.userData.objectType === 'connector') {
-              componentSceneData.children.push({
-                uuid: child.uuid,
-                name: child.name,
-                type: 'Mesh',
-                position: {
-                  x: child.position.x,
-                  y: child.position.y,
-                  z: child.position.z
-                },
-                userData: _objectSpread2({}, child.userData)
-              });
-            }
-          });
-        }
+        // Collect children that are connectors (using traverse to find deep children in models)
+        componentModel.traverse(function (child) {
+          if (child.userData && child.userData.objectType === 'connector') {
+            // Calculate position relative to component root
+            // This ensures that when we re-add it as a direct child of the component,
+            // it maintains the same world position relative to the component.
+            var componentMatrixWorldInverse = componentModel.matrixWorld.clone().invert();
+            var childWorldPos = new THREE__namespace.Vector3();
+            child.getWorldPosition(childWorldPos);
+            var relativePos = childWorldPos.applyMatrix4(componentMatrixWorldInverse);
+            componentSceneData.children.push({
+              uuid: child.uuid,
+              name: child.name,
+              type: 'Mesh',
+              position: {
+                x: relativePos.x,
+                y: relativePos.y,
+                z: relativePos.z
+              },
+              userData: _objectSpread2({}, child.userData)
+            });
+          }
+        });
 
         // Add the component to the scene data
         if (!currentSceneData.scene.children) {
@@ -39876,17 +39982,19 @@ var CentralPlantInternals = /*#__PURE__*/function () {
      * @param {string} componentId - The UUID of the component to translate
      * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
      * @param {number} value - The value to translate by
+     * @param {boolean} [skipPathUpdate=false] - Whether to skip triggering pathfinding
      * @returns {boolean} True if translation was successful, false otherwise
      */
   }, {
     key: "translateComponent",
     value: function translateComponent(componentId, axis, value) {
       var _this$centralPlant$ma;
+      var skipPathUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
       if (!((_this$centralPlant$ma = this.centralPlant.managers) !== null && _this$centralPlant$ma !== void 0 && _this$centralPlant$ma.transformOperationsManager)) {
         console.error('❌ translateComponent(): TransformOperationsManager not available');
         return false;
       }
-      return this.centralPlant.managers.transformOperationsManager.translateComponent(componentId, axis, value);
+      return this.centralPlant.managers.transformOperationsManager.translateComponent(componentId, axis, value, skipPathUpdate);
     }
 
     /**
@@ -39978,7 +40086,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
             } else if (objectType === 'gateway') {
               success = this.translateGateway(objectId, axis, value);
             } else if (objectType === 'component') {
-              success = this.translateComponent(objectId, axis, value);
+              success = this.translateComponent(objectId, axis, value, skipPathUpdate);
             } else {
               result.errors.push("Unknown object type: ".concat(objectType, " (").concat(objectId, ")"));
               console.warn("\u26A0\uFE0F Unknown object type: ".concat(objectType, " for ").concat(objectId));
@@ -41011,7 +41119,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.3.47
+   * @version 0.3.48
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -41341,7 +41449,8 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "translate",
     value: function translate(componentId, axis, value) {
-      return this.internals.translateComponent(componentId, axis, value);
+      var skipPathUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      return this.internals.translateComponent(componentId, axis, value, skipPathUpdate);
     }
 
     /**
@@ -42039,18 +42148,19 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
         return [];
       }
 
-      // Traverse through all components in the scene data
-      sceneData.scene.children.forEach(function (component) {
-        // Each component may have connector children
-        if (component.children && Array.isArray(component.children)) {
-          component.children.forEach(function (child) {
-            // Check if this child is a connector
-            if (child.userData && child.userData.objectType === 'connector' && child.uuid) {
-              allConnectorIds.push(child.uuid);
-            }
-          });
-        }
-      });
+      // Recursive search for connector IDs
+      var _findConnectorIds = function findConnectorIds(nodes) {
+        if (!nodes || !Array.isArray(nodes)) return;
+        nodes.forEach(function (node) {
+          if (node.userData && node.userData.objectType === 'connector' && node.uuid) {
+            allConnectorIds.push(node.uuid);
+          }
+          if (node.children && Array.isArray(node.children)) {
+            _findConnectorIds(node.children);
+          }
+        });
+      };
+      _findConnectorIds(sceneData.scene.children);
 
       // Get existing connections
       var existingConnections = this.getConnections();
@@ -42080,28 +42190,28 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
      * const infos = centralPlant.getAvailableConnectionsInfo()
      * // [{ id: 'PUMP-1-CONNECTOR-1', flow: 'out' }, ...]
      */
+    /**
+     * Get all connectors in the scene that are currently available (not used in a connection).
+     * Searches the active Three.js scene directly for the most accurate results.
+     * @returns {Array<{id: string, flow: string}>} Array of connector info objects
+     * @since 0.1.72 (Updated to search Three.js scene directly)
+     */
   }, {
     key: "getAvailableConnectionsInfo",
     value: function getAvailableConnectionsInfo() {
-      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
-        console.warn('⚠️ getAvailableConnectionsInfo(): Scene viewer or current scene data not available');
-        return [];
-      }
-      var sceneData = this.sceneViewer.currentSceneData;
-      if (!sceneData.scene || !sceneData.scene.children) {
-        console.warn('⚠️ getAvailableConnectionsInfo(): Invalid scene data structure');
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.warn('⚠️ getAvailableConnectionsInfo(): Scene viewer or scene not available');
         return [];
       }
       var allConnectorInfos = [];
-      sceneData.scene.children.forEach(function (component) {
-        if (component.children && Array.isArray(component.children)) {
-          component.children.forEach(function (child) {
-            if (child.userData && child.userData.objectType === 'connector' && child.uuid) {
-              allConnectorInfos.push({
-                id: child.uuid,
-                flow: child.userData.flow || 'bi'
-              });
-            }
+
+      // Search the Three.js scene directly for connectors
+      // This is more reliable than searching currentSceneData which might be stale
+      this.sceneViewer.scene.traverse(function (node) {
+        if (node.userData && node.userData.objectType === 'connector' && node.uuid) {
+          allConnectorInfos.push({
+            id: node.uuid,
+            flow: node.userData.flow || 'bi'
           });
         }
       });
@@ -42123,30 +42233,29 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
      * const result = centralPlant.validateConnections()
      * result.invalid.forEach(({ connection, reason }) => console.warn(reason, connection))
      */
+    /**
+     * Validate all connections in the current scene for flow direction compatibility.
+     * Searches the active Three.js scene for connector flow markers.
+     * @returns {{ valid: Array<Object>, invalid: Array<{connection: Object, reason: string}> }}
+     * @since 0.1.72 (Updated to search Three.js scene directly)
+     */
   }, {
     key: "validateConnections",
     value: function validateConnections() {
-      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
-        console.warn('⚠️ validateConnections(): Scene viewer or current scene data not available');
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.warn('⚠️ validateConnections(): Scene viewer or scene not available');
         return {
           valid: [],
           invalid: []
         };
       }
       var connections = this.getConnections();
-      var sceneData = this.sceneViewer.currentSceneData;
 
-      // Build lookup map: connectorId → flow
+      // Build lookup map: connectorId → flow from the Three.js scene
       var flowMap = {};
-      var scene = sceneData.scene || {};
-      var children = scene.children || [];
-      children.forEach(function (component) {
-        if (component.children && Array.isArray(component.children)) {
-          component.children.forEach(function (child) {
-            if (child.userData && child.userData.objectType === 'connector' && child.uuid) {
-              flowMap[child.uuid] = child.userData.flow || 'bi';
-            }
-          });
+      this.sceneViewer.scene.traverse(function (node) {
+        if (node.userData && node.userData.objectType === 'connector' && node.uuid) {
+          flowMap[node.uuid] = node.userData.flow || 'bi';
         }
       });
       var valid = [];
@@ -44114,7 +44223,7 @@ var sceneViewer = /*#__PURE__*/function (_BaseDisposable) {
               this.centralPlant.attachToComponent();
 
               // Sync our managers tracking object after attachment
-              managerKeys = ['threeJSResourceManager', 'performanceMonitorManager', 'settingsManager', 'sceneExportManager', 'componentManager', 'sceneInitializationManager', 'environmentManager', 'keyboardControlsManager', 'pathfindingManager', 'pathFlowManager', 'ioBehaviorManager', 'ioOutlineManager', 'sceneOperationsManager', 'animationManager', 'cameraControlsManager', 'componentDragManager', 'tooltipsManager', 'componentTooltipManager']; // Populate our managers tracking object
+              managerKeys = ['threeJSResourceManager', 'performanceMonitorManager', 'settingsManager', 'sceneExportManager', 'componentManager', 'transformOperationsManager', 'sceneInitializationManager', 'environmentManager', 'keyboardControlsManager', 'pathfindingManager', 'pathFlowManager', 'ioBehaviorManager', 'ioOutlineManager', 'sceneOperationsManager', 'animationManager', 'cameraControlsManager', 'componentDragManager', 'tooltipsManager', 'componentTooltipManager']; // Populate our managers tracking object
               managerKeys.forEach(function (key) {
                 if (_this2[key]) {
                   _this2.managers[key] = _this2[key];