@2112-lab/central-plant 0.1.4 → 0.1.5

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

@@ -1 +1,1144 @@
-import{createClass as e,objectSpread2 as t,typeof as n,classCallCheck as i}from"../../_virtual/_rollupPluginBabelHelpers.js";import{createTransformControls as a}from"../managers/controls/transformControlsManager.js";import{HotReloadManager as o}from"../managers/system/hotReloadManager.js";import{DisposalManager as s}from"../managers/system/disposalManager.js";import{SceneExportManager as r}from"../managers/scene/sceneExportManager.js";import{ComponentManager as l}from"../managers/components/componentManager.js";import{SceneInitializationManager as u}from"../managers/scene/sceneInitializationManager.js";import{EnvironmentManager as c}from"../managers/environment/environmentManager.js";import{KeyboardControlsManager as h}from"../managers/controls/keyboardControlsManager.js";import{PathfindingManager as m}from"../managers/components/pathfindingManager.js";import{SceneOperationsManager as d}from"../managers/scene/sceneOperationsManager.js";import{AnimationManager as f}from"../managers/components/animationManager.js";import{CameraControlsManager as v}from"../managers/controls/cameraControlsManager.js";import{SceneTooltipsManager as p}from"../managers/scene/sceneTooltipsManager.js";import{generateUuidFromName as g,getHardcodedUuid as y}from"./nameUtils.js";import{logger as k,transformLogger as w,pathfinderLogger as M,modelLogger as S}from"./debugLogger.js";import j from"../rendering/modelPreloader.js";import b from"../managers/controls/dragDropManager.js";import{SceneHelper as C}from"../helpers/sceneHelper.js";var D=function(){return e(function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null;i(this,e),this.sceneViewer=t,this.managers={},this.utilities={},this.isInitialized=!1,this.importedSceneData=null,this.metadata={},this.transformHistory={lastTransform:null},this.setDefaultSceneMetadata(),this.initializeUtilities(),t&&(this.initializeManagers(),this.isInitialized=!0)},[{key:"setSceneViewer",value:function(e){this.sceneViewer=e,!this.isInitialized&&e&&(this.initializeManagers(),this.isInitialized=!0)}},{key:"initializeManagers",value:function(){this.sceneViewer&&(this.managers.hotReloadManager=new o(this.sceneViewer),this.managers.disposalManager=new s(this.sceneViewer),this.managers.sceneExportManager=new r(this.sceneViewer),this.managers.componentManager=new l(this.sceneViewer),this.managers.sceneInitializationManager=new u(this.sceneViewer),this.managers.environmentManager=new c(this.sceneViewer),this.managers.keyboardControlsManager=new h(this.sceneViewer),this.managers.pathfindingManager=new m(this.sceneViewer),this.managers.sceneOperationsManager=new d(this.sceneViewer),this.managers.animationManager=new f(this.sceneViewer),this.managers.cameraControlsManager=new v(this.sceneViewer))}},{key:"initializeUtilities",value:function(){this.utilities.createTransformControls=a,this.utilities.generateUuidFromName=g,this.utilities.getHardcodedUuid=y,this.utilities.logger=k,this.utilities.transformLogger=w,this.utilities.pathfinderLogger=M,this.utilities.modelLogger=S,this.utilities.modelPreloader=j,this.utilities.SceneHelper=C,this.utilities.DragDropManager=b}},{key:"attachToComponent",value:function(){var e=this;this.sceneViewer&&(this.isInitialized||this.initializeManagers(),Object.keys(this.managers).forEach(function(t){e.sceneViewer[t]=e.managers[t]}),Object.keys(this.utilities).forEach(function(t){e.sceneViewer[t]=e.utilities[t]}))}},{key:"initializePostSceneManagers",value:function(){this.sceneViewer.$refs.container&&this.sceneViewer.camera&&this.sceneViewer.scene&&(this.managers.tooltipsManager=new p(this.sceneViewer.$refs.container,this.sceneViewer.camera,this.sceneViewer.scene),this.sceneViewer.tooltipsManager=this.managers.tooltipsManager),this.sceneViewer.scene&&this.sceneViewer.camera&&(this.managers.dragDropManager=new b({scene:this.sceneViewer.scene,camera:this.sceneViewer.camera,transformManager:this.sceneViewer.transformManager,modelPreloader:this.utilities.modelPreloader,componentManager:this.sceneViewer.componentManager}),this.sceneViewer.dragDropManager=this.managers.dragDropManager),this.sceneViewer.scene&&this.sceneViewer.camera&&this.sceneViewer.renderer&&(this.utilities.sceneHelper=new C({scene:this.sceneViewer.scene,camera:this.sceneViewer.camera,renderer:this.sceneViewer.renderer,controls:this.sceneViewer.controls,transformManager:this.sceneViewer.transformManager,componentManager:this.sceneViewer.componentManager,pathfindingManager:this.sceneViewer.pathfindingManager,currentSceneData:this.sceneViewer.currentSceneData,logger:this.utilities.logger}),this.sceneViewer.sceneHelper=this.utilities.sceneHelper)}},{key:"updateSceneHelperData",value:function(e){this.utilities.sceneHelper&&"function"==typeof this.utilities.sceneHelper.updateSceneData&&this.utilities.sceneHelper.updateSceneData(e)}},{key:"setImportedSceneData",value:function(e){this.importedSceneData=t({},e),this.setDefaultImportedSceneMetadata(e),this.utilities.sceneHelper&&"function"==typeof this.utilities.sceneHelper.updateSceneData&&this.utilities.sceneHelper.updateSceneData(e)}},{key:"getImportedSceneData",value:function(){return this.importedSceneData}},{key:"getImportedConnections",value:function(){var e;return(null===(e=this.importedSceneData)||void 0===e?void 0:e.connections)||[]}},{key:"getImportedSceneObjects",value:function(){var e;return(null===(e=this.importedSceneData)||void 0===e||null===(e=e.scene)||void 0===e?void 0:e.object)||null}},{key:"clearImportedSceneData",value:function(){this.importedSceneData=null}},{key:"setMetadata",value:function(e,t){this.metadata[e]=t}},{key:"getMetadata",value:function(e){return this.metadata[e]}},{key:"getAllMetadata",value:function(){return t({},this.metadata)}},{key:"removeMetadata",value:function(e){delete this.metadata[e]}},{key:"clearAllMetadata",value:function(){this.metadata={}}},{key:"clearAllData",value:function(){this.metadata={},this.transformHistory.lastTransform=null}},{key:"recordTransform",value:function(e){var t,n;if(e&&e.object){e.previousValues;var i={type:e.type,object:e.object,values:e.values,previousValues:e.previousValues,timestamp:(new Date).toISOString(),objectId:(null===(t=e.object)||void 0===t?void 0:t.uuid)||(null===(n=e.object)||void 0===n?void 0:n.id)||"unknown"};this.transformHistory.lastTransform=i}}},{key:"getLastTransform",value:function(){return this.transformHistory.lastTransform}},{key:"getTransformHistory",value:function(){return t({},this.transformHistory)}},{key:"clearTransformHistory",value:function(){this.transformHistory.lastTransform=null}},{key:"hasMetadata",value:function(e){return e in this.metadata}},{key:"setDefaultSceneMetadata",value:function(){var e=this,t={sceneInfo:{name:"Untitled Central Plant Scene",description:"A central plant facility scene",version:"1.0.0",created:(new Date).toISOString(),lastModified:(new Date).toISOString(),author:"Engineering Team"},projectSettings:{units:"metric",scale:1,gridSize:1,snapToGrid:!0,showGrid:!0,showAxes:!0},viewportSettings:{defaultViewMode:"perspective",backgroundType:"skybox",showEnvironment:!0,autoRotate:!1,cameraPosition:{x:10,y:10,z:10},cameraTarget:{x:0,y:0,z:0}},componentSettings:{defaultComponentScale:1,showBoundingBoxes:!1,showConnectionPaths:!0,highlightOnHover:!0,selectionOutlineColor:"#00ff00"},spatialBoundaries:{min:{x:-60,y:-16,z:-60},max:{x:60,y:16,z:60},center:{x:0,y:4,z:0}},systemInfo:{centralPlantVersion:"2.0.0",buildDate:(new Date).toISOString(),platform:"undefined"!=typeof window?window.navigator.platform:"Unknown",userAgent:"undefined"!=typeof window?window.navigator.userAgent:"Unknown"}};Object.keys(t).forEach(function(n){e.hasMetadata(n)||e.setMetadata(n,t[n])})}},{key:"setDefaultImportedSceneMetadata",value:function(e){var n,i,a,o=(new Date).toISOString(),s=(null===(n=e.connections)||void 0===n?void 0:n.length)||0,r=(null===(i=e.scene)||void 0===i||null===(i=i.object)||void 0===i||null===(i=i.children)||void 0===i?void 0:i.length)||0,l={};null!==(a=e.scene)&&void 0!==a&&null!==(a=a.object)&&void 0!==a&&a.children&&e.scene.object.children.forEach(function(e){var t,n=(null===(t=e.userData)||void 0===t?void 0:t.componentType)||"unknown";l[n]=(l[n]||0)+1});var u={importInfo:{importTimestamp:o,originalFileName:null,fileSize:null,importMethod:"file-upload",importVersion:"1.0.0"},sceneAnalysis:{totalComponents:r,totalConnections:s,componentTypes:l,sceneComplexity:this.calculateSceneComplexity(s,r),hasValidStructure:this.validateImportedSceneStructure(e)},dataQuality:{hasConnections:s>0,hasComponents:r>0,hasValidScene:!!e.scene,missingData:this.identifyMissingData(e),warnings:this.generateImportWarnings(e)},processingStats:{processedAt:o,processingDuration:null,memoryUsage:this.estimateMemoryUsage(e),cacheStatus:"pending"}};if(this.setMetadata("lastImport",u),this.hasMetadata("sceneInfo")){var c=this.getMetadata("sceneInfo");this.setMetadata("sceneInfo",t(t({},c),{},{lastModified:o,importSource:"file-import",dataSourceType:"json"}))}}},{key:"calculateSceneComplexity",value:function(e,t){var n=e+t;return n<=10?"simple":n<=50?"moderate":n<=200?"complex":"very-complex"}},{key:"validateImportedSceneStructure",value:function(e){return!!(e&&e.scene&&e.scene.object&&Array.isArray(e.connections))}},{key:"identifyMissingData",value:function(e){var t,n=[];return e.connections&&0!==e.connections.length||n.push("No connection data found"),null!==(t=e.scene)&&void 0!==t&&null!==(t=t.object)&&void 0!==t&&t.children&&0!==e.scene.object.children.length||n.push("No component data found"),e.metadata||n.push("No metadata found"),e.version||n.push("No version information"),n}},{key:"generateImportWarnings",value:function(e){var t,n,i=[],a=(null===(t=e.scene)||void 0===t||null===(t=t.object)||void 0===t||null===(t=t.children)||void 0===t?void 0:t.length)||0;a>100&&i.push("Large scene detected (".concat(a," components) - may impact performance"));var o=(null===(n=e.connections)||void 0===n?void 0:n.length)||0;return a>0&&0===o&&i.push("Components found but no connections - scene may be incomplete"),e.version&&parseFloat(e.version)<1&&i.push("Scene data version is older than current - some features may not work correctly"),i}},{key:"estimateMemoryUsage",value:function(e){var t=JSON.stringify(e).length,n=(t/1024/1024).toFixed(2);return{jsonSizeBytes:t,estimatedMB:parseFloat(n),category:n<1?"small":n<10?"medium":"large"}}},{key:"updateMetadataCategory",value:function(e,n){if(this.hasMetadata(e)){var i=this.getMetadata(e);this.setMetadata(e,t(t({},i),n))}else this.setMetadata(e,n)}},{key:"undoTransform",value:function(){var e=this.getLastTransform();if(!e)return!1;try{var t,n=e.object,i=e.type,a=e.previousValues;if(!n||!a)return!1;if(this.debugTransformState(n,"Before Undo"),this.sceneViewer&&this.sceneViewer.scene){var o=!1;if(this.sceneViewer.scene.traverse(function(e){e===n&&(o=!0)}),!o)return!1}switch(i){case"translate":case"position":a.position?(void 0!==a.position.x&&(n.position.x=a.position.x),void 0!==a.position.y&&(n.position.y=a.position.y),void 0!==a.position.z&&(n.position.z=a.position.z)):(void 0!==a.x&&(n.position.x=a.x),void 0!==a.y&&(n.position.y=a.y),void 0!==a.z&&(n.position.z=a.z));break;case"rotate":case"rotation":a.rotation?(void 0!==a.rotation.x&&(n.rotation.x=a.rotation.x),void 0!==a.rotation.y&&(n.rotation.y=a.rotation.y),void 0!==a.rotation.z&&(n.rotation.z=a.rotation.z)):(void 0!==a.x&&(n.rotation.x=a.x),void 0!==a.y&&(n.rotation.y=a.y),void 0!==a.z&&(n.rotation.z=a.z));break;case"scale":a.scale?(void 0!==a.scale.x&&(n.scale.x=a.scale.x),void 0!==a.scale.y&&(n.scale.y=a.scale.y),void 0!==a.scale.z&&(n.scale.z=a.scale.z)):(void 0!==a.x&&(n.scale.x=a.x),void 0!==a.y&&(n.scale.y=a.y),void 0!==a.z&&(n.scale.z=a.z));break;default:return!1}n.updateMatrix(),n.updateMatrixWorld(!0);var s=null===(t=this.sceneViewer)||void 0===t?void 0:t.transformManager;if(s&&s.transformControls){var r=s.transformControls;r.object===n&&(r.detach(),s.ensureSceneAttachment&&s.ensureSceneAttachment(!0),r.attach(n),s.selectedObject=n,s.updateBoundingBox&&s.updateBoundingBox(),s.boundingBoxCache&&s.boundingBoxCache.has(n)&&s.boundingBoxCache.delete(n))}if(this.sceneViewer&&this.sceneViewer.sceneOperationsManager&&this.sceneViewer.currentSceneData)try{this.sceneViewer.onTransformEnd(n)}catch(e){}if("undefined"!=typeof window){var l=new CustomEvent("sceneUpdateComplete",{detail:{timestamp:Date.now(),action:"undo-transform",objectId:n.uuid||n.id||"unknown"}});window.dispatchEvent(l)}return this.clearTransformHistory(),this.ensureObjectSelectable(n),this.debugTransformState(n,"After Undo"),!0}catch(e){return!1}}},{key:"ensureObjectSelectable",value:function(e){if(!e||!this.sceneViewer)return!1;try{var t=this.sceneViewer.transformManager;return!!t&&(t.recoverTransformControls?t.recoverTransformControls(e):(e.updateMatrixWorld(!0),t.boundingBoxCache&&t.boundingBoxCache.has(e)&&t.boundingBoxCache.delete(e),t.ensureSceneAttachment&&t.ensureSceneAttachment(!0),t.selectedObject===e&&(t.deselectObject(),requestAnimationFrame(function(){t.selectObjectForTransformOnly(e)})),!0))}catch(e){return!1}}},{key:"debugTransformState",value:function(e){}},{key:"fixTransformControlsSelection",value:function(){if(!this.sceneViewer||!this.sceneViewer.transformManager)return!1;var e=this.sceneViewer.transformManager;if(e.recoverTransformControls&&e.recoverTransformControls())return!0;try{var t=e.currentMode,n=e.currentSpace;return e.transformControls&&(e.transformControls.detach(),e.scene.remove(e.transformControls),e.transformControls.dispose(),e.transformControls=null),e.createTransformControls(),e.setupEventListeners(),e.setMode(t),e.setSpace(n),!0}catch(e){return!1}}},{key:"isObjectInScene",value:function(e){if(!this.sceneViewer||!this.sceneViewer.scene)return!1;var t=!1;return this.sceneViewer.scene.traverse(function(n){n===e&&(t=!0)}),t}}])}();export{D as CentralPlant,D as default};
+import { createClass as _createClass, objectSpread2 as _objectSpread2, typeof as _typeof, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { createTransformControls } from '../managers/controls/transformControlsManager.js';
+import { HotReloadManager } from '../managers/system/hotReloadManager.js';
+import { DisposalManager } from '../managers/system/disposalManager.js';
+import { SceneExportManager } from '../managers/scene/sceneExportManager.js';
+import { ComponentManager } from '../managers/components/componentManager.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 { SceneOperationsManager } from '../managers/scene/sceneOperationsManager.js';
+import { AnimationManager } from '../managers/components/animationManager.js';
+import { CameraControlsManager } from '../managers/controls/cameraControlsManager.js';
+import { SceneTooltipsManager } from '../managers/scene/sceneTooltipsManager.js';
+import { generateUuidFromName, getHardcodedUuid } from './nameUtils.js';
+import { logger, transformLogger, pathfinderLogger, modelLogger } from './debugLogger.js';
+import modelPreloader from '../rendering/modelPreloader.js';
+import DragDropManager from '../managers/controls/dragDropManager.js';
+import { SceneHelper } from '../helpers/sceneHelper.js';
+
+/**
+ * CentralPlant class that manages all scene utility instances
+ */
+var CentralPlant = /*#__PURE__*/function () {
+  /**
+   * Initialize the CentralPlant manager
+   * @param {Object} sceneViewer - The SceneViewerEnhanced component instance
+   */
+  function CentralPlant() {
+    var sceneViewer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    _classCallCheck(this, CentralPlant);
+    this.sceneViewer = sceneViewer;
+    this.managers = {};
+    this.utilities = {};
+    this.isInitialized = false;
+
+    // Store imported scene data directly
+    this.importedSceneData = null;
+
+    // Add metadata storage
+    this.metadata = {};
+
+    // Add transform history tracking
+    this.transformHistory = {
+      lastTransform: null
+    };
+
+    // Set default scene metadata
+    this.setDefaultSceneMetadata();
+
+    // Initialize utilities immediately (they don't need scene viewer)
+    this.initializeUtilities();
+
+    // Initialize managers only if sceneViewer is provided
+    if (sceneViewer) {
+      this.initializeManagers();
+      this.isInitialized = true;
+    }
+  }
+
+  /**
+   * Set the scene viewer instance and initialize managers if not already done
+   * @param {Object} sceneViewer - The SceneViewerEnhanced component instance
+   */
+  return _createClass(CentralPlant, [{
+    key: "setSceneViewer",
+    value: function setSceneViewer(sceneViewer) {
+      this.sceneViewer = sceneViewer;
+      if (!this.isInitialized && sceneViewer) {
+        this.initializeManagers();
+        this.isInitialized = true;
+      }
+    }
+
+    /**
+     * Initialize all manager instances
+     */
+  }, {
+    key: "initializeManagers",
+    value: function initializeManagers() {
+      if (!this.sceneViewer) {
+        console.warn('⚠️ Cannot initialize managers without scene viewer');
+        return;
+      }
+
+      // Initialize all managers consistently
+      this.managers.hotReloadManager = new HotReloadManager(this.sceneViewer);
+      this.managers.disposalManager = new DisposalManager(this.sceneViewer);
+      this.managers.sceneExportManager = new SceneExportManager(this.sceneViewer);
+      this.managers.componentManager = new ComponentManager(this.sceneViewer);
+      this.managers.sceneInitializationManager = new SceneInitializationManager(this.sceneViewer);
+      this.managers.environmentManager = new EnvironmentManager(this.sceneViewer);
+      this.managers.keyboardControlsManager = new KeyboardControlsManager(this.sceneViewer);
+      this.managers.pathfindingManager = new PathfindingManager(this.sceneViewer);
+      this.managers.sceneOperationsManager = new SceneOperationsManager(this.sceneViewer);
+      this.managers.animationManager = new AnimationManager(this.sceneViewer);
+      this.managers.cameraControlsManager = new CameraControlsManager(this.sceneViewer);
+
+      // All managers are now stored in the managers collection and will be attached via attachToComponent()
+    }
+
+    /**
+     * Initialize utility functions and objects
+     */
+  }, {
+    key: "initializeUtilities",
+    value: function initializeUtilities() {
+      // Transform controls factory function
+      this.utilities.createTransformControls = createTransformControls;
+
+      // Name utilities
+      this.utilities.generateUuidFromName = generateUuidFromName;
+      this.utilities.getHardcodedUuid = getHardcodedUuid;
+
+      // Loggers
+      this.utilities.logger = logger;
+      this.utilities.transformLogger = transformLogger;
+      this.utilities.pathfinderLogger = pathfinderLogger;
+      this.utilities.modelLogger = modelLogger;
+
+      // Model preloader
+      this.utilities.modelPreloader = modelPreloader;
+
+      // Scene helper utility
+      this.utilities.SceneHelper = SceneHelper;
+
+      // Drag drop manager factory (will be initialized after scene is ready)
+      this.utilities.DragDropManager = DragDropManager;
+    }
+
+    /**
+     * Set all managers and utilities on the scene viewer instance
+     */
+  }, {
+    key: "attachToComponent",
+    value: function attachToComponent() {
+      var _this = this;
+      if (!this.sceneViewer) {
+        console.warn('⚠️ Cannot attach to component: no scene viewer set');
+        return;
+      }
+
+      // Initialize managers if not already done
+      if (!this.isInitialized) {
+        this.initializeManagers();
+      }
+
+      // Attach all managers to the scene viewer instance
+      Object.keys(this.managers).forEach(function (key) {
+        _this.sceneViewer[key] = _this.managers[key];
+      });
+
+      // Attach utilities to the scene viewer instance
+      Object.keys(this.utilities).forEach(function (key) {
+        _this.sceneViewer[key] = _this.utilities[key];
+      });
+    }
+
+    /**
+     * Initialize specific managers that need to be created after scene setup
+     */
+  }, {
+    key: "initializePostSceneManagers",
+    value: function initializePostSceneManagers() {
+      // Initialize the tooltip manager (needs container, camera, scene)
+      if (this.sceneViewer.$refs.container && this.sceneViewer.camera && this.sceneViewer.scene) {
+        this.managers.tooltipsManager = new SceneTooltipsManager(this.sceneViewer.$refs.container, this.sceneViewer.camera, this.sceneViewer.scene);
+        this.sceneViewer.tooltipsManager = this.managers.tooltipsManager;
+        console.log('🔍 Tooltip manager initialized:', this.managers.tooltipsManager);
+      }
+
+      // Initialize the drag and drop manager (needs scene, camera, etc.)
+      if (this.sceneViewer.scene && this.sceneViewer.camera) {
+        this.managers.dragDropManager = new DragDropManager({
+          scene: this.sceneViewer.scene,
+          camera: this.sceneViewer.camera,
+          transformManager: this.sceneViewer.transformManager,
+          modelPreloader: this.utilities.modelPreloader,
+          componentManager: this.sceneViewer.componentManager
+        });
+        this.sceneViewer.dragDropManager = this.managers.dragDropManager;
+        console.log('🎯 Drag and drop manager initialized');
+      }
+
+      // Initialize the scene helper utility (needs scene, camera, renderer, etc.)
+      if (this.sceneViewer.scene && this.sceneViewer.camera && this.sceneViewer.renderer) {
+        this.utilities.sceneHelper = new SceneHelper({
+          scene: this.sceneViewer.scene,
+          camera: this.sceneViewer.camera,
+          renderer: this.sceneViewer.renderer,
+          controls: this.sceneViewer.controls,
+          transformManager: this.sceneViewer.transformManager,
+          componentManager: this.sceneViewer.componentManager,
+          pathfindingManager: this.sceneViewer.pathfindingManager,
+          currentSceneData: this.sceneViewer.currentSceneData,
+          logger: this.utilities.logger
+        });
+        this.sceneViewer.sceneHelper = this.utilities.sceneHelper;
+        console.log('🔧 Scene helper utility initialized:', this.utilities.sceneHelper);
+      }
+    }
+
+    /**
+     * Update scene helper with new scene data
+     * @param {Object} sceneData - Updated scene data
+     */
+  }, {
+    key: "updateSceneHelperData",
+    value: function updateSceneHelperData(sceneData) {
+      if (this.utilities.sceneHelper && typeof this.utilities.sceneHelper.updateSceneData === 'function') {
+        this.utilities.sceneHelper.updateSceneData(sceneData);
+        console.log('🔄 Scene helper data updated');
+      }
+    }
+
+    /**
+     * Set imported scene data directly in CentralPlant
+     * @param {Object} sceneData - The imported scene data (from cp-01-01.json or other scene files)
+     */
+  }, {
+    key: "setImportedSceneData",
+    value: function setImportedSceneData(sceneData) {
+      var _this$importedSceneDa, _this$importedSceneDa2;
+      this.importedSceneData = _objectSpread2({}, sceneData);
+      console.log('📥 Imported scene data stored in CentralPlant:', {
+        connections: ((_this$importedSceneDa = this.importedSceneData.connections) === null || _this$importedSceneDa === void 0 ? void 0 : _this$importedSceneDa.length) || 0,
+        sceneObjects: ((_this$importedSceneDa2 = this.importedSceneData.scene) === null || _this$importedSceneDa2 === void 0 || (_this$importedSceneDa2 = _this$importedSceneDa2.object) === null || _this$importedSceneDa2 === void 0 || (_this$importedSceneDa2 = _this$importedSceneDa2.children) === null || _this$importedSceneDa2 === void 0 ? void 0 : _this$importedSceneDa2.length) || 0,
+        timestamp: new Date().toISOString()
+      });
+
+      // Set default metadata for imported scene data
+      this.setDefaultImportedSceneMetadata(sceneData);
+
+      // Also update the scene helper if available
+      if (this.utilities.sceneHelper && typeof this.utilities.sceneHelper.updateSceneData === 'function') {
+        this.utilities.sceneHelper.updateSceneData(sceneData);
+      }
+    }
+
+    /**
+     * Get the stored imported scene data
+     * @returns {Object|null} The imported scene data or null if none is stored
+     */
+  }, {
+    key: "getImportedSceneData",
+    value: function getImportedSceneData() {
+      return this.importedSceneData;
+    }
+
+    /**
+     * Get connections from the imported scene data
+     * @returns {Array} The connections array or empty array if none
+     */
+  }, {
+    key: "getImportedConnections",
+    value: function getImportedConnections() {
+      var _this$importedSceneDa3;
+      return ((_this$importedSceneDa3 = this.importedSceneData) === null || _this$importedSceneDa3 === void 0 ? void 0 : _this$importedSceneDa3.connections) || [];
+    }
+
+    /**
+     * Get scene objects from the imported scene data
+     * @returns {Object|null} The scene object structure or null if none
+     */
+  }, {
+    key: "getImportedSceneObjects",
+    value: function getImportedSceneObjects() {
+      var _this$importedSceneDa4;
+      return ((_this$importedSceneDa4 = this.importedSceneData) === null || _this$importedSceneDa4 === void 0 || (_this$importedSceneDa4 = _this$importedSceneDa4.scene) === null || _this$importedSceneDa4 === void 0 ? void 0 : _this$importedSceneDa4.object) || null;
+    }
+
+    /**
+     * Clear the stored imported scene data
+     */
+  }, {
+    key: "clearImportedSceneData",
+    value: function clearImportedSceneData() {
+      this.importedSceneData = null;
+      console.log('🗑️ Imported scene data cleared from CentralPlant');
+    }
+
+    /**
+     * Set a metadata attribute
+     * @param {string} key - The metadata key
+     * @param {any} value - The metadata value
+     */
+  }, {
+    key: "setMetadata",
+    value: function setMetadata(key, value) {
+      this.metadata[key] = value;
+      console.log("\uD83D\uDCDD Metadata set: ".concat(key, " ="), value);
+    }
+
+    /**
+     * Get a metadata attribute
+     * @param {string} key - The metadata key
+     * @returns {any} The metadata value or undefined if not found
+     */
+  }, {
+    key: "getMetadata",
+    value: function getMetadata(key) {
+      return this.metadata[key];
+    }
+
+    /**
+     * Get all metadata
+     * @returns {Object} All metadata attributes
+     */
+  }, {
+    key: "getAllMetadata",
+    value: function getAllMetadata() {
+      return _objectSpread2({}, this.metadata);
+    }
+
+    /**
+     * Remove a metadata attribute
+     * @param {string} key - The metadata key to remove
+     */
+  }, {
+    key: "removeMetadata",
+    value: function removeMetadata(key) {
+      delete this.metadata[key];
+      console.log("\uD83D\uDDD1\uFE0F Metadata removed: ".concat(key));
+    }
+
+    /**
+     * Clear all metadata
+     */
+  }, {
+    key: "clearAllMetadata",
+    value: function clearAllMetadata() {
+      this.metadata = {};
+      console.log('🗑️ All metadata cleared from CentralPlant');
+    }
+
+    /**
+     * Clear all data including metadata and transform history
+     */
+  }, {
+    key: "clearAllData",
+    value: function clearAllData() {
+      this.metadata = {};
+      this.transformHistory.lastTransform = null;
+      console.log('🗑️ All data cleared from CentralPlant (metadata + transform history)');
+    }
+
+    /**
+     * Record a transform operation in the history
+     * @param {Object} transformData - The transform data to record
+     * @param {string} transformData.type - The type of transform (e.g., 'translate', 'rotate', 'scale')
+     * @param {Object} transformData.object - The object that was transformed
+     * @param {Object} transformData.values - The transform values applied
+     * @param {Object} transformData.previousValues - The previous transform values (for undo)
+     */
+  }, {
+    key: "recordTransform",
+    value: function recordTransform(transformData) {
+      var _transformData$object, _transformData$object2, _transformRecord$prev;
+      console.log("recordTransform started");
+
+      // Validate the transform data
+      if (!transformData || !transformData.object) {
+        console.error('❌ Invalid transform data provided to recordTransform:', transformData);
+        return;
+      }
+      if (!transformData.previousValues) {
+        console.warn('⚠️ No previous values provided for transform recording - undo may not work properly');
+      }
+      var transformRecord = {
+        type: transformData.type,
+        object: transformData.object,
+        values: transformData.values,
+        previousValues: transformData.previousValues,
+        timestamp: new Date().toISOString(),
+        objectId: ((_transformData$object = transformData.object) === null || _transformData$object === void 0 ? void 0 : _transformData$object.uuid) || ((_transformData$object2 = transformData.object) === null || _transformData$object2 === void 0 ? void 0 : _transformData$object2.id) || 'unknown'
+      };
+      this.transformHistory.lastTransform = transformRecord;
+      console.log('🔄 Transform recorded:', {
+        type: transformRecord.type,
+        objectId: transformRecord.objectId,
+        currentValues: transformRecord.values,
+        previousValues: transformRecord.previousValues,
+        previousValuesStructure: {
+          type: _typeof(transformRecord.previousValues),
+          keys: Object.keys(transformRecord.previousValues || {}),
+          hasPosition: !!(transformRecord.previousValues && transformRecord.previousValues.position),
+          hasRotation: !!(transformRecord.previousValues && transformRecord.previousValues.rotation),
+          hasScale: !!(transformRecord.previousValues && transformRecord.previousValues.scale),
+          positionValues: (_transformRecord$prev = transformRecord.previousValues) !== null && _transformRecord$prev !== void 0 && _transformRecord$prev.position ? {
+            x: transformRecord.previousValues.position.x,
+            y: transformRecord.previousValues.position.y,
+            z: transformRecord.previousValues.position.z
+          } : null
+        },
+        timestamp: transformRecord.timestamp
+      });
+      console.log("recordTransform this.transformHistory:", this.transformHistory);
+    }
+
+    /**
+     * Get the last transform operation
+     * @returns {Object|null} The last transform record or null if none exists
+     */
+  }, {
+    key: "getLastTransform",
+    value: function getLastTransform() {
+      return this.transformHistory.lastTransform;
+    }
+
+    /**
+     * Get the complete transform history
+     * @returns {Object} The transform history object
+     */
+  }, {
+    key: "getTransformHistory",
+    value: function getTransformHistory() {
+      return _objectSpread2({}, this.transformHistory);
+    }
+
+    /**
+     * Clear the transform history
+     */
+  }, {
+    key: "clearTransformHistory",
+    value: function clearTransformHistory() {
+      this.transformHistory.lastTransform = null;
+      console.log('🗑️ Transform history cleared');
+    }
+
+    /**
+     * Check if a metadata key exists
+     * @param {string} key - The metadata key to check
+     * @returns {boolean} True if the key exists
+     */
+  }, {
+    key: "hasMetadata",
+    value: function hasMetadata(key) {
+      return key in this.metadata;
+    }
+
+    /**
+     * Set default metadata for the CentralPlant scene
+     */
+  }, {
+    key: "setDefaultSceneMetadata",
+    value: function setDefaultSceneMetadata() {
+      var _this2 = this;
+      var defaultMetadata = {
+        // Scene Information
+        sceneInfo: {
+          name: 'Untitled Central Plant Scene',
+          description: 'A central plant facility scene',
+          version: '1.0.0',
+          created: new Date().toISOString(),
+          lastModified: new Date().toISOString(),
+          author: 'Engineering Team'
+        },
+        // Project Settings
+        projectSettings: {
+          units: 'metric',
+          // or 'imperial'
+          scale: 1.0,
+          gridSize: 1.0,
+          snapToGrid: true,
+          showGrid: true,
+          showAxes: true
+        },
+        // Viewport Settings
+        viewportSettings: {
+          defaultViewMode: 'perspective',
+          backgroundType: 'skybox',
+          showEnvironment: true,
+          autoRotate: false,
+          cameraPosition: {
+            x: 10,
+            y: 10,
+            z: 10
+          },
+          cameraTarget: {
+            x: 0,
+            y: 0,
+            z: 0
+          }
+        },
+        // Component Settings
+        componentSettings: {
+          defaultComponentScale: 1.0,
+          showBoundingBoxes: false,
+          showConnectionPaths: true,
+          highlightOnHover: true,
+          selectionOutlineColor: '#00ff00'
+        },
+        // Spatial Boundaries
+        spatialBoundaries: {
+          min: {
+            x: -60,
+            y: -16,
+            z: -60
+          },
+          max: {
+            x: 60,
+            y: 16,
+            z: 60
+          },
+          center: {
+            x: 0,
+            y: 4,
+            z: 0
+          }
+        },
+        // System Information
+        systemInfo: {
+          centralPlantVersion: '2.0.0',
+          buildDate: new Date().toISOString(),
+          platform: typeof window !== 'undefined' ? window.navigator.platform : 'Unknown',
+          userAgent: typeof window !== 'undefined' ? window.navigator.userAgent : 'Unknown'
+        }
+      };
+
+      // Set each default metadata category
+      Object.keys(defaultMetadata).forEach(function (category) {
+        if (!_this2.hasMetadata(category)) {
+          _this2.setMetadata(category, defaultMetadata[category]);
+        }
+      });
+      console.log('🎯 Default scene metadata initialized:', Object.keys(defaultMetadata));
+    }
+
+    /**
+     * Set default metadata for imported scene data
+     * @param {Object} sceneData - The imported scene data
+     */
+  }, {
+    key: "setDefaultImportedSceneMetadata",
+    value: function setDefaultImportedSceneMetadata(sceneData) {
+      var _sceneData$connection, _sceneData$scene, _sceneData$scene2;
+      var importTimestamp = new Date().toISOString();
+
+      // Extract information from the imported scene data
+      var connectionsCount = ((_sceneData$connection = sceneData.connections) === null || _sceneData$connection === void 0 ? void 0 : _sceneData$connection.length) || 0;
+      var componentsCount = ((_sceneData$scene = sceneData.scene) === null || _sceneData$scene === void 0 || (_sceneData$scene = _sceneData$scene.object) === null || _sceneData$scene === void 0 || (_sceneData$scene = _sceneData$scene.children) === null || _sceneData$scene === void 0 ? void 0 : _sceneData$scene.length) || 0;
+
+      // Count different types of components
+      var componentTypes = {};
+      if ((_sceneData$scene2 = sceneData.scene) !== null && _sceneData$scene2 !== void 0 && (_sceneData$scene2 = _sceneData$scene2.object) !== null && _sceneData$scene2 !== void 0 && _sceneData$scene2.children) {
+        sceneData.scene.object.children.forEach(function (child) {
+          var _child$userData;
+          var componentType = ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.componentType) || 'unknown';
+          componentTypes[componentType] = (componentTypes[componentType] || 0) + 1;
+        });
+      }
+      var importMetadata = {
+        // Import Information
+        importInfo: {
+          importTimestamp: importTimestamp,
+          originalFileName: null,
+          // Will be set from the calling context
+          fileSize: null,
+          // Will be set from the calling context
+          importMethod: 'file-upload',
+          importVersion: '1.0.0'
+        },
+        // Scene Analysis
+        sceneAnalysis: {
+          totalComponents: componentsCount,
+          totalConnections: connectionsCount,
+          componentTypes: componentTypes,
+          sceneComplexity: this.calculateSceneComplexity(connectionsCount, componentsCount),
+          hasValidStructure: this.validateImportedSceneStructure(sceneData)
+        },
+        // Data Quality
+        dataQuality: {
+          hasConnections: connectionsCount > 0,
+          hasComponents: componentsCount > 0,
+          hasValidScene: !!sceneData.scene,
+          missingData: this.identifyMissingData(sceneData),
+          warnings: this.generateImportWarnings(sceneData)
+        },
+        // Processing Stats
+        processingStats: {
+          processedAt: importTimestamp,
+          processingDuration: null,
+          // Can be updated after processing
+          memoryUsage: this.estimateMemoryUsage(sceneData),
+          cacheStatus: 'pending'
+        }
+      };
+
+      // Store import-specific metadata
+      this.setMetadata('lastImport', importMetadata);
+
+      // Update scene info if it exists
+      if (this.hasMetadata('sceneInfo')) {
+        var existingSceneInfo = this.getMetadata('sceneInfo');
+        this.setMetadata('sceneInfo', _objectSpread2(_objectSpread2({}, existingSceneInfo), {}, {
+          lastModified: importTimestamp,
+          importSource: 'file-import',
+          dataSourceType: 'json'
+        }));
+      }
+      console.log('📥 Default imported scene metadata set:', {
+        components: componentsCount,
+        connections: connectionsCount,
+        complexity: importMetadata.sceneAnalysis.sceneComplexity,
+        types: componentTypes
+      });
+    }
+
+    /**
+     * Calculate scene complexity based on components and connections
+     * @param {number} connectionsCount - Number of connections
+     * @param {number} componentsCount - Number of components
+     * @returns {string} Complexity level (simple, moderate, complex, very-complex)
+     */
+  }, {
+    key: "calculateSceneComplexity",
+    value: function calculateSceneComplexity(connectionsCount, componentsCount) {
+      var totalElements = connectionsCount + componentsCount;
+      if (totalElements <= 10) return 'simple';
+      if (totalElements <= 50) return 'moderate';
+      if (totalElements <= 200) return 'complex';
+      return 'very-complex';
+    }
+
+    /**
+     * Validate the structure of imported scene data
+     * @param {Object} sceneData - The imported scene data
+     * @returns {boolean} True if structure is valid
+     */
+  }, {
+    key: "validateImportedSceneStructure",
+    value: function validateImportedSceneStructure(sceneData) {
+      return !!(sceneData && sceneData.scene && sceneData.scene.object && Array.isArray(sceneData.connections));
+    }
+
+    /**
+     * Identify missing or incomplete data in imported scene
+     * @param {Object} sceneData - The imported scene data
+     * @returns {Array} Array of missing data warnings
+     */
+  }, {
+    key: "identifyMissingData",
+    value: function identifyMissingData(sceneData) {
+      var _sceneData$scene3;
+      var missing = [];
+      if (!sceneData.connections || sceneData.connections.length === 0) {
+        missing.push('No connection data found');
+      }
+      if (!((_sceneData$scene3 = sceneData.scene) !== null && _sceneData$scene3 !== void 0 && (_sceneData$scene3 = _sceneData$scene3.object) !== null && _sceneData$scene3 !== void 0 && _sceneData$scene3.children) || sceneData.scene.object.children.length === 0) {
+        missing.push('No component data found');
+      }
+      if (!sceneData.metadata) {
+        missing.push('No metadata found');
+      }
+      if (!sceneData.version) {
+        missing.push('No version information');
+      }
+      return missing;
+    }
+
+    /**
+     * Generate import warnings for potential issues
+     * @param {Object} sceneData - The imported scene data
+     * @returns {Array} Array of warning messages
+     */
+  }, {
+    key: "generateImportWarnings",
+    value: function generateImportWarnings(sceneData) {
+      var _sceneData$scene4, _sceneData$connection2;
+      var warnings = [];
+
+      // Check for large scene data
+      var componentsCount = ((_sceneData$scene4 = sceneData.scene) === null || _sceneData$scene4 === void 0 || (_sceneData$scene4 = _sceneData$scene4.object) === null || _sceneData$scene4 === void 0 || (_sceneData$scene4 = _sceneData$scene4.children) === null || _sceneData$scene4 === void 0 ? void 0 : _sceneData$scene4.length) || 0;
+      if (componentsCount > 100) {
+        warnings.push("Large scene detected (".concat(componentsCount, " components) - may impact performance"));
+      }
+
+      // Check for orphaned components (components without connections)
+      var connectionsCount = ((_sceneData$connection2 = sceneData.connections) === null || _sceneData$connection2 === void 0 ? void 0 : _sceneData$connection2.length) || 0;
+      if (componentsCount > 0 && connectionsCount === 0) {
+        warnings.push('Components found but no connections - scene may be incomplete');
+      }
+
+      // Check for version compatibility
+      if (sceneData.version && parseFloat(sceneData.version) < 1.0) {
+        warnings.push('Scene data version is older than current - some features may not work correctly');
+      }
+      return warnings;
+    }
+
+    /**
+     * Estimate memory usage of imported scene data
+     * @param {Object} sceneData - The imported scene data
+     * @returns {Object} Memory usage estimate
+     */
+  }, {
+    key: "estimateMemoryUsage",
+    value: function estimateMemoryUsage(sceneData) {
+      var jsonSize = JSON.stringify(sceneData).length;
+      var estimatedMB = (jsonSize / 1024 / 1024).toFixed(2);
+      return {
+        jsonSizeBytes: jsonSize,
+        estimatedMB: parseFloat(estimatedMB),
+        category: estimatedMB < 1 ? 'small' : estimatedMB < 10 ? 'medium' : 'large'
+      };
+    }
+
+    /**
+     * Update specific metadata category
+     * @param {string} category - The metadata category (e.g., 'sceneInfo', 'projectSettings')
+     * @param {Object} updates - The updates to apply to the category
+     */
+  }, {
+    key: "updateMetadataCategory",
+    value: function updateMetadataCategory(category, updates) {
+      if (this.hasMetadata(category)) {
+        var existing = this.getMetadata(category);
+        this.setMetadata(category, _objectSpread2(_objectSpread2({}, existing), updates));
+      } else {
+        this.setMetadata(category, updates);
+      }
+      console.log("\uD83D\uDCDD Metadata category '".concat(category, "' updated:"), updates);
+    }
+
+    /**
+     * Undo the last transform operation
+     * @returns {boolean} True if undo was successful, false otherwise
+     */
+  }, {
+    key: "undoTransform",
+    value: function undoTransform() {
+      var lastTransform = this.getLastTransform();
+      if (!lastTransform) {
+        console.warn('⚠️ No transform to undo');
+        return false;
+      }
+      console.log('🔄 Undoing transform:', lastTransform);
+      try {
+        var _this$sceneViewer;
+        var object = lastTransform.object,
+          type = lastTransform.type,
+          previousValues = lastTransform.previousValues;
+        if (!object || !previousValues) {
+          console.error('❌ Invalid transform data for undo');
+          return false;
+        }
+
+        // Debug current state before undo
+        this.debugTransformState(object, 'Before Undo');
+
+        // Debug the structure of previousValues
+        console.log('🔍 previousValues structure:', {
+          type: _typeof(previousValues),
+          keys: Object.keys(previousValues || {}),
+          values: previousValues,
+          hasPosition: !!(previousValues && previousValues.position),
+          hasRotation: !!(previousValues && previousValues.rotation),
+          hasScale: !!(previousValues && previousValues.scale),
+          hasDirectXYZ: !!(previousValues && (previousValues.x !== undefined || previousValues.y !== undefined || previousValues.z !== undefined))
+        });
+
+        // Verify the object still exists in the scene
+        if (this.sceneViewer && this.sceneViewer.scene) {
+          var objectFound = false;
+          this.sceneViewer.scene.traverse(function (child) {
+            if (child === object) {
+              objectFound = true;
+              console.log("undoTransform object:", object);
+            }
+          });
+          if (!objectFound) {
+            console.error('❌ Object no longer exists in scene, cannot undo');
+            return false;
+          }
+        }
+
+        // Apply the previous values based on transform type
+        switch (type) {
+          case 'translate':
+          case 'position':
+            console.log('🔄 undoTransform - Undoing position transform:', {
+              current: {
+                x: object.position.x,
+                y: object.position.y,
+                z: object.position.z
+              },
+              restoring: previousValues,
+              restoringPosition: previousValues.position
+            });
+
+            // Check if previousValues has position property (Vector3) or direct x,y,z properties
+            if (previousValues.position) {
+              // Handle Vector3 object
+              if (previousValues.position.x !== undefined) object.position.x = previousValues.position.x;
+              if (previousValues.position.y !== undefined) object.position.y = previousValues.position.y;
+              if (previousValues.position.z !== undefined) object.position.z = previousValues.position.z;
+            } else {
+              // Handle direct x,y,z properties
+              if (previousValues.x !== undefined) object.position.x = previousValues.x;
+              if (previousValues.y !== undefined) object.position.y = previousValues.y;
+              if (previousValues.z !== undefined) object.position.z = previousValues.z;
+            }
+            console.log('✅ undoTransform - Position restored to:', {
+              x: object.position.x,
+              y: object.position.y,
+              z: object.position.z
+            });
+            break;
+          case 'rotate':
+          case 'rotation':
+            console.log('🔄 Undoing rotation transform:', {
+              current: {
+                x: object.rotation.x,
+                y: object.rotation.y,
+                z: object.rotation.z
+              },
+              restoring: previousValues,
+              restoringRotation: previousValues.rotation
+            });
+
+            // Check if previousValues has rotation property (Euler) or direct x,y,z properties
+            if (previousValues.rotation) {
+              // Handle Euler object
+              if (previousValues.rotation.x !== undefined) object.rotation.x = previousValues.rotation.x;
+              if (previousValues.rotation.y !== undefined) object.rotation.y = previousValues.rotation.y;
+              if (previousValues.rotation.z !== undefined) object.rotation.z = previousValues.rotation.z;
+            } else {
+              // Handle direct x,y,z properties
+              if (previousValues.x !== undefined) object.rotation.x = previousValues.x;
+              if (previousValues.y !== undefined) object.rotation.y = previousValues.y;
+              if (previousValues.z !== undefined) object.rotation.z = previousValues.z;
+            }
+            console.log('✅ Rotation restored to:', {
+              x: object.rotation.x,
+              y: object.rotation.y,
+              z: object.rotation.z
+            });
+            break;
+          case 'scale':
+            console.log('🔄 Undoing scale transform:', {
+              current: {
+                x: object.scale.x,
+                y: object.scale.y,
+                z: object.scale.z
+              },
+              restoring: previousValues,
+              restoringScale: previousValues.scale
+            });
+
+            // Check if previousValues has scale property (Vector3) or direct x,y,z properties
+            if (previousValues.scale) {
+              // Handle Vector3 object
+              if (previousValues.scale.x !== undefined) object.scale.x = previousValues.scale.x;
+              if (previousValues.scale.y !== undefined) object.scale.y = previousValues.scale.y;
+              if (previousValues.scale.z !== undefined) object.scale.z = previousValues.scale.z;
+            } else {
+              // Handle direct x,y,z properties
+              if (previousValues.x !== undefined) object.scale.x = previousValues.x;
+              if (previousValues.y !== undefined) object.scale.y = previousValues.y;
+              if (previousValues.z !== undefined) object.scale.z = previousValues.z;
+            }
+            console.log('✅ Scale restored to:', {
+              x: object.scale.x,
+              y: object.scale.y,
+              z: object.scale.z
+            });
+            break;
+          default:
+            console.warn("\u26A0\uFE0F Unknown transform type for undo: ".concat(type));
+            return false;
+        }
+
+        // Force update the object's matrix to ensure transforms are properly applied
+        object.updateMatrix();
+        object.updateMatrixWorld(true);
+
+        // Get the transform controls manager reference
+        var transformManager = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.transformManager;
+
+        // Update transform controls if they exist and are attached to this object
+        if (transformManager && transformManager.transformControls) {
+          var transformControls = transformManager.transformControls;
+
+          // Check if the object is currently selected
+          var isCurrentlySelected = transformControls.object === object;
+          if (isCurrentlySelected) {
+            console.log('🔧 Updating transform controls after undo');
+
+            // Temporarily detach to force a clean reattachment
+            transformControls.detach();
+
+            // Ensure the transform controls are properly attached to the scene
+            if (transformManager.ensureSceneAttachment) {
+              transformManager.ensureSceneAttachment(true);
+            }
+
+            // Reattach to the object
+            transformControls.attach(object);
+
+            // Update the transform manager's selected object state
+            transformManager.selectedObject = object;
+
+            // Refresh the bounding box if it exists
+            if (transformManager.updateBoundingBox) {
+              transformManager.updateBoundingBox();
+            }
+
+            // Clear any cached bounding box data for this object
+            if (transformManager.boundingBoxCache && transformManager.boundingBoxCache.has(object)) {
+              transformManager.boundingBoxCache.delete(object);
+            }
+            console.log('✅ Transform controls successfully updated after undo');
+          } else {
+            console.log('🔍 Object not currently selected by transform controls');
+          }
+        }
+
+        // Notify SceneOperationsManager about the transform change
+        if (this.sceneViewer && this.sceneViewer.sceneOperationsManager && this.sceneViewer.currentSceneData) {
+          try {
+            console.log('🔄 Updating scene data after undo');
+            this.sceneViewer.onTransformEnd(object);
+            // this.sceneViewer.sceneOperationsManager.updateSceneDataAfterTransform(object, this.sceneViewer.currentSceneData)
+          } catch (sceneOpsError) {
+            console.warn('⚠️ Error updating scene operations after undo:', sceneOpsError);
+            // Continue with undo operation even if scene operations update fails
+          }
+        }
+
+        // Dispatch scene update events if available
+        if (typeof window !== 'undefined') {
+          var sceneUpdateEvent = new CustomEvent('sceneUpdateComplete', {
+            detail: {
+              timestamp: Date.now(),
+              action: 'undo-transform',
+              objectId: object.uuid || object.id || 'unknown'
+            }
+          });
+          window.dispatchEvent(sceneUpdateEvent);
+          console.log('📡 Scene update event dispatched after undo');
+        }
+
+        // Clear the transform history since we've undone it
+        this.clearTransformHistory();
+
+        // Ensure object is selectable after undo
+        this.ensureObjectSelectable(object);
+
+        // Debug final state after undo
+        this.debugTransformState(object, 'After Undo');
+
+        // Log success
+        console.log('✅ Transform undone successfully', {
+          type: type,
+          objectId: object.uuid || object.id || 'unknown',
+          restoredValues: previousValues,
+          matrixUpdated: true,
+          transformControlsUpdated: !!(this.sceneViewer && this.sceneViewer.transformManager),
+          sceneRerendered: !!(this.sceneViewer && this.sceneViewer.renderer)
+        });
+        return true;
+      } catch (error) {
+        console.error('❌ Error undoing transform:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Ensure object is properly selectable after undo operation
+     * This method addresses issues where transform controls become unresponsive
+     * @param {Object} object - The Three.js object to ensure is selectable
+     * @returns {boolean} True if object selection was refreshed successfully
+     */
+  }, {
+    key: "ensureObjectSelectable",
+    value: function ensureObjectSelectable(object) {
+      if (!object || !this.sceneViewer) {
+        console.warn('⚠️ Cannot ensure object selectable: missing object or scene viewer');
+        return false;
+      }
+      try {
+        var transformManager = this.sceneViewer.transformManager;
+        if (!transformManager) {
+          console.warn('⚠️ Transform manager not available');
+          return false;
+        }
+
+        // Use the recovery method in transform controls manager
+        if (transformManager.recoverTransformControls) {
+          console.log('🔄 Using transform controls recovery method');
+          return transformManager.recoverTransformControls(object);
+        }
+
+        // Fallback to original method if recovery method not available
+        console.log('⚠️ Recovery method not available, using fallback');
+
+        // Force update the object's world matrix
+        object.updateMatrixWorld(true);
+
+        // Clear any cached bounding box data for this object
+        if (transformManager.boundingBoxCache && transformManager.boundingBoxCache.has(object)) {
+          transformManager.boundingBoxCache.delete(object);
+          console.log('🧹 Cleared bounding box cache for object');
+        }
+
+        // Ensure transform controls are properly attached to the scene
+        if (transformManager.ensureSceneAttachment) {
+          transformManager.ensureSceneAttachment(true);
+        }
+
+        // If this object is currently selected, refresh the selection
+        if (transformManager.selectedObject === object) {
+          console.log('🔄 Refreshing object selection after undo');
+
+          // Temporarily deselect
+          transformManager.deselectObject();
+
+          // Wait a frame to ensure state is clean
+          requestAnimationFrame(function () {
+            // Reselect the object
+            transformManager.selectObjectForTransformOnly(object);
+            console.log('✅ Object selection refreshed successfully');
+          });
+        }
+        return true;
+      } catch (error) {
+        console.error('❌ Error ensuring object selectable:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Debug method to log current transform state of an object
+     * @param {Object} object - The Three.js object to debug
+     * @param {string} context - Context string for logging
+     */
+  }, {
+    key: "debugTransformState",
+    value: function debugTransformState(object) {
+      var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Debug';
+      if (!object) {
+        console.log("\uD83D\uDD0D ".concat(context, ": No object provided"));
+        return;
+      }
+      console.log("\uD83D\uDD0D ".concat(context, " - Object Transform State:"), {
+        objectId: object.uuid || object.id || 'unknown',
+        position: {
+          x: object.position.x,
+          y: object.position.y,
+          z: object.position.z
+        },
+        rotation: {
+          x: object.rotation.x,
+          y: object.rotation.y,
+          z: object.rotation.z
+        },
+        scale: {
+          x: object.scale.x,
+          y: object.scale.y,
+          z: object.scale.z
+        },
+        matrixWorldNeedsUpdate: object.matrixWorldNeedsUpdate,
+        visible: object.visible,
+        parent: object.parent ? object.parent.uuid || object.parent.id || 'unknown' : 'none',
+        inScene: this.sceneViewer && this.sceneViewer.scene ? this.isObjectInScene(object) : 'unknown'
+      });
+    }
+
+    /**
+    * Manual fix for when transform controls become unresponsive
+    * Call this method if you can't select objects after undo
+    * @returns {boolean} True if fix was attempted
+    */
+  }, {
+    key: "fixTransformControlsSelection",
+    value: function fixTransformControlsSelection() {
+      if (!this.sceneViewer || !this.sceneViewer.transformManager) {
+        console.warn('⚠️ Cannot fix transform controls: missing scene viewer or transform manager');
+        return false;
+      }
+      var transformManager = this.sceneViewer.transformManager;
+      console.log('🔧 Manually fixing transform controls selection...');
+
+      // Try to recover the transform controls
+      if (transformManager.recoverTransformControls) {
+        var result = transformManager.recoverTransformControls();
+        if (result) {
+          console.log('✅ Transform controls manually fixed');
+          return true;
+        }
+      }
+
+      // Fallback: Force recreate the entire transform controls system
+      try {
+        console.log('🔄 Attempting to recreate transform controls system...');
+
+        // Store current settings
+        var currentMode = transformManager.currentMode;
+        var currentSpace = transformManager.currentSpace;
+
+        // Dispose existing controls
+        if (transformManager.transformControls) {
+          transformManager.transformControls.detach();
+          transformManager.scene.remove(transformManager.transformControls);
+          transformManager.transformControls.dispose();
+          transformManager.transformControls = null;
+        }
+
+        // Recreate controls
+        transformManager.createTransformControls();
+        transformManager.setupEventListeners();
+
+        // Restore settings
+        transformManager.setMode(currentMode);
+        transformManager.setSpace(currentSpace);
+        console.log('✅ Transform controls system recreated successfully');
+        return true;
+      } catch (error) {
+        console.error('❌ Error recreating transform controls:', error);
+        return false;
+      }
+    }
+
+    /**
+     * Check if an object is in the scene
+     * @param {Object} object - The Three.js object to check
+     * @returns {boolean} True if object is in scene
+     */
+  }, {
+    key: "isObjectInScene",
+    value: function isObjectInScene(object) {
+      if (!this.sceneViewer || !this.sceneViewer.scene) return false;
+      var found = false;
+      this.sceneViewer.scene.traverse(function (child) {
+        if (child === object) {
+          found = true;
+        }
+      });
+      return found;
+    }
+  }]);
+}();
+
+export { CentralPlant, CentralPlant as default };