@2112-lab/central-plant 0.1.39 → 0.1.41

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

@@ -1,19 +1,21 @@
-import { createClass as _createClass, objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { CentralPlantValidator } from './centralPlantValidator.js';
 import { createTransformControls } from '../managers/controls/transformControlsManager.js';
 import { ThreeJSResourceManager } from '../managers/system/threeJSResourceManager.js';
 import { PerformanceMonitorManager } from '../managers/system/performanceMonitorManager.js';
 import { SettingsManager } from '../managers/system/settingsManager.js';
+import { OperationHistoryManager } from '../managers/system/operationHistoryManager.js';
 import { SceneExportManager } from '../managers/scene/sceneExportManager.js';
 import { ComponentManager } from '../managers/components/componentManager.js';
 import { ComponentDataManager } from '../managers/components/componentDataManager.js';
+import { TransformOperationsManager } from '../managers/components/transformOperationsManager.js';
 import { SceneInitializationManager } from '../managers/scene/sceneInitializationManager.js';
 import { EnvironmentManager } from '../managers/environment/environmentManager.js';
 import { KeyboardControlsManager } from '../managers/controls/keyboardControlsManager.js';
-import { PathfindingManager } from '../managers/components/pathfindingManager.js';
+import { PathfindingManager } from '../managers/pathfinding/pathfindingManager.js';
 import { SceneOperationsManager } from '../managers/scene/sceneOperationsManager.js';
-import { AnimationManager } from '../managers/components/animationManager.js';
+import { AnimationManager } from '../managers/scene/animationManager.js';
 import { CameraControlsManager } from '../managers/controls/cameraControlsManager.js';
 import { ComponentDragManager } from '../managers/controls/componentDragManager.js';
 import { SceneTooltipsManager } from '../managers/scene/sceneTooltipsManager.js';
@@ -73,9 +75,11 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       this.centralPlant.managers.threeJSResourceManager = new ThreeJSResourceManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.performanceMonitorManager = new PerformanceMonitorManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.settingsManager = new SettingsManager(this.centralPlant.sceneViewer);
+      this.centralPlant.managers.operationHistoryManager = new OperationHistoryManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.sceneExportManager = new SceneExportManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.componentManager = new ComponentManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.componentDataManager = new ComponentDataManager(this.centralPlant.sceneViewer);
+      this.centralPlant.managers.transformOperationsManager = new TransformOperationsManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.sceneInitializationManager = new SceneInitializationManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.environmentManager = new EnvironmentManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.keyboardControlsManager = new KeyboardControlsManager(this.centralPlant.sceneViewer);
@@ -373,7 +377,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
     // ===== TRANSFORM OPERATIONS =====
 
     /**
-     * Translate a component by componentId (internal implementation)
+     * Translate a component by componentId (delegates to TransformOperationsManager)
      * @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
@@ -382,78 +386,16 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "translateComponent",
     value: function translateComponent(componentId, axis, value) {
-      var _this$centralPlant$sc2, _this$centralPlant$sc3;
-      // Use centralized validator for parameter validation
-      var validation = this.validator.validateTransformationParams(componentId, axis, value, {
-        operation: 'translate'
-      });
-      if (!validation.isValid) {
-        return false; // Validator already logged the error
-      }
-
-      // Validate scene availability
-      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc2 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc2 === void 0 ? void 0 : _this$centralPlant$sc2.scene);
-      if (!sceneValidation.isValid) {
-        return false;
-      }
-
-      // Find the component in the scene
-      var component = null;
-      this.centralPlant.sceneViewer.scene.traverse(function (child) {
-        var _child$userData;
-        if (child.uuid === componentId || ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid) === componentId) {
-          component = child;
-        }
-      });
-      if (!component) {
-        console.error("\u274C translateComponent(): Component with ID '".concat(componentId, "' not found in scene"));
-        return false;
-      }
-
-      // Validate that it's actually a component
-      if (!component.userData || !component.userData.objectType) {
-        console.error("\u274C translateComponent(): Object with ID '".concat(componentId, "' is not a valid component"));
+      var _this$centralPlant$ma;
+      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;
       }
-
-      // Apply the translation
-      console.log("\uD83D\uDD04 translateComponent(): Translating component ".concat(componentId, " on ").concat(axis, " axis by ").concat(value));
-
-      // Update the Three.js object position
-      component.position[axis] += value;
-
-      // Update world bounding boxes for the component and its children
-      this.updateWorldBoundingBoxes(component);
-
-      // Update matrices
-      component.updateMatrix();
-      component.updateMatrixWorld(true);
-
-      // Check if component is underground and fix if needed (based on settings)
-      var checkUnderground = (_this$centralPlant$sc3 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc3 === void 0 || (_this$centralPlant$sc3 = _this$centralPlant$sc3.managers) === null || _this$centralPlant$sc3 === void 0 || (_this$centralPlant$sc3 = _this$centralPlant$sc3.settingsManager) === null || _this$centralPlant$sc3 === void 0 ? void 0 : _this$centralPlant$sc3.getSetting('scene', 'checkUnderground');
-      if (checkUnderground) {
-        var wasFixed = this.fixUndergroundComponent(component);
-        if (wasFixed) {
-          // Update bounding boxes again after fixing position
-          this.updateWorldBoundingBoxes(component);
-        }
-      }
-
-      // Emit transform event if available
-      if (this.centralPlant.sceneViewer.emit && typeof this.centralPlant.sceneViewer.emit === 'function') {
-        this.centralPlant.sceneViewer.emit('objectTransformed', {
-          object: component,
-          transformType: 'translate',
-          axis: axis,
-          value: value
-        });
-      }
-      console.log("\u2705 translateComponent(): Component ".concat(componentId, " translated successfully"));
-      return true;
+      return this.centralPlant.managers.transformOperationsManager.translateComponent(componentId, axis, value);
     }
 
     /**
-     * Translate a pipe segment by segmentId (internal implementation)
+     * Translate a pipe segment by segmentId (delegates to TransformOperationsManager)
      * @param {string} segmentId - The UUID of the pipe segment to translate
      * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
      * @param {number} value - The value to translate by
@@ -462,129 +404,16 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "translateSegment",
     value: function translateSegment(segmentId, axis, value) {
-      var _this$centralPlant$sc4, _this$centralPlant$ma;
-      // Use centralized validator for parameter validation
-      var validation = this.validator.validateTransformationParams(segmentId, axis, value, {
-        operation: 'translate'
-      });
-      if (!validation.isValid) {
-        return false; // Validator already logged the error
-      }
-
-      // Validate scene availability
-      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc4 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc4 === void 0 ? void 0 : _this$centralPlant$sc4.scene);
-      if (!sceneValidation.isValid) {
-        return false;
-      }
-
-      // Find the segment in the scene
-      var segment = null;
-      this.centralPlant.sceneViewer.scene.traverse(function (child) {
-        var _child$userData2;
-        if (child.uuid === segmentId || ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.originalUuid) === segmentId) {
-          segment = child;
-        }
-      });
-      if (!segment) {
-        console.error("\u274C translateSegment(): Segment with ID '".concat(segmentId, "' not found in scene"));
-        return false;
-      }
-
-      // Validate that it's actually a pipe segment
-      if (!segment.userData || !segment.userData.isPipeSegment) {
-        console.error("\u274C translateSegment(): Object with ID '".concat(segmentId, "' is not a valid pipe segment"));
-        return false;
-      }
-
-      // Check if segment is horizontal (only horizontal segments can be translated)
-      if (!this.isSegmentHorizontal(segment)) {
-        console.warn("\u26A0\uFE0F translateSegment(): Segment '".concat(segmentId, "' is not horizontal. Only horizontal segments can be translated."));
-        console.log('   Segment orientation: vertical or diagonal');
+      var _this$centralPlant$ma2;
+      if (!((_this$centralPlant$ma2 = this.centralPlant.managers) !== null && _this$centralPlant$ma2 !== void 0 && _this$centralPlant$ma2.transformOperationsManager)) {
+        console.error('❌ translateSegment(): TransformOperationsManager not available');
         return false;
       }
-      console.log('[translateSegment] segment:', segment);
-
-      // Calculate segment endpoints to check for nearby connectors
-      var segmentEndpoints = this.calculateSegmentEndpoints(segment);
-
-      // Check if there are any connectors (component or manual) at segment endpoints
-      var connectorsAtEndpoints = this.findConnectorsAtPositions([segmentEndpoints.start, segmentEndpoints.end], 0.15 // tolerance for position matching
-      );
-
-      // Filter out segment connectors - we only care about component connectors
-      var componentConnectorsAtEndpoints = connectorsAtEndpoints.filter(function (connector) {
-        var _connector$userData;
-        return !((_connector$userData = connector.userData) !== null && _connector$userData !== void 0 && _connector$userData.isManualSegmentConnector);
-      });
-      if (componentConnectorsAtEndpoints.length > 0) {
-        console.warn("\u26A0\uFE0F translateSegment(): Segment '".concat(segmentId, "' has component connectors at endpoints. Cannot translate."));
-        console.log("   Found ".concat(componentConnectorsAtEndpoints.length, " component connector(s):"), componentConnectorsAtEndpoints.map(function (c) {
-          var _c$parent;
-          return {
-            uuid: c.uuid,
-            parent: (_c$parent = c.parent) === null || _c$parent === void 0 ? void 0 : _c$parent.uuid
-          };
-        }));
-        return false;
-      }
-      console.log("\uD83D\uDD04 translateSegment(): Translating segment ".concat(segmentId, " on ").concat(axis, " axis by ").concat(value));
-
-      // Apply the translation to the Three.js object
-      segment.position[axis] += value;
-
-      // Update matrices
-      segment.updateMatrix();
-      segment.updateMatrixWorld(true);
-      var pathfindingManager = (_this$centralPlant$ma = this.centralPlant.managers) === null || _this$centralPlant$ma === void 0 ? void 0 : _this$centralPlant$ma.pathfindingManager;
-      if (!pathfindingManager) {
-        console.error('❌ translateSegment(): PathfindingManager not available');
-        return false;
-      }
-
-      // Check if segment is already declared - if not, manualize it first
-      if (segment.userData.isDeclared !== true) {
-        console.log('🔌 Handling manual segment transformation via PathfindingManager (first move)');
-        try {
-          pathfindingManager.manualizeSegment(segment, this.centralPlant.sceneViewer.currentSceneData);
-        } catch (error) {
-          console.error('❌ translateSegment(): Error in manualizeSegment:', error);
-          return false;
-        }
-      } else {
-        console.log('🔄 Segment already declared, updating connector positions (subsequent move)');
-      }
-
-      // ALWAYS update connector positions after segment movement (first or subsequent moves)
-      this.updateSegmentConnectorPositions(segment);
-
-      // Regenerate paths to create new pipe segments that connect to the moved segment
-      console.log('🔄 Regenerating paths to create connecting pipe segments...');
-      try {
-        if (this.centralPlant.sceneViewer && typeof this.centralPlant.sceneViewer.updatePaths === 'function') {
-          this.centralPlant.sceneViewer.updatePaths();
-          console.log('✅ Paths regenerated successfully - new connecting segments created');
-        } else {
-          console.warn('⚠️ updatePaths method not available on sceneViewer');
-        }
-      } catch (error) {
-        console.error('❌ Error regenerating paths:', error);
-      }
-
-      // Emit transform event if available
-      if (this.centralPlant.sceneViewer.emit && typeof this.centralPlant.sceneViewer.emit === 'function') {
-        this.centralPlant.sceneViewer.emit('objectTransformed', {
-          object: segment,
-          transformType: 'translateSegment',
-          axis: axis,
-          value: value
-        });
-      }
-      console.log("\u2705 translateSegment(): Segment ".concat(segmentId, " translated and connections restructured successfully"));
-      return true;
+      return this.centralPlant.managers.transformOperationsManager.translateSegment(segmentId, axis, value);
     }
 
     /**
-     * Translate a gateway by gatewayId (internal implementation)
+     * Translate a gateway by gatewayId (delegates to TransformOperationsManager)
      * @param {string} gatewayId - The UUID of the gateway to translate
      * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
      * @param {number} value - The value to translate by
@@ -593,95 +422,16 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "translateGateway",
     value: function translateGateway(gatewayId, axis, value) {
-      var _this$centralPlant$sc5, _this$centralPlant$ma2;
-      console.log("[Pathfinder] translateGateway started");
-      // Use centralized validator for parameter validation
-      var validation = this.validator.validateTransformationParams(gatewayId, axis, value, {
-        operation: 'translate'
-      });
-      if (!validation.isValid) {
-        return false; // Validator already logged the error
-      }
-
-      // Validate scene availability
-      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc5 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc5 === void 0 ? void 0 : _this$centralPlant$sc5.scene);
-      if (!sceneValidation.isValid) {
-        return false;
-      }
-
-      // Find the gateway in the scene
-      var gateway = null;
-      this.centralPlant.sceneViewer.scene.traverse(function (child) {
-        var _child$userData3;
-        if (child.uuid === gatewayId || ((_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.originalUuid) === gatewayId) {
-          gateway = child;
-        }
-      });
-      if (!gateway) {
-        console.error("\u274C translateGateway(): Gateway with ID '".concat(gatewayId, "' not found in scene"));
-        return false;
-      }
-
-      // Validate that it's actually a gateway
-      if (!gateway.userData || gateway.userData.objectType !== 'gateway') {
-        console.error("\u274C translateGateway(): Object with ID '".concat(gatewayId, "' is not a valid gateway"));
-        return false;
-      }
-
-      // Check if gateway is already declared - allow re-translation of declared gateways
-      // (unlike segments, gateways can be moved multiple times)
-
-      console.log("\uD83D\uDD04 translateGateway(): Translating gateway ".concat(gatewayId, " on ").concat(axis, " axis by ").concat(value));
-
-      // Apply the translation to the Three.js object
-      gateway.position[axis] += value;
-
-      // Update matrices
-      gateway.updateMatrix();
-      gateway.updateMatrixWorld(true);
-
-      // Handle manual gateway transformation (convert to declared and process connections)
-      console.log('🔧 Handling manual gateway transformation via PathfindingManager');
-      var pathfindingManager = (_this$centralPlant$ma2 = this.centralPlant.managers) === null || _this$centralPlant$ma2 === void 0 ? void 0 : _this$centralPlant$ma2.pathfindingManager;
-      if (!pathfindingManager) {
-        console.error('❌ translateGateway(): PathfindingManager not available');
+      var _this$centralPlant$ma3;
+      if (!((_this$centralPlant$ma3 = this.centralPlant.managers) !== null && _this$centralPlant$ma3 !== void 0 && _this$centralPlant$ma3.transformOperationsManager)) {
+        console.error('❌ translateGateway(): TransformOperationsManager not available');
         return false;
       }
-      try {
-        pathfindingManager.manualizeGateway(gateway, this.centralPlant.sceneViewer.currentSceneData);
-      } catch (error) {
-        console.error('❌ translateGateway(): Error in manualizeGateway:', error);
-        return false;
-      }
-
-      // Regenerate paths to reflect the gateway's new position
-      console.log('🔄 Regenerating paths to reflect gateway movement...');
-      try {
-        if (this.centralPlant.sceneViewer && typeof this.centralPlant.sceneViewer.updatePaths === 'function') {
-          this.centralPlant.sceneViewer.updatePaths();
-          console.log('✅ Paths regenerated successfully - routing updated for new gateway position');
-        } else {
-          console.warn('⚠️ updatePaths method not available on sceneViewer');
-        }
-      } catch (error) {
-        console.error('❌ Error regenerating paths:', error);
-      }
-
-      // Emit transform event if available
-      if (this.centralPlant.sceneViewer.emit && typeof this.centralPlant.sceneViewer.emit === 'function') {
-        this.centralPlant.sceneViewer.emit('objectTransformed', {
-          object: gateway,
-          transformType: 'translateGateway',
-          axis: axis,
-          value: value
-        });
-      }
-      console.log("\u2705 translateGateway(): Gateway ".concat(gatewayId, " translated and marked as declared successfully"));
-      return true;
+      return this.centralPlant.managers.transformOperationsManager.translateGateway(gatewayId, axis, value);
     }
 
     /**
-     * Rotate a component by componentId (internal implementation)
+     * Rotate a component by componentId (delegates to TransformOperationsManager)
      * @param {string} componentId - The UUID of the component to rotate
      * @param {string} axis - The axis to rotate around ('x', 'y', or 'z')
      * @param {number} value - The value to rotate by in degrees
@@ -690,81 +440,16 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "rotateComponent",
     value: function rotateComponent(componentId, axis, value) {
-      var _this$centralPlant$sc6;
-      // Use centralized validator for parameter validation
-      var validation = this.validator.validateTransformationParams(componentId, axis, value, {
-        operation: 'rotate'
-      });
-      if (!validation.isValid) {
-        return false; // Validator already logged the error
-      }
-
-      // Validate scene availability
-      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc6 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc6 === void 0 ? void 0 : _this$centralPlant$sc6.scene);
-      if (!sceneValidation.isValid) {
+      var _this$centralPlant$ma4;
+      if (!((_this$centralPlant$ma4 = this.centralPlant.managers) !== null && _this$centralPlant$ma4 !== void 0 && _this$centralPlant$ma4.transformOperationsManager)) {
+        console.error('❌ rotateComponent(): TransformOperationsManager not available');
         return false;
       }
-
-      // Find the component in the scene
-      var component = null;
-      this.centralPlant.sceneViewer.scene.traverse(function (child) {
-        var _child$userData4;
-        if (child.uuid === componentId || ((_child$userData4 = child.userData) === null || _child$userData4 === void 0 ? void 0 : _child$userData4.originalUuid) === componentId) {
-          component = child;
-        }
-      });
-      if (!component) {
-        console.error("\u274C rotateComponent(): Component with ID '".concat(componentId, "' not found in scene"));
-        return false;
-      }
-      if (!component.userData.libraryId) {
-        console.error("\u274C rotateComponent(): Object with ID '".concat(componentId, "' is not a valid component"));
-        return false;
-      }
-
-      // Store previous rotation for potential undo
-      var previousRotation = {
-        x: component.rotation.x,
-        y: component.rotation.y,
-        z: component.rotation.z
-      };
-
-      // Convert degrees to radians
-      var radians = value * Math.PI / 180;
-      console.log("\uD83D\uDD04 rotateComponent(): Rotating component ".concat(componentId, " around ").concat(axis, " axis by ").concat(value, " degrees (").concat(radians, " radians)"));
-
-      // Apply the rotation
-      component.rotation[axis] += radians;
-
-      // Update direction vectors for connectors if this is a 90-degree rotation
-      if (value % 90 === 0) {
-        this.updateConnectorDirections(component, axis, value);
-      }
-
-      // Update world bounding boxes for the component and its children
-      this.updateWorldBoundingBoxes(component);
-
-      // Update matrices
-      component.updateMatrix();
-      component.updateMatrixWorld(true);
-
-      // Emit transform event if available
-      if (this.centralPlant.sceneViewer.emit && typeof this.centralPlant.sceneViewer.emit === 'function') {
-        this.centralPlant.sceneViewer.emit('objectTransformed', {
-          object: component,
-          transformType: 'rotate',
-          axis: axis,
-          value: value,
-          radians: radians,
-          previousRotation: previousRotation
-        });
-      }
-      console.log("\u2705 rotateComponent(): Component ".concat(componentId, " rotated successfully"));
-      return true;
+      return this.centralPlant.managers.transformOperationsManager.rotateComponent(componentId, axis, value);
     }
 
     /**
-     * Update connector direction vectors after component rotation
+     * Update connector direction vectors after component rotation (delegates to TransformOperationsManager)
      * @param {THREE.Object3D} component - The component that was rotated
      * @param {string} axis - The axis of rotation ('x', 'y', or 'z')
      * @param {number} degrees - The rotation angle in degrees (should be multiple of 90)
@@ -773,121 +458,52 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "updateConnectorDirections",
     value: function updateConnectorDirections(component, axis, degrees) {
-      if (!component || degrees % 90 !== 0) {
+      var _this$centralPlant$ma5;
+      if (!((_this$centralPlant$ma5 = this.centralPlant.managers) !== null && _this$centralPlant$ma5 !== void 0 && _this$centralPlant$ma5.transformOperationsManager)) {
+        console.warn('⚠️ updateConnectorDirections(): TransformOperationsManager not available');
         return;
       }
-      console.log("\uD83D\uDD04 Updating connector directions after ".concat(degrees, "\xB0 rotation around ").concat(axis, " axis"));
-
-      // Simple approach: just log that directions may need manual verification
-      // In most cases, Three.js world matrices handle the actual positioning correctly
-      component.traverse(function (child) {
-        var _child$userData5, _child$userData6;
-        if (((_child$userData5 = child.userData) === null || _child$userData5 === void 0 ? void 0 : _child$userData5.objectType) === 'connector' && (_child$userData6 = child.userData) !== null && _child$userData6 !== void 0 && _child$userData6.direction) {
-          console.log("\uD83D\uDCCD Connector ".concat(child.uuid, " direction may need verification after rotation"));
-        }
-      });
+      return this.centralPlant.managers.transformOperationsManager.updateConnectorDirections(component, axis, degrees);
     }
 
     /**
-     * Update world bounding boxes for a component after transformation
-     * @param {THREE.Object3D} component - The component that was transformed
-     * @private
-     */
-  }, {
-    key: "updateWorldBoundingBoxes",
-    value: function updateWorldBoundingBoxes(component) {
-      if (!component) {
-        return;
-      }
-      try {
-        var _this$centralPlant$sc7, _this$centralPlant$sc8;
-        // Force matrix updates to ensure accurate bounding box calculation
-        component.updateMatrix();
-        component.updateMatrixWorld(true);
-
-        // Trigger the pathfinding manager's recompute method if available
-        if ((_this$centralPlant$sc7 = this.centralPlant.sceneViewer) !== null && _this$centralPlant$sc7 !== void 0 && _this$centralPlant$sc7.pathfindingManager && (_this$centralPlant$sc8 = this.centralPlant.sceneViewer) !== null && _this$centralPlant$sc8 !== void 0 && _this$centralPlant$sc8.currentSceneData && typeof this.centralPlant.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes === 'function') {
-          this.centralPlant.sceneViewer.pathfindingManager.recomputeWorldBoundingBoxes(this.centralPlant.sceneViewer.currentSceneData);
-          console.log('📦 Updated bounding boxes for pathfinding after transform');
-        }
-      } catch (error) {
-        console.warn('⚠️ Error updating bounding boxes:', error);
-      }
-    }
-
-    /**
-     * Check if a component is positioned underground (below Z=0 in Z-up coordinate system)
+     * Check if a component is positioned underground (delegates to TransformOperationsManager)
      * @param {THREE.Object3D} component - The component to check
      * @returns {Object} Object with { isUnderground: boolean, lowestZ: number, correction: number }
      */
   }, {
     key: "checkComponentUnderground",
     value: function checkComponentUnderground(component) {
-      if (!component) {
-        return {
-          isUnderground: false,
-          lowestZ: 0,
-          correction: 0
-        };
-      }
-      try {
-        // Calculate bounding box in world coordinates
-        var boundingBox = new THREE.Box3().setFromObject(component);
-
-        // In Z-up coordinate system, ground is at z=0
-        // Check the lowest Z point of the bounding box
-        var lowestZ = boundingBox.min.z;
-        var isUnderground = lowestZ < 0;
-
-        // Calculate how much we need to move up to put the lowest point at ground level
-        var correction = isUnderground ? Math.abs(lowestZ) : 0;
-        return {
-          isUnderground: isUnderground,
-          lowestZ: lowestZ,
-          correction: correction
-        };
-      } catch (error) {
-        console.warn('⚠️ Error checking component underground status:', error);
+      var _this$centralPlant$ma6;
+      if (!((_this$centralPlant$ma6 = this.centralPlant.managers) !== null && _this$centralPlant$ma6 !== void 0 && _this$centralPlant$ma6.transformOperationsManager)) {
+        console.warn('⚠️ checkComponentUnderground(): TransformOperationsManager not available');
         return {
           isUnderground: false,
           lowestZ: 0,
           correction: 0
         };
       }
+      return this.centralPlant.managers.transformOperationsManager.checkComponentUnderground(component);
     }
 
     /**
-     * Fix component position if it's underground
+     * Fix component position if it's underground (delegates to TransformOperationsManager)
      * @param {THREE.Object3D} component - The component to fix
      * @returns {boolean} True if component was adjusted, false otherwise
      */
   }, {
     key: "fixUndergroundComponent",
     value: function fixUndergroundComponent(component) {
-      if (!component) {
+      var _this$centralPlant$ma7;
+      if (!((_this$centralPlant$ma7 = this.centralPlant.managers) !== null && _this$centralPlant$ma7 !== void 0 && _this$centralPlant$ma7.transformOperationsManager)) {
+        console.warn('⚠️ fixUndergroundComponent(): TransformOperationsManager not available');
         return false;
       }
-      var checkResult = this.checkComponentUnderground(component);
-      if (checkResult.isUnderground) {
-        var _component$userData;
-        var componentId = component.uuid || ((_component$userData = component.userData) === null || _component$userData === void 0 ? void 0 : _component$userData.originalUuid) || 'unknown';
-        console.log("\uD83D\uDD27 Component ".concat(componentId, " is underground (lowest Z: ").concat(checkResult.lowestZ.toFixed(3), "), moving up by ").concat(checkResult.correction.toFixed(3)));
-
-        // Move the component up so its lowest point is at ground level (z=0)
-        component.position.z += checkResult.correction;
-
-        // Update matrices
-        component.updateMatrix();
-        component.updateMatrixWorld(true);
-        console.log("\u2705 Component ".concat(componentId, " moved to surface (new position Z: ").concat(component.position.z.toFixed(3), ")"));
-        return true;
-      }
-      return false;
+      return this.centralPlant.managers.transformOperationsManager.fixUndergroundComponent(component);
     }
 
     /**
-     * Check if a pipe segment is horizontal (Z-axis aligned in Z-up coordinate system)
-     * A segment is considered horizontal if its direction vector has minimal Z component
+     * Check if a pipe segment is horizontal (delegates to TransformOperationsManager)
      * @param {THREE.Object3D} segment - The pipe segment to check
      * @param {number} tolerance - Angular tolerance in radians (default: ~5.7 degrees)
      * @returns {boolean} True if segment is horizontal, false otherwise
@@ -896,27 +512,17 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "isSegmentHorizontal",
     value: function isSegmentHorizontal(segment) {
+      var _this$centralPlant$ma8;
       var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.1;
-      if (!segment || !segment.geometry || !segment.quaternion) {
-        console.warn('⚠️ Invalid segment provided to isSegmentHorizontal');
+      if (!((_this$centralPlant$ma8 = this.centralPlant.managers) !== null && _this$centralPlant$ma8 !== void 0 && _this$centralPlant$ma8.transformOperationsManager)) {
+        console.warn('⚠️ isSegmentHorizontal(): TransformOperationsManager not available');
         return false;
       }
-
-      // Get the segment's direction vector (cylinder aligned with Y-axis by default)
-      var direction = new THREE.Vector3(0, 1, 0);
-      direction.applyQuaternion(segment.quaternion);
-      direction.normalize();
-
-      // In Z-up coordinate system, horizontal segments should have Z component near 0
-      // A perfectly horizontal segment would have direction.z = 0
-      var zComponent = Math.abs(direction.z);
-
-      // Allow small tolerance for floating point precision
-      return zComponent < tolerance;
+      return this.centralPlant.managers.transformOperationsManager.isSegmentHorizontal(segment, tolerance);
     }
 
     /**
-     * Calculate segment endpoints in world coordinates
+     * Calculate segment endpoints in world coordinates (delegates to TransformOperationsManager)
      * @param {THREE.Object3D} segment - The pipe segment
      * @returns {Object} Object with start and end Vector3 points
      * @private
@@ -924,31 +530,19 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "calculateSegmentEndpoints",
     value: function calculateSegmentEndpoints(segment) {
-      // Get the segment's geometry to determine its length and orientation
-      var geometry = segment.geometry;
-      var length = geometry.parameters.height || 1;
-
-      // Calculate start and end points based on segment position and orientation
-      var startPoint = new THREE.Vector3();
-      var endPoint = new THREE.Vector3();
-
-      // Get the segment's direction vector
-      var direction = new THREE.Vector3(0, 1, 0);
-      direction.applyQuaternion(segment.quaternion);
-
-      // Calculate start point (half length back from center)
-      startPoint.copy(segment.position).sub(direction.clone().multiplyScalar(length / 2));
-
-      // Calculate end point (half length forward from center)
-      endPoint.copy(segment.position).add(direction.clone().multiplyScalar(length / 2));
-      return {
-        start: startPoint,
-        end: endPoint
-      };
+      var _this$centralPlant$ma9;
+      if (!((_this$centralPlant$ma9 = this.centralPlant.managers) !== null && _this$centralPlant$ma9 !== void 0 && _this$centralPlant$ma9.transformOperationsManager)) {
+        console.warn('⚠️ calculateSegmentEndpoints(): TransformOperationsManager not available');
+        return {
+          start: new THREE.Vector3(),
+          end: new THREE.Vector3()
+        };
+      }
+      return this.centralPlant.managers.transformOperationsManager.calculateSegmentEndpoints(segment);
     }
 
     /**
-     * Find all connectors (component or manual) at given positions
+     * Find all connectors at given positions (delegates to TransformOperationsManager)
      * @param {Array<THREE.Vector3>} positions - Array of positions to check
      * @param {number} tolerance - Distance tolerance for position matching
      * @returns {Array<THREE.Object3D>} Array of connector objects found at positions
@@ -957,112 +551,29 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "findConnectorsAtPositions",
     value: function findConnectorsAtPositions(positions) {
-      var _this$centralPlant$sc9;
+      var _this$centralPlant$ma0;
       var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.15;
-      if (!((_this$centralPlant$sc9 = this.centralPlant.sceneViewer) !== null && _this$centralPlant$sc9 !== void 0 && _this$centralPlant$sc9.scene)) {
+      if (!((_this$centralPlant$ma0 = this.centralPlant.managers) !== null && _this$centralPlant$ma0 !== void 0 && _this$centralPlant$ma0.transformOperationsManager)) {
+        console.warn('⚠️ findConnectorsAtPositions(): TransformOperationsManager not available');
         return [];
       }
-      var foundConnectors = [];
-
-      // Traverse scene to find all connectors
-      this.centralPlant.sceneViewer.scene.traverse(function (child) {
-        var _child$userData7;
-        // Check if this is a connector (component connector or manual segment connector)
-        if (((_child$userData7 = child.userData) === null || _child$userData7 === void 0 ? void 0 : _child$userData7.objectType) === 'connector') {
-          // Get world position of connector
-          var connectorWorldPos = new THREE.Vector3();
-          child.getWorldPosition(connectorWorldPos);
-
-          // Check if connector is near any of the target positions
-          var _iterator = _createForOfIteratorHelper(positions),
-            _step;
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var position = _step.value;
-              var distance = connectorWorldPos.distanceTo(position);
-              if (distance <= tolerance) {
-                foundConnectors.push(child);
-                break; // Don't count the same connector twice
-              }
-            }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-        }
-      });
-      return foundConnectors;
+      return this.centralPlant.managers.transformOperationsManager.findConnectorsAtPositions(positions, tolerance);
     }
 
     /**
-     * Update connector positions in scene data after a declared segment is moved
+     * Update connector positions in scene data after a declared segment is moved (delegates to TransformOperationsManager)
      * @param {THREE.Object3D} segment - The segment whose connectors need updating
      * @private
      */
   }, {
     key: "updateSegmentConnectorPositions",
     value: function updateSegmentConnectorPositions(segment) {
-      var _this$centralPlant$sc0;
-      console.log("updateSegmentConnectorPositions started:", segment);
-      if (!segment || !((_this$centralPlant$sc0 = this.centralPlant.sceneViewer) !== null && _this$centralPlant$sc0 !== void 0 && (_this$centralPlant$sc0 = _this$centralPlant$sc0.currentSceneData) !== null && _this$centralPlant$sc0 !== void 0 && _this$centralPlant$sc0.scene)) {
-        console.warn('⚠️ updateSegmentConnectorPositions(): Missing segment or scene data');
+      var _this$centralPlant$ma1;
+      if (!((_this$centralPlant$ma1 = this.centralPlant.managers) !== null && _this$centralPlant$ma1 !== void 0 && _this$centralPlant$ma1.transformOperationsManager)) {
+        console.warn('⚠️ updateSegmentConnectorPositions(): TransformOperationsManager not available');
         return;
       }
-
-      // Helper function to clean up floating-point precision errors
-      var cleanPosition = function cleanPosition(value) {
-        return Math.abs(value) < 1e-10 ? 0 : value;
-      };
-
-      // Find all child connectors of the segment
-      var connectors = [];
-      segment.traverse(function (child) {
-        var _child$userData8, _child$userData9;
-        if (((_child$userData8 = child.userData) === null || _child$userData8 === void 0 ? void 0 : _child$userData8.objectType) === 'connector' && (_child$userData9 = child.userData) !== null && _child$userData9 !== void 0 && _child$userData9.isManualSegmentConnector) {
-          connectors.push(child);
-        }
-      });
-      if (connectors.length === 0) {
-        console.warn("\u26A0\uFE0F No connectors found for segment ".concat(segment.uuid));
-        return;
-      }
-      console.log("\uD83D\uDCCD Updating ".concat(connectors.length, " connector positions in scene data for segment ").concat(segment.uuid));
-
-      // First, find the segment in scene data
-      var sceneDataSegment = this.centralPlant.sceneViewer.currentSceneData.scene.children.find(function (child) {
-        var _segment$userData;
-        return child.uuid === segment.uuid || child.uuid === ((_segment$userData = segment.userData) === null || _segment$userData === void 0 ? void 0 : _segment$userData.originalUuid);
-      });
-      if (!sceneDataSegment) {
-        console.warn("\u26A0\uFE0F Segment ".concat(segment.uuid, " not found in scene data"));
-        return;
-      }
-      if (!sceneDataSegment.children || !Array.isArray(sceneDataSegment.children)) {
-        console.warn("\u26A0\uFE0F Segment ".concat(segment.uuid, " has no children array in scene data"));
-        return;
-      }
-      console.log("\u2705 Found segment in scene data with ".concat(sceneDataSegment.children.length, " children"));
-
-      // Update each connector's position in scene data
-      connectors.forEach(function (connector) {
-        // Get world position
-        var worldPosition = new THREE.Vector3();
-        connector.getWorldPosition(worldPosition);
-
-        // Find the connector in the segment's children array (not root scene.children)
-        var sceneDataConnector = sceneDataSegment.children.find(function (child) {
-          var _connector$userData2;
-          return child.uuid === connector.uuid || child.uuid === ((_connector$userData2 = connector.userData) === null || _connector$userData2 === void 0 ? void 0 : _connector$userData2.originalUuid);
-        });
-        if (sceneDataConnector && sceneDataConnector.userData) {
-          // Update position as array [x, y, z] for pathfinder compatibility
-          sceneDataConnector.userData.position = [cleanPosition(worldPosition.x), cleanPosition(worldPosition.y), cleanPosition(worldPosition.z)];
-          console.log("\u2705 Updated connector ".concat(connector.uuid, " position to [").concat(sceneDataConnector.userData.position.join(', '), "]"));
-        } else {
-          console.warn("\u26A0\uFE0F Connector ".concat(connector.uuid, " not found in segment's children in scene data"));
-        }
-      });
+      return this.centralPlant.managers.transformOperationsManager.updateSegmentConnectorPositions(segment);
     }
 
     // ===== COMPONENT AND CONNECTION OPERATIONS =====
@@ -1076,9 +587,9 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "addConnection",
     value: function addConnection(fromConnectorId, toConnectorId) {
-      var _this$centralPlant$sc1;
+      var _this$centralPlant$sc2;
       // Use centralized validation for connection parameters
-      var existingConnections = ((_this$centralPlant$sc1 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc1 === void 0 || (_this$centralPlant$sc1 = _this$centralPlant$sc1.currentSceneData) === null || _this$centralPlant$sc1 === void 0 ? void 0 : _this$centralPlant$sc1.connections) || [];
+      var existingConnections = ((_this$centralPlant$sc2 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc2 === void 0 || (_this$centralPlant$sc2 = _this$centralPlant$sc2.currentSceneData) === null || _this$centralPlant$sc2 === void 0 ? void 0 : _this$centralPlant$sc2.connections) || [];
       var validation = this.validator.validateConnectionParams(fromConnectorId, toConnectorId, existingConnections);
       if (!validation.isValid) {
         return false; // Validator already logged the error
@@ -1204,7 +715,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "addComponent",
     value: function addComponent(libraryId) {
-      var _this$centralPlant$sc10;
+      var _this$centralPlant$sc3;
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       // Use centralized validation for component addition parameters
       var existingIds = this.getComponentIds();
@@ -1214,7 +725,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       }
 
       // Validate scene availability
-      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc10 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc10 === void 0 ? void 0 : _this$centralPlant$sc10.scene);
+      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc3 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc3 === void 0 ? void 0 : _this$centralPlant$sc3.scene);
       if (!sceneValidation.isValid) {
         return false;
       }
@@ -1233,7 +744,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         return false;
       }
       try {
-        var _this$centralPlant$sc11;
+        var _this$centralPlant$sc4;
         // Generate a unique component ID if not provided
         var componentId = options.customId || this.generateUniqueComponentId(libraryId);
 
@@ -1296,9 +807,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
           originalUuid: componentId,
           addedTimestamp: new Date().toISOString(),
           addedBy: 'centralPlant.addComponent()',
-          isUserAdded: true,
-          initialPosition: _objectSpread2({}, position),
-          initialRotation: _objectSpread2({}, rotation)
+          initialPosition: _objectSpread2({}, position)
         };
 
         // Add the component to the scene
@@ -1309,7 +818,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         componentModel.updateMatrixWorld(true);
 
         // Check if component is underground and fix if needed (based on settings)
-        var checkUnderground = (_this$centralPlant$sc11 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc11 === void 0 || (_this$centralPlant$sc11 = _this$centralPlant$sc11.managers) === null || _this$centralPlant$sc11 === void 0 || (_this$centralPlant$sc11 = _this$centralPlant$sc11.settingsManager) === null || _this$centralPlant$sc11 === void 0 ? void 0 : _this$centralPlant$sc11.getSetting('scene', 'checkUnderground');
+        var checkUnderground = (_this$centralPlant$sc4 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc4 === void 0 || (_this$centralPlant$sc4 = _this$centralPlant$sc4.managers) === null || _this$centralPlant$sc4 === void 0 || (_this$centralPlant$sc4 = _this$centralPlant$sc4.settingsManager) === null || _this$centralPlant$sc4 === void 0 ? void 0 : _this$centralPlant$sc4.getSetting('scene', 'checkUnderground');
         if (checkUnderground) {
           var wasFixed = this.fixUndergroundComponent(componentModel);
           if (wasFixed) {
@@ -1429,8 +938,8 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       }
       var componentIds = [];
       this.centralPlant.sceneViewer.scene.traverse(function (child) {
-        var _child$userData0;
-        if (((_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.objectType) === 'component') {
+        var _child$userData;
+        if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) === 'component') {
           componentIds.push(child.uuid || child.userData.originalUuid);
         }
       });