@2112-lab/central-plant 0.3.49 → 0.3.51

package/dist/bundle/index.js

@@ -2513,6 +2513,11 @@ var transformControls = /*#__PURE__*/function (_THREE$Object3D) {
     _this.showY = true;
     _this.showZ = true;
 
+    // Axis interactivity (pickers). Visual handles can remain visible when false.
+    _this.pickX = true;
+    _this.pickY = true;
+    _this.pickZ = true;
+
     // Click timing for interaction delays
     _this.clickDelay = null;
     _this.lastInteractionTime = 0;
@@ -2666,6 +2671,9 @@ var transformControls = /*#__PURE__*/function (_THREE$Object3D) {
         this.lastInteractionTime = currentTime;
       }
       if (this.axis !== null) {
+        if (!this._isAxisPickable(this.axis)) {
+          return;
+        }
         _raycaster.setFromCamera(pointer, this.camera);
         var planeIntersect = this._intersectObjectWithRay(this._plane, _raycaster, true);
         if (planeIntersect) {
@@ -2936,10 +2944,19 @@ var transformControls = /*#__PURE__*/function (_THREE$Object3D) {
     value: function getMode() {
       return this.mode;
     }
+  }, {
+    key: "_isAxisPickable",
+    value: function _isAxisPickable(axisName) {
+      if (!axisName) return false;
+      if (axisName.indexOf('X') !== -1) return this.pickX !== false;
+      if (axisName.indexOf('Y') !== -1) return this.pickY !== false;
+      if (axisName.indexOf('Z') !== -1) return this.pickZ !== false;
+      return true;
+    }
   }, {
     key: "setMode",
     value: function setMode(mode) {
-      if (mode !== 'translate') {
+      if (mode !== 'translate' && mode !== 'rotate') {
         console.warn("transformControls: ".concat(mode, " mode is disabled. Locking to translate."));
         mode = 'translate';
       }
@@ -3180,6 +3197,7 @@ var SimpleTransformGizmo = /*#__PURE__*/function (_THREE$Object3D2) {
   }, {
     key: "updateGizmoState",
     value: function updateGizmoState(controls) {
+      var _this$gizmo$controls$, _this$gizmo$controls$2, _this$picker$controls, _this$picker$controls2;
       // Show only the gizmo for current mode
       this.gizmo['translate'].visible = controls.mode === 'translate';
       this.gizmo['rotate'].visible = controls.mode === 'rotate';
@@ -3197,43 +3215,62 @@ var SimpleTransformGizmo = /*#__PURE__*/function (_THREE$Object3D2) {
       // Force maximum render priority for all gizmo objects
       this._forceMaxRenderOrder();
 
-      // Update all handles for the current mode
-      var handles = [].concat(_toConsumableArray(this.picker[controls.mode].children), _toConsumableArray(this.gizmo[controls.mode].children));
+      // Scale based on camera distance
+      var factor;
+      if (controls.camera.isOrthographicCamera) {
+        factor = (controls.camera.top - controls.camera.bottom) / controls.camera.zoom;
+      } else {
+        factor = controls.worldPosition.distanceTo(controls.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * controls.camera.fov / 360) / controls.camera.zoom, 7);
+      }
+      this.scale.setScalar(factor * controls.size / 4);
+      this._updateModeHandles(controls, (_this$gizmo$controls$ = (_this$gizmo$controls$2 = this.gizmo[controls.mode]) === null || _this$gizmo$controls$2 === void 0 ? void 0 : _this$gizmo$controls$2.children) !== null && _this$gizmo$controls$ !== void 0 ? _this$gizmo$controls$ : [], false);
+      this._updateModeHandles(controls, (_this$picker$controls = (_this$picker$controls2 = this.picker[controls.mode]) === null || _this$picker$controls2 === void 0 ? void 0 : _this$picker$controls2.children) !== null && _this$picker$controls !== void 0 ? _this$picker$controls : [], true);
+    }
+  }, {
+    key: "_isAxisShown",
+    value: function _isAxisShown(controls, axisName) {
+      if (axisName.indexOf('X') !== -1 && !controls.showX) return false;
+      if (axisName.indexOf('Y') !== -1 && !controls.showY) return false;
+      if (axisName.indexOf('Z') !== -1 && !controls.showZ) return false;
+      return true;
+    }
+  }, {
+    key: "_isAxisPickable",
+    value: function _isAxisPickable(controls, axisName) {
+      if (axisName.indexOf('X') !== -1) return controls.pickX !== false;
+      if (axisName.indexOf('Y') !== -1) return controls.pickY !== false;
+      if (axisName.indexOf('Z') !== -1) return controls.pickZ !== false;
+      return true;
+    }
+  }, {
+    key: "_updateModeHandles",
+    value: function _updateModeHandles(controls, handles, isPicker) {
       var _iterator = _createForOfIteratorHelper(handles),
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _handle$material$_ori;
           var handle = _step.value;
-          handle.visible = true;
-
-          // Scale based on camera distance
-          var factor = void 0;
-          if (controls.camera.isOrthographicCamera) {
-            factor = (controls.camera.top - controls.camera.bottom) / controls.camera.zoom;
-          } else {
-            factor = controls.worldPosition.distanceTo(controls.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * controls.camera.fov / 360) / controls.camera.zoom, 7);
+          var axisName = handle.name;
+          var shown = this._isAxisShown(controls, axisName);
+          var pickable = this._isAxisPickable(controls, axisName);
+          if (isPicker) {
+            handle.visible = shown && pickable;
+            continue;
           }
-
-          // Apply scale to the entire gizmo, not individual handles
-          this.scale.setScalar(factor * controls.size / 4);
-
-          // Apply axis visibility constraints
-          if (handle.name.indexOf('X') !== -1 && !controls.showX) handle.visible = false;
-          if (handle.name.indexOf('Y') !== -1 && !controls.showY) handle.visible = false;
-          if (handle.name.indexOf('Z') !== -1 && !controls.showZ) handle.visible = false;
-
-          // Highlight selected axis
-          if (handle.material) {
-            handle.material._originalColor = handle.material._originalColor || handle.material.color.clone();
-            handle.material._originalOpacity = handle.material._originalOpacity || handle.material.opacity;
+          handle.visible = shown;
+          if (!handle.material) continue;
+          handle.material._originalColor = handle.material._originalColor || handle.material.color.clone();
+          handle.material._originalOpacity = (_handle$material$_ori = handle.material._originalOpacity) !== null && _handle$material$_ori !== void 0 ? _handle$material$_ori : handle.material.opacity;
+          if (shown && pickable && controls.enabled && controls.axis === axisName) {
+            handle.material.color.setHex(0xffff00);
+            handle.material.opacity = 1.0;
+          } else if (shown && !pickable) {
+            handle.material.color.copy(handle.material._originalColor);
+            handle.material.opacity = SimpleTransformGizmo.DISABLED_AXIS_OPACITY;
+          } else {
             handle.material.color.copy(handle.material._originalColor);
             handle.material.opacity = handle.material._originalOpacity;
-            if (controls.enabled && controls.axis) {
-              if (handle.name === controls.axis) {
-                handle.material.color.setHex(0xffff00);
-                handle.material.opacity = 1.0;
-              }
-            }
           }
         }
       } catch (err) {
@@ -3283,6 +3320,7 @@ var SimpleTransformGizmo = /*#__PURE__*/function (_THREE$Object3D2) {
  * Optimized plane for transformation interactions
  * Simplified geometry and material for better performance
  */
+_defineProperty(SimpleTransformGizmo, "DISABLED_AXIS_OPACITY", 0.3);
 var SimpleTransformPlane = /*#__PURE__*/function (_THREE$Mesh) {
   function SimpleTransformPlane() {
     var _this4;
@@ -4171,6 +4209,7 @@ var TransformControlsManager = /*#__PURE__*/function () {
       this.eventHandlers.transformStart = function () {
         console.log("transformControls transformStart");
         _this2.transformState.isTransforming = true;
+        _this2._suppressNextClick = true;
 
         // Store initial transforms for all selected objects
         if (_this2.selectedObjects.length > 0) {
@@ -4374,6 +4413,10 @@ var TransformControlsManager = /*#__PURE__*/function () {
             // Translate mode
             _this3.setMode('translate');
             break;
+          case 'KeyR':
+            // Rotate mode
+            _this3.setMode('rotate');
+            break;
         }
       };
       window.addEventListener('keydown', this.eventHandlers.keydown);
@@ -4558,8 +4601,16 @@ var TransformControlsManager = /*#__PURE__*/function () {
         }
 
         // Left-click: select for transform only (bounding box, no tooltip)
+        var isComponent = objectType === 'component';
+        var isSameSingleSelection = isComponent && _this4.selectedObjects.length === 1 && _this4.selectedObjects[0] === targetObject;
+        if (isSameSingleSelection) {
+          _this4.toggleTransformMode();
+          return;
+        }
         if (!_this4.selectedObjects.includes(targetObject)) {
           _this4.deselectObject();
+        } else if (!isComponent) {
+          _this4.setMode('translate');
         }
         _this4.selectObjectForTransformOnly(targetObject);
       };
@@ -5231,6 +5282,7 @@ var TransformControlsManager = /*#__PURE__*/function () {
         this._hideTransformControls();
         console.log("\uD83D\uDD12 Transform controls hidden after deselection");
       }
+      this.setMode('translate');
 
       // Execute callback
       if (this.callbacks.onObjectSelect) {
@@ -5393,14 +5445,14 @@ var TransformControlsManager = /*#__PURE__*/function () {
   }, {
     key: "setMode",
     value: function setMode(mode) {
-      // Only allow translate mode - lock rotation and scale controls
-      if (mode !== 'translate') {
+      if (mode !== 'translate' && mode !== 'rotate') {
         console.warn("\u26A0\uFE0F Transform mode ".concat(mode, " is disabled. Locking to translate."));
         mode = 'translate';
       }
       var previousMode = this.currentMode;
       this.currentMode = mode;
       this.transformControls.setMode(mode);
+      this._updateAxisVisibilityForMode(mode);
 
       // Execute callback
       if (this.callbacks.onModeChange) {
@@ -5409,6 +5461,47 @@ var TransformControlsManager = /*#__PURE__*/function () {
       console.log("\uD83D\uDD27 Transform mode changed: ".concat(previousMode, " \u2192 ").concat(mode));
     }
 
+    /**
+     * Update gizmo axis visibility based on transform mode.
+     * Rotation shows all rings but only Z-axis is interactive.
+     * @param {'translate' | 'rotate'} mode
+     * @private
+     */
+  }, {
+    key: "_updateAxisVisibilityForMode",
+    value: function _updateAxisVisibilityForMode(mode) {
+      if (!this.transformControls) return;
+      if (mode === 'rotate') {
+        this.transformControls.showX = true;
+        this.transformControls.showY = true;
+        this.transformControls.showZ = true;
+        this.transformControls.pickX = false;
+        this.transformControls.pickY = false;
+        this.transformControls.pickZ = true;
+        return;
+      }
+      this.transformControls.showX = this.config.showX;
+      this.transformControls.showY = this.config.showY;
+      this.transformControls.showZ = this.config.showZ;
+      this.transformControls.pickX = true;
+      this.transformControls.pickY = true;
+      this.transformControls.pickZ = true;
+    }
+
+    /**
+     * Toggle between translate and rotate transform modes
+     */
+  }, {
+    key: "toggleTransformMode",
+    value: function toggleTransformMode() {
+      var _this$transformContro;
+      var newMode = this.currentMode === 'translate' ? 'rotate' : 'translate';
+      this.setMode(newMode);
+      if ((_this$transformContro = this.transformControls) !== null && _this$transformContro !== void 0 && _this$transformContro.object) {
+        this.transformControls.updateMatrixWorld(true);
+      }
+    }
+
     /**
      * Set the transformation space
      * @param {'world' | 'local'} space - The transformation space
@@ -5847,12 +5940,10 @@ var TransformControlsManager = /*#__PURE__*/function () {
           obj.position.copy(newWorldPos);
           obj.updateMatrix();
         } else if (_this8.currentMode === 'rotate') {
-          // Calculate offset from centroid
+          // Calculate offset from centroid (Z-axis rotation only)
           var offsetFromCentroid = originalWorldPos.clone().sub(originalCentroid);
-
-          // Rotate the offset vector
           var rotatedOffset = offsetFromCentroid.clone();
-          var rotationQuat = new THREE__namespace.Quaternion().setFromEuler(rotationDelta);
+          var rotationQuat = new THREE__namespace.Quaternion().setFromAxisAngle(new THREE__namespace.Vector3(0, 0, 1), rotationDelta.z);
           rotatedOffset.applyQuaternion(rotationQuat);
 
           // Calculate new world position
@@ -5868,9 +5959,9 @@ var TransformControlsManager = /*#__PURE__*/function () {
           }
           obj.position.copy(_newWorldPos);
 
-          // Apply rotation to the object itself
-          obj.rotation.x = originalRot.x + rotationDelta.x;
-          obj.rotation.y = originalRot.y + rotationDelta.y;
+          // Apply Z-axis rotation only
+          obj.rotation.x = originalRot.x;
+          obj.rotation.y = originalRot.y;
           obj.rotation.z = originalRot.z + rotationDelta.z;
           obj.updateMatrix();
         }
@@ -5900,7 +5991,15 @@ var TransformControlsManager = /*#__PURE__*/function () {
               return _context2.a(2);
             case 1:
               console.log("\uD83D\uDD27 Applying multi-selection transform to ".concat(this.selectedObjects.length, " objects"));
-
+              if (!(this.currentMode === 'rotate')) {
+                _context2.n = 3;
+                break;
+              }
+              _context2.n = 2;
+              return this._applyMultiSelectionRotation();
+            case 2:
+              return _context2.a(2);
+            case 3:
               // Calculate transformation deltas
               _this$_calculateTrans = this._calculateTransformDeltas(), deltaX = _this$_calculateTrans.deltaX, deltaY = _this$_calculateTrans.deltaY, deltaZ = _this$_calculateTrans.deltaZ, threshold = _this$_calculateTrans.threshold;
               console.log('🔧 Transform delta:', {
@@ -5910,12 +6009,12 @@ var TransformControlsManager = /*#__PURE__*/function () {
               });
 
               // Only process if there's a meaningful translation
-              if (!(this.currentMode !== 'translate' || Math.abs(deltaX) < threshold && Math.abs(deltaY) < threshold && Math.abs(deltaZ) < threshold)) {
-                _context2.n = 2;
+              if (!(Math.abs(deltaX) < threshold && Math.abs(deltaY) < threshold && Math.abs(deltaZ) < threshold)) {
+                _context2.n = 4;
                 break;
               }
               return _context2.a(2);
-            case 2:
+            case 4:
               // Reset all objects to original positions
               this._resetObjectsToOriginalPositions();
 
@@ -5929,20 +6028,20 @@ var TransformControlsManager = /*#__PURE__*/function () {
               components = this.selectedObjects.filter(function (obj) {
                 return !isSegment(obj) && !isGateway(obj);
               }); // Translate each object type
-              _context2.n = 3;
+              _context2.n = 5;
               return this._translateSegments(segments, deltaX, deltaY, deltaZ, threshold);
-            case 3:
-              _context2.n = 4;
+            case 5:
+              _context2.n = 6;
               return this._translateGateways(gateways, deltaX, deltaY, deltaZ, threshold);
-            case 4:
-              _context2.n = 5;
+            case 6:
+              _context2.n = 7;
               return this._translateComponents(components, deltaX, deltaY, deltaZ, threshold);
-            case 5:
+            case 7:
               console.log("\u2705 All ".concat(this.selectedObjects.length, " objects translated"));
 
               // Cleanup and refresh
               this._finalizeMultiSelectionTransform();
-            case 6:
+            case 8:
               return _context2.a(2);
           }
         }, _callee2, this);
@@ -5952,6 +6051,123 @@ var TransformControlsManager = /*#__PURE__*/function () {
       }
       return applyMultiSelectionTransform;
     }()
+    /**
+     * Apply rotation from multi-selection group to selected components via API
+     * @private
+     */
+    )
+  }, {
+    key: "_applyMultiSelectionRotation",
+    value: (function () {
+      var _applyMultiSelectionRotation2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var threshold, rotationDeltas, _iterator6, _step6, _obj2, originalRot, originalPos, _deltaRad, _i, _rotationDeltas, _obj$userData5, _obj$userData6, _obj$userData7, _this$centralPlant, _rotationDeltas$_i, obj, deltaRad, componentId, deltaDeg, snappedDeg, _t;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              threshold = 0.001;
+              rotationDeltas = [];
+              _iterator6 = _createForOfIteratorHelper(this.selectedObjects);
+              _context3.p = 1;
+              _iterator6.s();
+            case 2:
+              if ((_step6 = _iterator6.n()).done) {
+                _context3.n = 6;
+                break;
+              }
+              _obj2 = _step6.value;
+              originalRot = _obj2.userData._multiSelectOriginalRotation;
+              originalPos = _obj2.userData._multiSelectOriginalPosition;
+              if (originalRot) {
+                _context3.n = 3;
+                break;
+              }
+              return _context3.a(3, 5);
+            case 3:
+              _deltaRad = _obj2.rotation.z - originalRot.z;
+              if (!(Math.abs(_deltaRad) < threshold)) {
+                _context3.n = 4;
+                break;
+              }
+              return _context3.a(3, 5);
+            case 4:
+              rotationDeltas.push({
+                obj: _obj2,
+                originalPos: originalPos === null || originalPos === void 0 ? void 0 : originalPos.clone(),
+                originalRot: originalRot.clone(),
+                deltaRad: _deltaRad
+              });
+            case 5:
+              _context3.n = 2;
+              break;
+            case 6:
+              _context3.n = 8;
+              break;
+            case 7:
+              _context3.p = 7;
+              _t = _context3.v;
+              _iterator6.e(_t);
+            case 8:
+              _context3.p = 8;
+              _iterator6.f();
+              return _context3.f(8);
+            case 9:
+              if (!(rotationDeltas.length === 0)) {
+                _context3.n = 10;
+                break;
+              }
+              return _context3.a(2);
+            case 10:
+              rotationDeltas.forEach(function (_ref2) {
+                var obj = _ref2.obj,
+                  originalPos = _ref2.originalPos,
+                  originalRot = _ref2.originalRot;
+                if (originalPos) {
+                  obj.position.copy(originalPos);
+                }
+                obj.rotation.copy(originalRot);
+                obj.updateMatrixWorld(true);
+              });
+              _i = 0, _rotationDeltas = rotationDeltas;
+            case 11:
+              if (!(_i < _rotationDeltas.length)) {
+                _context3.n = 15;
+                break;
+              }
+              _rotationDeltas$_i = _rotationDeltas[_i], obj = _rotationDeltas$_i.obj, deltaRad = _rotationDeltas$_i.deltaRad;
+              if (!(((_obj$userData5 = obj.userData) === null || _obj$userData5 === void 0 ? void 0 : _obj$userData5.objectType) !== 'component' || !((_obj$userData6 = obj.userData) !== null && _obj$userData6 !== void 0 && _obj$userData6.libraryId))) {
+                _context3.n = 12;
+                break;
+              }
+              return _context3.a(3, 14);
+            case 12:
+              componentId = obj.uuid || ((_obj$userData7 = obj.userData) === null || _obj$userData7 === void 0 ? void 0 : _obj$userData7.originalUuid);
+              if (!(!componentId || !((_this$centralPlant = this.centralPlant) !== null && _this$centralPlant !== void 0 && _this$centralPlant.rotate))) {
+                _context3.n = 13;
+                break;
+              }
+              return _context3.a(3, 14);
+            case 13:
+              deltaDeg = THREE__namespace.MathUtils.radToDeg(deltaRad);
+              snappedDeg = Math.round(deltaDeg / 90) * 90;
+              if (Math.abs(snappedDeg) >= 90) {
+                this.centralPlant.rotate(componentId, 'z', snappedDeg);
+              }
+            case 14:
+              _i++;
+              _context3.n = 11;
+              break;
+            case 15:
+              this._finalizeMultiSelectionTransform();
+            case 16:
+              return _context3.a(2);
+          }
+        }, _callee3, this, [[1, 7, 8, 9]]);
+      }));
+      function _applyMultiSelectionRotation() {
+        return _applyMultiSelectionRotation2.apply(this, arguments);
+      }
+      return _applyMultiSelectionRotation;
+    }()
     /**
      * Calculate transformation deltas from multi-selection group
      * @returns {Object} Delta values and threshold
@@ -6007,17 +6223,17 @@ var TransformControlsManager = /*#__PURE__*/function () {
   }, {
     key: "_translateSegments",
     value: (function () {
-      var _translateSegments2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(segments, deltaX, deltaY, deltaZ, threshold) {
+      var _translateSegments2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(segments, deltaX, deltaY, deltaZ, threshold) {
         var _this$sceneViewer, _this$sceneViewer2;
-        var transformOpsManager, useOptimizedPath, throttleDelay, AXIS_THROTTLE, OBJECT_DELAY, i, segment, axes, _i, _axes, _axes$_i, axis, delta;
-        return _regenerator().w(function (_context3) {
-          while (1) switch (_context3.n) {
+        var transformOpsManager, useOptimizedPath, throttleDelay, AXIS_THROTTLE, OBJECT_DELAY, i, segment, axes, _i2, _axes, _axes$_i, axis, delta;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
             case 0:
               if (!(segments.length === 0)) {
-                _context3.n = 1;
+                _context4.n = 1;
                 break;
               }
-              return _context3.a(2);
+              return _context4.a(2);
             case 1:
               transformOpsManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.transformOperationsManager;
               useOptimizedPath = transformOpsManager != null;
@@ -6036,7 +6252,7 @@ var TransformControlsManager = /*#__PURE__*/function () {
               i = 0;
             case 2:
               if (!(i < segments.length)) {
-                _context3.n = 8;
+                _context4.n = 8;
                 break;
               }
               segment = segments[i];
@@ -6050,26 +6266,26 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 axis: 'z',
                 delta: deltaZ
               }]; // Translate on each axis
-              _i = 0, _axes = axes;
+              _i2 = 0, _axes = axes;
             case 3:
-              if (!(_i < _axes.length)) {
-                _context3.n = 6;
+              if (!(_i2 < _axes.length)) {
+                _context4.n = 6;
                 break;
               }
-              _axes$_i = _axes[_i], axis = _axes$_i.axis, delta = _axes$_i.delta;
+              _axes$_i = _axes[_i2], axis = _axes$_i.axis, delta = _axes$_i.delta;
               if (!(Math.abs(delta) > threshold)) {
-                _context3.n = 5;
+                _context4.n = 5;
                 break;
               }
-              _context3.n = 4;
+              _context4.n = 4;
               return this._translateSegmentOnAxis(segment, axis, delta, useOptimizedPath, i);
             case 4:
-              segment = _context3.v;
-              _context3.n = 5;
+              segment = _context4.v;
+              _context4.n = 5;
               return throttleDelay(AXIS_THROTTLE);
             case 5:
-              _i++;
-              _context3.n = 3;
+              _i2++;
+              _context4.n = 3;
               break;
             case 6:
               // Update selected objects array with refreshed reference
@@ -6080,14 +6296,14 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 console.warn("\u26A0\uFE0F Segment reference became null (".concat(i + 1, "/").concat(segments.length, ")"));
               }
               if (!(i < segments.length - 1)) {
-                _context3.n = 7;
+                _context4.n = 7;
                 break;
               }
-              _context3.n = 7;
+              _context4.n = 7;
               return throttleDelay(OBJECT_DELAY);
             case 7:
               i++;
-              _context3.n = 2;
+              _context4.n = 2;
               break;
             case 8:
               // Batch update paths for optimized path only
@@ -6097,9 +6313,9 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 console.log('✅ Paths regenerated successfully');
               }
             case 9:
-              return _context3.a(2);
+              return _context4.a(2);
           }
-        }, _callee3, this);
+        }, _callee4, this);
       }));
       function _translateSegments(_x, _x2, _x3, _x4, _x5) {
         return _translateSegments2.apply(this, arguments);
@@ -6138,11 +6354,11 @@ var TransformControlsManager = /*#__PURE__*/function () {
   }, {
     key: "_translateSegmentOnAxis",
     value: (function () {
-      var _translateSegmentOnAxis2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(segment, axis, delta, useOptimizedPath, index) {
+      var _translateSegmentOnAxis2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(segment, axis, delta, useOptimizedPath, index) {
         var _segment$userData3;
         var segmentId, success;
-        return _regenerator().w(function (_context4) {
-          while (1) switch (_context4.n) {
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
             case 0:
               segmentId = segment.uuid || ((_segment$userData3 = segment.userData) === null || _segment$userData3 === void 0 ? void 0 : _segment$userData3.originalUuid);
               if (useOptimizedPath) {
@@ -6155,9 +6371,9 @@ var TransformControlsManager = /*#__PURE__*/function () {
               }
 
               // Refresh segment reference after manualization
-              return _context4.a(2, this._refreshSegmentReference(segment));
+              return _context5.a(2, this._refreshSegmentReference(segment));
           }
-        }, _callee4, this);
+        }, _callee5, this);
       }));
       function _translateSegmentOnAxis(_x6, _x7, _x8, _x9, _x0) {
         return _translateSegmentOnAxis2.apply(this, arguments);
@@ -6173,8 +6389,8 @@ var TransformControlsManager = /*#__PURE__*/function () {
     key: "_updateSegmentReference",
     value: function _updateSegmentReference(oldSegment, newSegment, index) {
       var selectedIndex = this.selectedObjects.findIndex(function (obj) {
-        var _obj$userData5;
-        return obj.uuid === oldSegment.uuid || ((_obj$userData5 = obj.userData) === null || _obj$userData5 === void 0 ? void 0 : _obj$userData5.originalUuid) === oldSegment.uuid;
+        var _obj$userData8;
+        return obj.uuid === oldSegment.uuid || ((_obj$userData8 = obj.userData) === null || _obj$userData8 === void 0 ? void 0 : _obj$userData8.originalUuid) === oldSegment.uuid;
       });
       if (selectedIndex !== -1 && newSegment) {
         // Clear bounding box cache
@@ -6192,17 +6408,17 @@ var TransformControlsManager = /*#__PURE__*/function () {
   }, {
     key: "_translateGateways",
     value: (function () {
-      var _translateGateways2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(gateways, deltaX, deltaY, deltaZ, threshold) {
+      var _translateGateways2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(gateways, deltaX, deltaY, deltaZ, threshold) {
         var _this9 = this;
         var throttleDelay, AXIS_THROTTLE, OBJECT_DELAY, i, _gateway$userData, gateway, gatewayId;
-        return _regenerator().w(function (_context5) {
-          while (1) switch (_context5.n) {
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
             case 0:
               if (!(gateways.length === 0)) {
-                _context5.n = 1;
+                _context6.n = 1;
                 break;
               }
-              return _context5.a(2);
+              return _context6.a(2);
             case 1:
               throttleDelay = function throttleDelay(ms) {
                 return new Promise(function (resolve) {
@@ -6214,31 +6430,31 @@ var TransformControlsManager = /*#__PURE__*/function () {
               i = 0;
             case 2:
               if (!(i < gateways.length)) {
-                _context5.n = 5;
+                _context6.n = 5;
                 break;
               }
               gateway = gateways[i];
               gatewayId = gateway.uuid || ((_gateway$userData = gateway.userData) === null || _gateway$userData === void 0 ? void 0 : _gateway$userData.originalUuid);
-              _context5.n = 3;
+              _context6.n = 3;
               return this._translateObjectOnAxes(gatewayId, deltaX, deltaY, deltaZ, threshold, throttleDelay, AXIS_THROTTLE, function (id, axis, delta) {
                 return _this9.centralPlant.translateGateway(id, axis, delta);
               });
             case 3:
               console.log("\uD83D\uDEAA Gateway ".concat(gateway.name, " translated (").concat(i + 1, "/").concat(gateways.length, ")"));
               if (!(i < gateways.length - 1)) {
-                _context5.n = 4;
+                _context6.n = 4;
                 break;
               }
-              _context5.n = 4;
+              _context6.n = 4;
               return throttleDelay(OBJECT_DELAY);
             case 4:
               i++;
-              _context5.n = 2;
+              _context6.n = 2;
               break;
             case 5:
-              return _context5.a(2);
+              return _context6.a(2);
           }
-        }, _callee5, this);
+        }, _callee6, this);
       }));
       function _translateGateways(_x1, _x10, _x11, _x12, _x13) {
         return _translateGateways2.apply(this, arguments);
@@ -6253,17 +6469,17 @@ var TransformControlsManager = /*#__PURE__*/function () {
   }, {
     key: "_translateComponents",
     value: (function () {
-      var _translateComponents2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(components, deltaX, deltaY, deltaZ, threshold) {
+      var _translateComponents2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(components, deltaX, deltaY, deltaZ, threshold) {
         var _this0 = this;
         var throttleDelay, AXIS_THROTTLE, OBJECT_DELAY, i, _component$userData, component, componentId;
-        return _regenerator().w(function (_context6) {
-          while (1) switch (_context6.n) {
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
             case 0:
               if (!(components.length === 0)) {
-                _context6.n = 1;
+                _context7.n = 1;
                 break;
               }
-              return _context6.a(2);
+              return _context7.a(2);
             case 1:
               throttleDelay = function throttleDelay(ms) {
                 return new Promise(function (resolve) {
@@ -6275,31 +6491,31 @@ var TransformControlsManager = /*#__PURE__*/function () {
               i = 0;
             case 2:
               if (!(i < components.length)) {
-                _context6.n = 5;
+                _context7.n = 5;
                 break;
               }
               component = components[i];
               componentId = component.uuid || ((_component$userData = component.userData) === null || _component$userData === void 0 ? void 0 : _component$userData.originalUuid);
-              _context6.n = 3;
+              _context7.n = 3;
               return this._translateObjectOnAxes(componentId, deltaX, deltaY, deltaZ, threshold, throttleDelay, AXIS_THROTTLE, function (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, ")"));
               if (!(i < components.length - 1)) {
-                _context6.n = 4;
+                _context7.n = 4;
                 break;
               }
-              _context6.n = 4;
+              _context7.n = 4;
               return throttleDelay(OBJECT_DELAY);
             case 4:
               i++;
-              _context6.n = 2;
+              _context7.n = 2;
               break;
             case 5:
-              return _context6.a(2);
+              return _context7.a(2);
           }
-        }, _callee6, this);
+        }, _callee7, this);
       }));
       function _translateComponents(_x14, _x15, _x16, _x17, _x18) {
         return _translateComponents2.apply(this, arguments);
@@ -6314,10 +6530,10 @@ var TransformControlsManager = /*#__PURE__*/function () {
   }, {
     key: "_translateObjectOnAxes",
     value: (function () {
-      var _translateObjectOnAxes2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(objectId, deltaX, deltaY, deltaZ, threshold, throttleDelay, axisThrottle, translateFn) {
-        var axes, _i2, _axes2, _axes2$_i, axis, delta;
-        return _regenerator().w(function (_context7) {
-          while (1) switch (_context7.n) {
+      var _translateObjectOnAxes2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(objectId, deltaX, deltaY, deltaZ, threshold, throttleDelay, axisThrottle, translateFn) {
+        var axes, _i3, _axes2, _axes2$_i, axis, delta;
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
             case 0:
               axes = [{
                 axis: 'x',
@@ -6329,28 +6545,28 @@ var TransformControlsManager = /*#__PURE__*/function () {
                 axis: 'z',
                 delta: deltaZ
               }];
-              _i2 = 0, _axes2 = axes;
+              _i3 = 0, _axes2 = axes;
             case 1:
-              if (!(_i2 < _axes2.length)) {
-                _context7.n = 3;
+              if (!(_i3 < _axes2.length)) {
+                _context8.n = 3;
                 break;
               }
-              _axes2$_i = _axes2[_i2], axis = _axes2$_i.axis, delta = _axes2$_i.delta;
+              _axes2$_i = _axes2[_i3], axis = _axes2$_i.axis, delta = _axes2$_i.delta;
               if (!(Math.abs(delta) > threshold)) {
-                _context7.n = 2;
+                _context8.n = 2;
                 break;
               }
               translateFn(objectId, axis, delta);
-              _context7.n = 2;
+              _context8.n = 2;
               return throttleDelay(axisThrottle);
             case 2:
-              _i2++;
-              _context7.n = 1;
+              _i3++;
+              _context8.n = 1;
               break;
             case 3:
-              return _context7.a(2);
+              return _context8.a(2);
           }
-        }, _callee7);
+        }, _callee8);
       }));
       function _translateObjectOnAxes(_x19, _x20, _x21, _x22, _x23, _x24, _x25, _x26) {
         return _translateObjectOnAxes2.apply(this, arguments);
@@ -25488,6 +25704,405 @@ function interceptControlUp( event ) {
 
 }
 
+/** Default horizontal orbit bearing (target → camera, XY plane). */
+var DEFAULT_HOME_VIEW_DIRECTION = {
+  x: -8,
+  y: -9,
+  z: 0
+};
+
+/** Downward pitch from camera to the bottom-center look-at target (degrees). */
+var HOME_DOWNWARD_PITCH_DEG = 13;
+
+/** Minimum camera height above the bbox floor (world units). */
+var HOME_CAMERA_MIN_HEIGHT = 0.8;
+
+/** Ground plane height in world space (Z-up). */
+var WORLD_GROUND_Z = 0;
+
+/** Camera height above the ground when the scene has no components. */
+var HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND = 2.5;
+
+/** Default horizontal distance from world origin when the scene is empty. */
+var HOME_EMPTY_SCENE_DISTANCE = Math.hypot(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y);
+var WORLD_ORIGIN = new THREE__namespace.Vector3(0, 0, 0);
+var CameraControlsManager = /*#__PURE__*/function () {
+  function CameraControlsManager(component) {
+    _classCallCheck(this, CameraControlsManager);
+    this.sceneViewer = component;
+    this.autoRotateSpeed = 1.0; // Default rotation speed
+    this._isAutoRotating = false; // Internal state tracking
+  }
+
+  /**
+   * Frame the camera so that every component in the scene fits perfectly in view.
+   *
+   * Computes the combined bounding box of all scene components, then moves the
+   * (perspective) camera along its current viewing direction to the distance
+   * required to fit that bounding sphere within the frustum. The orbit target,
+   * clipping planes and distance limits are updated to match.
+   *
+   * @param {Object} [options]
+   * @param {number} [options.padding=1.04] - Multiplier on the fit distance (>1 leaves margin).
+   * @param {THREE.Vector3|{x:number,y:number,z:number}} [options.direction] - Override viewing
+   *   direction (target -> camera). When omitted, the current orbit angle is preserved.
+   * @param {boolean} [options.groundLevel] - Pin camera low with a downward pitch toward
+   *   the bottom-center of the assembly. Defaults to true when a home direction is used.
+   * @returns {boolean} True if the camera was reframed, false if there was nothing to frame.
+   */
+  return _createClass(CameraControlsManager, [{
+    key: "fitCameraToScene",
+    value: function fitCameraToScene() {
+      var _options$padding, _options$groundLevel;
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var component = this.sceneViewer;
+      var camera = component === null || component === void 0 ? void 0 : component.camera;
+      var scene = component === null || component === void 0 ? void 0 : component.scene;
+      var controls = component === null || component === void 0 ? void 0 : component.controls;
+      if (!camera || !scene || !camera.isPerspectiveCamera) {
+        console.warn('⚠️ fitCameraToScene: missing perspective camera or scene');
+        return false;
+      }
+      var padding = (_options$padding = options.padding) !== null && _options$padding !== void 0 ? _options$padding : 1.04;
+
+      // Make sure world matrices are current before measuring bounds
+      scene.updateMatrixWorld(true);
+      var box = this._collectSceneBounds(scene);
+      if (!box) {
+        return this._aimCameraAtWorldCenter(camera, controls, options);
+      }
+      var useGroundLevel = (_options$groundLevel = options.groundLevel) !== null && _options$groundLevel !== void 0 ? _options$groundLevel : this._isHomeDirection(options.direction);
+      if (useGroundLevel) {
+        return this._fitCameraGroundLevel(box, camera, controls, options, padding);
+      }
+      return this._fitCameraFromCenter(box, camera, controls, options, padding);
+    }
+
+    /**
+     * Aim the camera at world origin when there are no components to frame.
+     * @private
+     */
+  }, {
+    key: "_aimCameraAtWorldCenter",
+    value: function _aimCameraAtWorldCenter(camera, controls) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var frameTarget = WORLD_ORIGIN.clone();
+      var distance = HOME_EMPTY_SCENE_DISTANCE;
+      var horizDir = new THREE__namespace.Vector3();
+      if (options.direction) {
+        horizDir.set(options.direction.x, options.direction.y, 0);
+      } else {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      if (horizDir.lengthSq() < 1e-6) {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      horizDir.normalize();
+      var cameraHeight = WORLD_GROUND_Z + HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND;
+      var camPos = new THREE__namespace.Vector3(frameTarget.x + horizDir.x * distance, frameTarget.y + horizDir.y * distance, cameraHeight);
+      camera.position.copy(camPos);
+      camera.near = 0.01;
+      camera.far = 1000;
+      camera.updateProjectionMatrix();
+      camera.lookAt(frameTarget);
+      if (controls) {
+        controls.target.copy(frameTarget);
+        controls.minDistance = 1;
+        controls.maxDistance = 20;
+        controls.update();
+      }
+      console.log('🎥 Camera aimed at world origin (empty scene)');
+      return true;
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_collectSceneBounds",
+    value: function _collectSceneBounds(scene) {
+      var includeTypes = ['component', 'gateway', 'segment'];
+      var box = new THREE__namespace.Box3();
+      var found = false;
+      scene.traverse(function (obj) {
+        var _obj$userData;
+        if (includeTypes.includes((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType)) {
+          var objBox = new THREE__namespace.Box3().setFromObject(obj);
+          if (!objBox.isEmpty()) {
+            box.union(objBox);
+            found = true;
+          }
+        }
+      });
+      return found && !box.isEmpty() ? box : null;
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_isHomeDirection",
+    value: function _isHomeDirection(direction) {
+      if (!direction) return false;
+      var horiz = Math.hypot(direction.x, direction.y);
+      if (horiz < 1e-6) return false;
+      var dx = direction.x / horiz - DEFAULT_HOME_VIEW_DIRECTION.x / Math.hypot(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y);
+      var dy = direction.y / horiz - DEFAULT_HOME_VIEW_DIRECTION.y / Math.hypot(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y);
+      return Math.hypot(dx, dy) < 0.05 && Math.abs(direction.z) < 0.5;
+    }
+
+    /**
+     * Ground-hugging camera: horizontal offset with a fixed downward pitch toward
+     * the bottom-center of the component group.
+     * @private
+     */
+  }, {
+    key: "_fitCameraGroundLevel",
+    value: function _fitCameraGroundLevel(box, camera, controls, options, padding) {
+      var size = box.getSize(new THREE__namespace.Vector3());
+      var frameTarget = this._getBoxBottomCenter(box);
+      var downwardPitch = THREE__namespace.MathUtils.degToRad(HOME_DOWNWARD_PITCH_DEG);
+      var horizDir = new THREE__namespace.Vector3();
+      if (options.direction) {
+        horizDir.set(options.direction.x, options.direction.y, 0);
+      } else {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      if (horizDir.lengthSq() < 1e-6) {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      horizDir.normalize();
+      var corners = this._getBoxCorners(box);
+      var vFov = THREE__namespace.MathUtils.degToRad(camera.fov);
+      var aspect = camera.aspect || 1;
+      var tanHalfV = Math.tan(vFov / 2);
+      var tanHalfH = tanHalfV * aspect;
+      var fitsAtDistance = function fitsAtDistance(distance) {
+        var cameraHeight = Math.max(frameTarget.z + distance * Math.tan(downwardPitch), box.min.z + HOME_CAMERA_MIN_HEIGHT);
+        var camPos = new THREE__namespace.Vector3(frameTarget.x + horizDir.x * distance, frameTarget.y + horizDir.y * distance, cameraHeight);
+        var forward = new THREE__namespace.Vector3().subVectors(frameTarget, camPos).normalize();
+        var worldUp = camera.up.clone().normalize();
+        var right = new THREE__namespace.Vector3().crossVectors(forward, worldUp);
+        if (right.lengthSq() < 1e-6) {
+          right = new THREE__namespace.Vector3().crossVectors(forward, new THREE__namespace.Vector3(1, 0, 0));
+        }
+        right.normalize();
+        var up = new THREE__namespace.Vector3().crossVectors(right, forward).normalize();
+        var _iterator = _createForOfIteratorHelper(corners),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var corner = _step.value;
+            var rel = new THREE__namespace.Vector3().subVectors(corner, camPos);
+            var depth = rel.dot(forward);
+            if (depth <= 0.01) return false;
+            if (Math.abs(rel.dot(right)) / depth > tanHalfH) return false;
+            if (Math.abs(rel.dot(up)) / depth > tanHalfV) return false;
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        return true;
+      };
+      var fitDistance = 0.5;
+      while (!fitsAtDistance(fitDistance) && fitDistance < 500) {
+        fitDistance *= 1.15;
+      }
+      if (fitDistance >= 500) {
+        console.warn('⚠️ fitCameraToScene: could not frame scene from ground level');
+        return false;
+      }
+
+      // Tighten to the closest distance that still fits, then apply padding.
+      var lo = 0.01;
+      var hi = fitDistance;
+      while (hi - lo > 0.1) {
+        var mid = (lo + hi) / 2;
+        if (fitsAtDistance(mid)) hi = mid;else lo = mid;
+      }
+      fitDistance = hi * padding;
+      var cameraHeight = Math.max(frameTarget.z + fitDistance * Math.tan(downwardPitch), box.min.z + HOME_CAMERA_MIN_HEIGHT);
+      var camPos = new THREE__namespace.Vector3(frameTarget.x + horizDir.x * fitDistance, frameTarget.y + horizDir.y * fitDistance, cameraHeight);
+      camera.position.copy(camPos);
+      var span = size.length();
+      camera.near = Math.max(fitDistance / 1000, 0.01);
+      camera.far = Math.max(fitDistance + span * 4, 1000);
+      camera.updateProjectionMatrix();
+      camera.lookAt(frameTarget);
+      if (controls) {
+        controls.target.copy(frameTarget);
+        controls.minDistance = Math.max(span * 0.1, 0.1);
+        controls.maxDistance = fitDistance * 4;
+        controls.update();
+      }
+      console.log("\uD83C\uDFA5 Camera framed to scene at ground level (distance: ".concat(fitDistance.toFixed(2), ", height: ").concat(cameraHeight.toFixed(2), ")"));
+      return true;
+    }
+
+    /**
+     * Bottom-center of a bounding box (centered in X/Y, at the floor in Z).
+     * @private
+     */
+  }, {
+    key: "_getBoxBottomCenter",
+    value: function _getBoxBottomCenter(box) {
+      var center = box.getCenter(new THREE__namespace.Vector3());
+      return new THREE__namespace.Vector3(center.x, center.y, box.min.z);
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_getBoxCorners",
+    value: function _getBoxCorners(box) {
+      var min = box.min,
+        max = box.max;
+      var corners = [];
+      for (var i = 0; i < 8; i++) {
+        corners.push(new THREE__namespace.Vector3(i & 1 ? max.x : min.x, i & 2 ? max.y : min.y, i & 4 ? max.z : min.z));
+      }
+      return corners;
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_fitCameraFromCenter",
+    value: function _fitCameraFromCenter(box, camera, controls, options, padding) {
+      var center = box.getCenter(new THREE__namespace.Vector3());
+      var target = controls !== null && controls !== void 0 && controls.target ? controls.target.clone() : new THREE__namespace.Vector3();
+      var direction = new THREE__namespace.Vector3();
+      if (options.direction) {
+        direction.set(options.direction.x, options.direction.y, options.direction.z);
+      } else {
+        direction.subVectors(camera.position, target);
+      }
+      if (direction.lengthSq() < 1e-6) {
+        direction.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, DEFAULT_HOME_VIEW_DIRECTION.z);
+      }
+      direction.normalize();
+      var forward = direction.clone().negate();
+      var worldUp = camera.up.clone().normalize();
+      var right = new THREE__namespace.Vector3().crossVectors(forward, worldUp);
+      if (right.lengthSq() < 1e-6) {
+        right = new THREE__namespace.Vector3().crossVectors(forward, new THREE__namespace.Vector3(1, 0, 0));
+      }
+      right.normalize();
+      var up = new THREE__namespace.Vector3().crossVectors(right, forward).normalize();
+      var vFov = THREE__namespace.MathUtils.degToRad(camera.fov);
+      var aspect = camera.aspect || 1;
+      var tanHalfV = Math.tan(vFov / 2);
+      var tanHalfH = tanHalfV * aspect;
+      var min = box.min;
+      var max = box.max;
+      var fitDistance = 0.01;
+      for (var i = 0; i < 8; i++) {
+        var v = new THREE__namespace.Vector3(i & 1 ? max.x : min.x, i & 2 ? max.y : min.y, i & 4 ? max.z : min.z).sub(center);
+        var vForward = v.dot(forward);
+        var vRight = Math.abs(v.dot(right));
+        var vUp = Math.abs(v.dot(up));
+        var cornerDistance = Math.max(vRight / tanHalfH - vForward, vUp / tanHalfV - vForward, -vForward + 0.01);
+        fitDistance = Math.max(fitDistance, cornerDistance);
+      }
+      fitDistance *= padding;
+      camera.position.copy(center).addScaledVector(direction, fitDistance);
+      var span = box.getSize(new THREE__namespace.Vector3()).length();
+      camera.near = Math.max(fitDistance / 1000, 0.01);
+      camera.far = Math.max(fitDistance + span * 4, 1000);
+      camera.updateProjectionMatrix();
+      camera.lookAt(center);
+      if (controls) {
+        controls.target.copy(center);
+        controls.minDistance = Math.max(span * 0.1, 0.1);
+        controls.maxDistance = fitDistance * 4;
+        controls.update();
+      }
+      console.log("\uD83C\uDFA5 Camera framed to scene (distance: ".concat(fitDistance.toFixed(2), ")"));
+      return true;
+    }
+
+    /**
+     * Frame the scene using the default low, ground-level home viewing angle.
+     * @param {Object} [options] - Passed to fitCameraToScene (padding, etc.)
+     * @returns {boolean}
+     */
+  }, {
+    key: "fitCameraToSceneHome",
+    value: function fitCameraToSceneHome() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.fitCameraToScene(_objectSpread2(_objectSpread2({}, options), {}, {
+        direction: DEFAULT_HOME_VIEW_DIRECTION,
+        groundLevel: true
+      }));
+    }
+
+    /**
+     * Toggle camera auto-rotation on/off
+     * 
+     * @returns {boolean} The new auto-rotation state
+     */
+  }, {
+    key: "toggleCameraRotation",
+    value: function toggleCameraRotation() {
+      var component = this.sceneViewer;
+      if (!component.controls || !component.sceneInitializationManager) {
+        console.warn('⚠️ Cannot toggle camera rotation: missing controls or sceneInitializationManager');
+        return false;
+      }
+
+      // Use the sceneInitializationManager to toggle auto-rotation
+      var isAutoRotating = component.sceneInitializationManager.toggleAutoRotation();
+
+      // Update our internal state
+      this._isAutoRotating = isAutoRotating;
+
+      // Set autoRotate speed if needed (using the stored preference)
+      if (isAutoRotating && component.controls.autoRotateSpeed !== this.autoRotateSpeed) {
+        component.controls.autoRotateSpeed = this.autoRotateSpeed;
+      }
+      console.log("\uD83D\uDD04 Camera auto-rotation ".concat(isAutoRotating ? 'enabled' : 'disabled', " via CameraControlsManager"));
+      return isAutoRotating;
+    }
+
+    /**
+     * Get the current auto-rotation state
+     * 
+     * @returns {boolean} Whether auto-rotation is enabled
+     */
+  }, {
+    key: "isAutoRotating",
+    value: function isAutoRotating() {
+      // If controls exist, sync our state with actual control state
+      if (this.sceneViewer.controls) {
+        this._isAutoRotating = this.sceneViewer.controls.autoRotate;
+      }
+      return this._isAutoRotating;
+    }
+
+    /**
+     * Directly enable or disable camera auto-rotation
+     * 
+     * @param {boolean} enable - Whether to enable auto-rotation
+     * @returns {boolean} The new auto-rotation state
+     */
+  }, {
+    key: "setAutoRotation",
+    value: function setAutoRotation(enable) {
+      var component = this.sceneViewer;
+      if (component.sceneInitializationManager) {
+        var result = component.sceneInitializationManager.toggleAutoRotation(enable);
+        this._isAutoRotating = result;
+        return result;
+      }
+      return false;
+    }
+  }]);
+}();
+
 var SceneInitializationManager = /*#__PURE__*/function () {
   function SceneInitializationManager(sceneViewer) {
     _classCallCheck(this, SceneInitializationManager);
@@ -25515,7 +26130,7 @@ var SceneInitializationManager = /*#__PURE__*/function () {
               containerWidth = containerRect.width;
               containerHeight = containerRect.height; // Create camera (Z-up coordinate system with flipped Y)
               component.camera = new THREE__namespace.PerspectiveCamera(50, containerWidth / containerHeight, 0.01, 1000);
-              component.camera.position.set(-8, -9, 2); // Flipped Y direction
+              component.camera.position.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND);
               component.camera.up.set(0, 0, 1); // Set Z as up vector
 
               // Create renderer
@@ -29209,204 +29824,344 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     }
 
     /**
-     * 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)
+     * 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)
      * @private
      */
   }, {
     key: "_enrichSceneDataWithBoundingBoxes",
     value: function _enrichSceneDataWithBoundingBoxes(sceneData) {
       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);
+      // 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) {
         // Skip computed objects ( elbows etc )
-        if (node.userData && (node.userData.isComputed === true || node.userData.objectType === 'elbow')) {
-          return node;
+        if (child.userData && (child.userData.isComputed === true || child.userData.objectType === 'elbow')) {
+          return child;
         }
 
-        // ── Enrich Segments ──
-        if (node.userData && node.userData.objectType === 'segment') {
-          var segmentObject = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.uuid);
+        // 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 = _this4.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
           if (segmentObject) {
+            // ── Cache check ──
             var hash = _this4._matrixHash(segmentObject);
-            var cached = _this4._bboxCache.get(node.uuid);
+            var cached = _this4._bboxCache.get(child.uuid);
             if (cached && cached.matrixHash === hash && cached.segmentBBox) {
-              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
-                worldBoundingBox: cached.segmentBBox
-              });
-            } 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
+              return _objectSpread2(_objectSpread2({}, child), {}, {
+                userData: _objectSpread2(_objectSpread2({}, child.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
+            _this4._bboxCache.set(child.uuid, {
+              matrixHash: hash,
+              segmentBBox: bboxData
+            });
+            return _objectSpread2(_objectSpread2({}, child), {}, {
+              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+                worldBoundingBox: bboxData
+              })
+            });
+          } else {
+            console.warn("\u26A0\uFE0F Could not find segment object in scene: ".concat(child.uuid));
           }
         }
 
-        // ── Enrich Components ──
-        else if (node.userData && node.userData.objectType === 'component') {
-          var componentObject = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.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 = _this4.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
           if (componentObject) {
+            // Explicitly update matrices for this component subtree before computing bounding boxes
             componentObject.updateMatrixWorld(true);
+
+            // ── Cache check ──
             var _hash = _this4._matrixHash(componentObject);
-            var _cached = _this4._bboxCache.get(node.uuid);
+            var _cached = _this4._bboxCache.get(child.uuid);
             if (_cached && _cached.matrixHash === _hash && _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]
+              // Rebuild enriched child from cached data
+              var _enrichedChild = _objectSpread2(_objectSpread2({}, child), {}, {
+                // Sync live transform even on cache hit just in case the manifest (child) is stale
+                position: {
+                  x: componentObject.position.x,
+                  y: componentObject.position.y,
+                  z: componentObject.position.z
+                },
+                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)
+                },
+                userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+                  worldBoundingBox: _cached.filteredBBox,
+                  position: [componentObject.position.x, componentObject.position.y, componentObject.position.z]
+                })
               });
-
-              // 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);
+              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]), {}, {
+                      position: {
+                        x: deviceBBox.userData.position[0],
+                        y: deviceBBox.userData.position[1],
+                        z: deviceBBox.userData.position[2]
+                      },
+                      userData: _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex].userData), {}, {
+                        objectType: 'io-device',
+                        worldBoundingBox: deviceBBox.worldBoundingBox,
+                        position: deviceBBox.userData.position
+                      })
+                    });
+                  } else {
+                    _enrichedChild.children.push({
+                      uuid: deviceBBox.uuid,
+                      position: {
+                        x: deviceBBox.userData.position[0],
+                        y: deviceBBox.userData.position[1],
+                        z: deviceBBox.userData.position[2]
+                      },
+                      userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
+                        worldBoundingBox: deviceBBox.worldBoundingBox,
+                        position: deviceBBox.userData.position
+                      }),
+                      children: []
+                    });
+                  }
                 });
               }
-              if (_cached.ioDeviceBBoxes) {
-                _cached.ioDeviceBBoxes.forEach(function (dev) {
-                  return _this4._mergeEnrichedChild(enrichedNode.children, dev);
+
+              // 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]), {}, {
+                      position: {
+                        x: connBBox.userData.position[0],
+                        y: connBBox.userData.position[1],
+                        z: connBBox.userData.position[2]
+                      },
+                      userData: _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex].userData), {}, {
+                        worldBoundingBox: connBBox.worldBoundingBox,
+                        position: connBBox.userData.position
+                      })
+                    });
+                  } else {
+                    _enrichedChild.children.push({
+                      uuid: connBBox.uuid,
+                      position: {
+                        x: connBBox.userData.position[0],
+                        y: connBBox.userData.position[1],
+                        z: connBBox.userData.position[2]
+                      },
+                      userData: _objectSpread2(_objectSpread2({}, connBBox.userData), {}, {
+                        worldBoundingBox: connBBox.worldBoundingBox,
+                        position: connBBox.userData.position
+                      }),
+                      children: []
+                    });
+                  }
                 });
               }
-            } 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 = {
+              return _enrichedChild;
+            }
+
+            // 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]
+            };
+
+            // Build the enriched component entry
+            var enrichedChild = _objectSpread2(_objectSpread2({}, child), {}, {
+              // Sync live transform to ensure pathfinder has latest coordinates
+              position: {
                 x: componentObject.position.x,
                 y: componentObject.position.y,
                 z: componentObject.position.z
-              };
-              enrichedNode.rotation = {
+              },
+              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), {}, {
+              },
+              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
                 worldBoundingBox: _bboxData,
                 position: [componentObject.position.x, componentObject.position.y, componentObject.position.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]), {}, {
+                    position: {
+                      x: deviceBBox.userData.position[0],
+                      y: deviceBBox.userData.position[1],
+                      z: deviceBBox.userData.position[2]
+                    },
+                    userData: _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex].userData), {}, {
+                      objectType: 'io-device',
+                      worldBoundingBox: deviceBBox.worldBoundingBox,
+                      position: deviceBBox.userData.position
+                    })
+                  });
+                } else {
+                  enrichedChild.children.push({
+                    uuid: deviceBBox.uuid,
+                    position: {
+                      x: deviceBBox.userData.position[0],
+                      y: deviceBBox.userData.position[1],
+                      z: deviceBBox.userData.position[2]
+                    },
+                    userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
+                      worldBoundingBox: deviceBBox.worldBoundingBox,
+                      position: deviceBBox.userData.position
+                    }),
+                    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(', '), "]"));
               });
-              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
+              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]), {}, {
+                    position: {
+                      x: connBBox.userData.position[0],
+                      y: connBBox.userData.position[1],
+                      z: connBBox.userData.position[2]
+                    },
+                    userData: _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex].userData), {}, {
+                      worldBoundingBox: connBBox.worldBoundingBox,
+                      position: connBBox.userData.position
+                    })
+                  });
+                } else {
+                  enrichedChild.children.push({
+                    uuid: connBBox.uuid,
+                    position: {
+                      x: connBBox.userData.position[0],
+                      y: connBBox.userData.position[1],
+                      z: connBBox.userData.position[2]
+                    },
+                    userData: _objectSpread2(_objectSpread2({}, connBBox.userData), {}, {
+                      worldBoundingBox: connBBox.worldBoundingBox,
+                      position: connBBox.userData.position
+                    }),
+                    children: []
+                  });
+                }
               });
             }
+
+            // Store in cache
+            _this4._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));
           }
         }
 
-        // ── 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);
+        // ────────────────────────────────────────────────────────────────────────
+        // PHASE 3: Handle top-level Gateways and Connectors
+        // ────────────────────────────────────────────────────────────────────────
+        if (child.userData && (child.userData.objectType === 'gateway' || child.userData.objectType === 'connector')) {
+          var _child$userData;
+          var object = _this4.sceneViewer.scene.getObjectByProperty('uuid', child.uuid) || _this4.sceneViewer.scene.getObjectByProperty('uuid', (_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid);
           if (object) {
             var worldPos = new THREE__namespace.Vector3();
             object.getWorldPosition(worldPos);
-            enrichedNode.position = {
-              x: worldPos.x,
-              y: worldPos.y,
-              z: worldPos.z
-            };
-            enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
-              position: [worldPos.x, worldPos.y, worldPos.z]
+            return _objectSpread2(_objectSpread2({}, child), {}, {
+              // Sync live transform to ensure pathfinder has latest coordinates
+              position: {
+                x: worldPos.x,
+                y: worldPos.y,
+                z: worldPos.z
+              },
+              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+                position: [worldPos.x, worldPos.y, worldPos.z]
+              })
             });
-
-            // 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];
-            }
           }
         }
 
-        // 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);
-      }
+        // For non-segments and non-components (and if object search failed), return as-is
+        return child;
+      });
+      return enriched;
     }
 
     /**
-     * Helper to merge an enriched child (connector/device) into a children array
-     * @private
+     * Core pathfinding logic shared across initialization and updates
      */
-  }, {
-    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 _this5 = this,
           _sceneDataCopy$childr,
@@ -29581,7 +30336,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
         return _executePathfinding2.apply(this, arguments);
       }
       return _executePathfinding;
-    }()
+    }())
   }, {
     key: "getSimplifiedSceneData",
     value: function getSimplifiedSceneData() {
@@ -34091,6 +34846,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "_finalizeScene",
     value: function _finalizeScene(data, crosscubeTextureSet, isImported) {
+      var _component$cameraCont;
       var component = this.sceneViewer;
       component.currentSceneData = data;
       component.crosscubeTextureSet = crosscubeTextureSet;
@@ -34102,6 +34858,14 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         }
         this._setTransformControlsState(true, false); // Enable but keep hidden initially
       }
+
+      // Frame the camera so all components fit perfectly in view (low, ground-level angle)
+      if ((_component$cameraCont = component.cameraControlsManager) !== null && _component$cameraCont !== void 0 && _component$cameraCont.fitCameraToScene) {
+        component.cameraControlsManager.fitCameraToScene({
+          direction: DEFAULT_HOME_VIEW_DIRECTION,
+          groundLevel: true
+        });
+      }
     }
 
     /**
@@ -34984,82 +35748,6 @@ var AnimationManager = /*#__PURE__*/function (_BaseDisposable) {
   }]);
 }(BaseDisposable);
 
-/**
- * CameraControlsManager
- * Handles camera movement, rotation, and other camera-specific controls
- */
-
-var CameraControlsManager = /*#__PURE__*/function () {
-  function CameraControlsManager(component) {
-    _classCallCheck(this, CameraControlsManager);
-    this.sceneViewer = component;
-    this.autoRotateSpeed = 1.0; // Default rotation speed
-    this._isAutoRotating = false; // Internal state tracking
-  }
-
-  /**
-   * Toggle camera auto-rotation on/off
-   * 
-   * @returns {boolean} The new auto-rotation state
-   */
-  return _createClass(CameraControlsManager, [{
-    key: "toggleCameraRotation",
-    value: function toggleCameraRotation() {
-      var component = this.sceneViewer;
-      if (!component.controls || !component.sceneInitializationManager) {
-        console.warn('⚠️ Cannot toggle camera rotation: missing controls or sceneInitializationManager');
-        return false;
-      }
-
-      // Use the sceneInitializationManager to toggle auto-rotation
-      var isAutoRotating = component.sceneInitializationManager.toggleAutoRotation();
-
-      // Update our internal state
-      this._isAutoRotating = isAutoRotating;
-
-      // Set autoRotate speed if needed (using the stored preference)
-      if (isAutoRotating && component.controls.autoRotateSpeed !== this.autoRotateSpeed) {
-        component.controls.autoRotateSpeed = this.autoRotateSpeed;
-      }
-      console.log("\uD83D\uDD04 Camera auto-rotation ".concat(isAutoRotating ? 'enabled' : 'disabled', " via CameraControlsManager"));
-      return isAutoRotating;
-    }
-
-    /**
-     * Get the current auto-rotation state
-     * 
-     * @returns {boolean} Whether auto-rotation is enabled
-     */
-  }, {
-    key: "isAutoRotating",
-    value: function isAutoRotating() {
-      // If controls exist, sync our state with actual control state
-      if (this.sceneViewer.controls) {
-        this._isAutoRotating = this.sceneViewer.controls.autoRotate;
-      }
-      return this._isAutoRotating;
-    }
-
-    /**
-     * Directly enable or disable camera auto-rotation
-     * 
-     * @param {boolean} enable - Whether to enable auto-rotation
-     * @returns {boolean} The new auto-rotation state
-     */
-  }, {
-    key: "setAutoRotation",
-    value: function setAutoRotation(enable) {
-      var component = this.sceneViewer;
-      if (component.sceneInitializationManager) {
-        var result = component.sceneInitializationManager.toggleAutoRotation(enable);
-        this._isAutoRotating = result;
-        return result;
-      }
-      return false;
-    }
-  }]);
-}();
-
 /**
  * ComponentDragManager handles drag and drop from external UI elements to the 3D scene
  */
@@ -41125,7 +41813,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.3.49
+   * @version 0.3.51
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -43001,6 +43689,98 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       }
     }
 
+    /**
+     * Get the world-space axis-aligned bounding box for a scene object.
+     * @param {string|THREE.Object3D} objectOrId - The object's UUID/name, or the Three.js object itself
+     * @param {Object} [options={}] - Bounding box options
+     * @param {boolean} [options.filtered=true] - When true, exclude connector and io-device
+     *   subtrees so the box reflects the component body footprint. When false, the box
+     *   envelops all descendants (equivalent to THREE.Box3.setFromObject).
+     * @param {string[]} [options.excludeTypes] - Override the userData.objectType values to
+     *   exclude (defaults to ['io-device', 'connector'] when filtered is true).
+     * @returns {{min: {x,y,z}, max: {x,y,z}, size: {x,y,z}, center: {x,y,z}}|null}
+     *   The bounding box descriptor in world space, or null if the object can't be found
+     *   or has no geometry.
+     * @description Computes a tight world-space bounding box for a component (or any scene
+     * object). By default the component body is measured independently of its attached
+     * connectors and io-devices, which is useful for layout and spacing operations.
+     * @example
+     * // Component body bounding box (excludes connectors / io-devices)
+     * const bbox = centralPlant.getBoundingBox('PUMP-1');
+     * console.log(bbox.size.x, bbox.size.y, bbox.size.z);
+     *
+     * @example
+     * // Full bounding box including connectors and io-devices
+     * const fullBox = centralPlant.getBoundingBox('PUMP-1', { filtered: false });
+     *
+     * @since 0.3.50
+     */
+  }, {
+    key: "getBoundingBox",
+    value: function getBoundingBox(objectOrId) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.warn('⚠️ getBoundingBox(): Scene viewer or scene not available');
+        return null;
+      }
+      var _options$filtered = options.filtered,
+        filtered = _options$filtered === void 0 ? true : _options$filtered,
+        excludeTypes = options.excludeTypes;
+
+      // Resolve the target object
+      var object = objectOrId;
+      if (typeof objectOrId === 'string') {
+        object = this.sceneViewer.scene.getObjectByProperty('uuid', objectOrId) || this.sceneViewer.scene.getObjectByProperty('name', objectOrId);
+        if (!object) {
+          // Fall back to a full traverse (matches translate's lookup by originalUuid)
+          this.sceneViewer.scene.traverse(function (child) {
+            var _child$userData2;
+            if (!object && ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.originalUuid) === objectOrId) {
+              object = child;
+            }
+          });
+        }
+      }
+      if (!object || typeof object.traverse !== 'function') {
+        console.warn("\u26A0\uFE0F getBoundingBox(): Object '".concat(objectOrId, "' not found in scene"));
+        return null;
+      }
+      try {
+        var typesToExclude = filtered ? excludeTypes || ['io-device', 'connector'] : [];
+        var box = computeFilteredBoundingBox(object, typesToExclude);
+        if (box.isEmpty()) {
+          return null;
+        }
+        var size = box.getSize(new THREE__namespace.Vector3());
+        var center = box.getCenter(new THREE__namespace.Vector3());
+        return {
+          min: {
+            x: box.min.x,
+            y: box.min.y,
+            z: box.min.z
+          },
+          max: {
+            x: box.max.x,
+            y: box.max.y,
+            z: box.max.z
+          },
+          size: {
+            x: size.x,
+            y: size.y,
+            z: size.z
+          },
+          center: {
+            x: center.x,
+            y: center.y,
+            z: center.z
+          }
+        };
+      } catch (error) {
+        console.error('❌ getBoundingBox(): Error computing bounding box:', error);
+        return null;
+      }
+    }
+
     /**
      * Get available component categories
      * @returns {Array<Object>} Array of category objects with id, label, icon, and description
@@ -43235,8 +44015,8 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       var componentDictionary = ((_this$managers$compon = this.managers.componentDataManager) === null || _this$managers$compon === void 0 ? void 0 : _this$managers$compon.componentDictionary) || {};
       var missingIds = [];
       sceneData.scene.children.forEach(function (child) {
-        var _child$userData2;
-        var libraryId = (_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.libraryId;
+        var _child$userData3;
+        var libraryId = (_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.libraryId;
         if (libraryId && !componentDictionary[libraryId]) {
           // Only add unique IDs
           if (!missingIds.includes(libraryId)) {
@@ -43314,8 +44094,8 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       // If still not found, try finding by originalUuid in userData
       if (!targetObject) {
         this.sceneViewer.scene.traverse(function (child) {
-          var _child$userData3;
-          if (((_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.originalUuid) === objectId) {
+          var _child$userData4;
+          if (((_child$userData4 = child.userData) === null || _child$userData4 === void 0 ? void 0 : _child$userData4.originalUuid) === objectId) {
             targetObject = child;
             return;
           }
@@ -49940,9 +50720,11 @@ exports.ComponentDataManager = ComponentDataManager;
 exports.ComponentDragManager = ComponentDragManager;
 exports.ComponentManager = ComponentManager;
 exports.ComponentTooltipManager = ComponentTooltipManager;
+exports.DEFAULT_HOME_VIEW_DIRECTION = DEFAULT_HOME_VIEW_DIRECTION;
 exports.EnvironmentManager = EnvironmentManager;
 exports.FLOW_ATTRIBUTE_KEYS = FLOW_ATTRIBUTE_KEYS;
 exports.GLOBAL_CACHE_NAME = GLOBAL_CACHE_NAME;
+exports.HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND = HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND;
 exports.IoBehaviorManager = IoBehaviorManager;
 exports.KeyboardControlsManager = KeyboardControlsManager;
 exports.ModelManager = ModelManager;