@2112-lab/central-plant 0.3.4 → 0.3.6

package/dist/bundle/index.js

@@ -29813,15 +29813,28 @@ var ModelManager = /*#__PURE__*/function () {
               _context5.n = 2;
               return Promise.all(glbLoadingPromises);
             case 2:
-              // Update world bounding boxes for loaded models
+              // Update world bounding boxes for loaded models and propagate to the live Three.js objects
               libraryObjectsToReplace.forEach(function (_ref2) {
-                var _jsonData$userData2;
                 var jsonData = _ref2.jsonData,
                   glbModel = _ref2.glbModel;
-                if (glbModel && (_jsonData$userData2 = jsonData.userData) !== null && _jsonData$userData2 !== void 0 && _jsonData$userData2.worldBoundingBox) {
-                  var worldBoundingBox = _this3._calculateWorldBoundingBox(glbModel);
-                  jsonData.userData.worldBoundingBox = worldBoundingBox;
-                }
+                if (!glbModel) return;
+                // Use filtered bbox (excludes connectors + io-devices) so it matches
+                // what pathfindingManager._enrichSceneDataWithBoundingBoxes produces
+                var filteredBox = computeFilteredBoundingBox(glbModel, ['io-device', 'connector']);
+                var worldBoundingBox = filteredBox.isEmpty() ? _this3._calculateWorldBoundingBox(glbModel) : {
+                  min: [filteredBox.min.x, filteredBox.min.y, filteredBox.min.z],
+                  max: [filteredBox.max.x, filteredBox.max.y, filteredBox.max.z]
+                };
+                // Update both the JSON data object AND the live scene object
+                jsonData.userData.worldBoundingBox = worldBoundingBox;
+                glbModel.userData.worldBoundingBox = worldBoundingBox;
+                // Snapshot the object's local position so viewport2DManager can compute
+                // world-bbox updates via a fast O(1) position delta instead of re-traversing geometry
+                glbModel.userData._wbbBasePosition = {
+                  x: glbModel.position.x,
+                  y: glbModel.position.y,
+                  z: glbModel.position.z
+                };
               });
 
               // Dispatch completion event
@@ -30121,10 +30134,10 @@ var SceneClearingUtility = /*#__PURE__*/function () {
               throw new Error('Scene not available for clearing');
             case 1:
               componentsToRemove = [];
-              scene = this.sceneViewer.scene; // Collect only component objects
+              scene = this.sceneViewer.scene; // Collect component, segment, and gateway objects
               scene.traverse(function (child) {
                 if (child === scene) return;
-                var isComponent = child.userData && (child.userData.objectType === 'component' || child.userData.objectType === 'component');
+                var isComponent = child.userData && (child.userData.objectType === 'component' || child.userData.objectType === 'segment' || child.userData.objectType === 'gateway' || child.userData.objectType === 'connector');
                 var isDirectChild = child.parent === scene;
                 if (isComponent && isDirectChild) {
                   componentsToRemove.push(child);
@@ -31117,123 +31130,52 @@ var SceneOperationsManager = /*#__PURE__*/function () {
     }
 
     /**
-     * Helper function to compute world bounding boxes
-     * For components: uses filtered bbox (excludes io-device and connector subtrees)
-     * For io-devices: computes separate bounding boxes and injects them as children
-     */
-  }, {
-    key: "computeWorldBoundingBoxes",
-    value: function computeWorldBoundingBoxes(data) {
-      var component = this.sceneViewer;
-      component.scene.traverse(function (object) {
-        if (object.isMesh) {
-          // Find the corresponding JSON object
-          var jsonObject = null;
-          var _findJsonObject = function findJsonObject(children) {
-            var _iterator = _createForOfIteratorHelper(children),
-              _step;
-            try {
-              for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                var _object$userData, _child$userData4;
-                var child = _step.value;
-                // Enhanced matching logic with hardcoded UUID priority
-
-                // Strategy 1: Direct hardcoded UUID match (HIGHEST PRIORITY)
-                if (child.uuid === object.uuid || child.uuid === ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.originalUuid) || object.uuid === ((_child$userData4 = child.userData) === null || _child$userData4 === void 0 ? void 0 : _child$userData4.originalUuid)) {
-                  return child;
-                }
-
-                // Recursively search children
-                if (child.children) {
-                  var found = _findJsonObject(child.children);
-                  if (found) return found;
-                }
-              }
-            } catch (err) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
-            }
-            return null;
-          };
-          jsonObject = _findJsonObject(data.scene.children);
-          if (jsonObject) {
-            // Store in JSON userData for pathfinder (skip for gateways - they're just routing points)
-            if (!jsonObject.userData) jsonObject.userData = {};
-            if (jsonObject.userData.objectType === 'component') {
-              // For components: compute filtered bounding box (excludes io-device and connector subtrees)
-              var filteredBBox = computeFilteredBoundingBox(object, ['io-device', 'connector']);
-              jsonObject.userData.worldBoundingBox = {
-                min: filteredBBox.min.toArray(),
-                max: filteredBBox.max.toArray()
-              };
-              console.log("Added filtered world bounding box for component:", jsonObject.userData.worldBoundingBox);
-
-              // Compute and inject separate io-device bounding boxes as children
-              var ioDeviceBBoxes = computeIODeviceBoundingBoxes(object);
-              if (ioDeviceBBoxes.length > 0) {
-                if (!jsonObject.children) jsonObject.children = [];
-                ioDeviceBBoxes.forEach(function (deviceBBox) {
-                  var existingIndex = jsonObject.children.findIndex(function (c) {
-                    return c.uuid === deviceBBox.uuid;
-                  });
-                  if (existingIndex >= 0) {
-                    // Update existing entry
-                    if (!jsonObject.children[existingIndex].userData) jsonObject.children[existingIndex].userData = {};
-                    jsonObject.children[existingIndex].userData.objectType = 'io-device';
-                    jsonObject.children[existingIndex].userData.worldBoundingBox = deviceBBox.worldBoundingBox;
-                  } else {
-                    // Create new entry
-                    jsonObject.children.push({
-                      uuid: deviceBBox.uuid,
-                      userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
-                        worldBoundingBox: deviceBBox.worldBoundingBox
-                      }),
-                      children: []
-                    });
-                  }
-                });
-                console.log("\uD83D\uDCE6 Injected ".concat(ioDeviceBBoxes.length, " io-device bbox(es) for component ").concat(jsonObject.uuid));
-              }
-            } else if (jsonObject.userData.objectType !== 'gateway') {
-              // For non-component, non-gateway objects: standard bounding box
-              var boundingBox = new THREE__namespace.Box3().setFromObject(object);
-              jsonObject.userData.worldBoundingBox = {
-                min: boundingBox.min.toArray(),
-                max: boundingBox.max.toArray()
-              };
-              console.log("Added world bounding box:", jsonObject.userData.worldBoundingBox);
-            }
-
-            // For gateways and connectors, ensure userData.position exists in scene data
-            // This is REQUIRED for pathfinder compatibility
-            if (jsonObject.userData.objectType === 'gateway' || jsonObject.userData.objectType === 'connector') {
-              // Use the object's world position (from Three.js mesh)
-              var worldPos = new THREE__namespace.Vector3();
-              object.getWorldPosition(worldPos);
-
-              // ALWAYS update userData.position with world position
-              // This is critical for manual segment connectors which start with local positions
-              jsonObject.userData.position = [worldPos.x, worldPos.y, worldPos.z];
-              console.log("\u2705 Set userData.position for ".concat(jsonObject.userData.objectType, " ").concat(jsonObject.uuid, ": [").concat(worldPos.x.toFixed(2), ", ").concat(worldPos.y.toFixed(2), ", ").concat(worldPos.z.toFixed(2), "]"));
-
-              // For gateways, ensure isDeclared flag is in scene data
-              if (jsonObject.userData.objectType === 'gateway') {
-                if (jsonObject.userData.isDeclared === undefined) {
-                  jsonObject.userData.isDeclared = true;
-                }
-              }
-
-              // For manual segment connectors, ensure isDeclared is set in scene data
-              if (jsonObject.userData.objectType === 'segment-connector' && jsonObject.userData.isDeclared === undefined) {
-                jsonObject.userData.isDeclared = true;
-                console.log("\u2705 Set isDeclared=true for manual segment connector in scene data: ".concat(jsonObject.uuid));
-              }
-
-              // Also sync the mesh's userData.position (belt and suspenders approach)
-              object.userData.position = [worldPos.x, worldPos.y, worldPos.z];
+     * Sync world-space positions and isDeclared flags for gateways and connectors
+     * into the scene JSON data so the pathfinder can read them.
+     *
+     * Bounding boxes for components and segments are intentionally NOT computed here.
+     * They are computed (with matrix-hash caching) by
+     * PathfindingManager._enrichSceneDataWithBoundingBoxes(), which runs after GLB
+     * models are fully loaded and therefore produces correct values.
+     */
+  }, {
+    key: "_syncPositionsForPathfinding",
+    value: function _syncPositionsForPathfinding(data) {
+      var scene = this.sceneViewer.scene;
+      var worldPos = new THREE__namespace.Vector3();
+      var syncPosition = function syncPosition(jsonObject) {
+        var _jsonObject$userData;
+        var object = scene.getObjectByProperty('uuid', jsonObject.uuid) || scene.getObjectByProperty('uuid', (_jsonObject$userData = jsonObject.userData) === null || _jsonObject$userData === void 0 ? void 0 : _jsonObject$userData.originalUuid);
+        if (!object) return;
+        object.getWorldPosition(worldPos);
+        var pos = [worldPos.x, worldPos.y, worldPos.z];
+        jsonObject.userData.position = pos;
+        object.userData.position = pos;
+      };
+      data.scene.children.forEach(function (jsonObject) {
+        var _jsonObject$userData2;
+        var type = (_jsonObject$userData2 = jsonObject.userData) === null || _jsonObject$userData2 === void 0 ? void 0 : _jsonObject$userData2.objectType;
+        if (type === 'gateway') {
+          syncPosition(jsonObject);
+          if (jsonObject.userData.isDeclared === undefined) {
+            jsonObject.userData.isDeclared = true;
+          }
+        } else if (type === 'connector') {
+          syncPosition(jsonObject);
+        } else if (type === 'segment-connector') {
+          syncPosition(jsonObject);
+          if (jsonObject.userData.isDeclared === undefined) {
+            jsonObject.userData.isDeclared = true;
+          }
+        } else if (type === 'component' && Array.isArray(jsonObject.children)) {
+          // Connectors are injected as JSON children by _injectConnectorChildrenFromDictionary
+          // and their Three.js objects exist in the scene, created recursively by createSceneObject
+          jsonObject.children.forEach(function (childJson) {
+            var _childJson$userData;
+            if (((_childJson$userData = childJson.userData) === null || _childJson$userData === void 0 ? void 0 : _childJson$userData.objectType) === 'connector') {
+              syncPosition(childJson);
             }
-          }
+          });
         }
       });
     }
@@ -31398,10 +31340,10 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       var componentsProcessed = 0;
       var connectorsInjected = 0;
       data.scene.children.forEach(function (child) {
-        var _child$userData5, _child$userData6, _child$userData7;
-        var childType = ((_child$userData5 = child.userData) === null || _child$userData5 === void 0 ? void 0 : _child$userData5.objectType) || ((_child$userData6 = child.userData) === null || _child$userData6 === void 0 ? void 0 : _child$userData6.objectType);
+        var _child$userData4, _child$userData5, _child$userData6;
+        var childType = ((_child$userData4 = child.userData) === null || _child$userData4 === void 0 ? void 0 : _child$userData4.objectType) || ((_child$userData5 = child.userData) === null || _child$userData5 === void 0 ? void 0 : _child$userData5.objectType);
         // Only process components with libraryId
-        if (childType === 'component' && (_child$userData7 = child.userData) !== null && _child$userData7 !== void 0 && _child$userData7.libraryId) {
+        if (childType === 'component' && (_child$userData6 = child.userData) !== null && _child$userData6 !== void 0 && _child$userData6.libraryId) {
           var libraryId = child.userData.libraryId;
           var dictEntry = componentDictionary[libraryId];
 
@@ -31558,23 +31500,25 @@ var SceneOperationsManager = /*#__PURE__*/function () {
               geometries = this.createSceneGeometries(data, componentDictionary); // Create basic objects and track GLB replacements
               libraryObjectsToReplace = [];
               data.scene.children.forEach(function (child, index) {
-                var _child$userData8, _child$userData9;
+                var _child$userData7, _child$userData8;
                 var createdObject = _this4.createSceneObject(child, geometries, materials, componentDictionary);
                 _this4.sceneViewer.scene.add(createdObject);
 
                 // Track objects that need GLB model replacement
-                if ((_child$userData8 = child.userData) !== null && _child$userData8 !== void 0 && _child$userData8.libraryId && componentDictionary[(_child$userData9 = child.userData) === null || _child$userData9 === void 0 ? void 0 : _child$userData9.libraryId]) {
-                  var _child$userData0;
+                if ((_child$userData7 = child.userData) !== null && _child$userData7 !== void 0 && _child$userData7.libraryId && componentDictionary[(_child$userData8 = child.userData) === null || _child$userData8 === void 0 ? void 0 : _child$userData8.libraryId]) {
+                  var _child$userData9;
                   libraryObjectsToReplace.push({
                     basicObject: createdObject,
                     jsonData: child,
-                    componentData: componentDictionary[(_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.libraryId]
+                    componentData: componentDictionary[(_child$userData9 = child.userData) === null || _child$userData9 === void 0 ? void 0 : _child$userData9.libraryId]
                   });
                 }
               });
 
-              // Compute bounding boxes for pathfinding
-              this.computeWorldBoundingBoxes(data);
+              // Sync gateway/connector world positions into JSON before pathfinding.
+              // Bounding boxes are computed later by PathfindingManager._enrichSceneDataWithBoundingBoxes
+              // (after GLB models are loaded), so no bbox work is done here.
+              this._syncPositionsForPathfinding(data);
               this._saveOriginalWorldMatrices(this.sceneViewer.scene);
               return _context6.a(2, {
                 componentDictionary: componentDictionary,
@@ -31720,8 +31664,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       var instanceBehaviors = [];
       if (Array.isArray(data === null || data === void 0 || (_data$scene3 = data.scene) === null || _data$scene3 === void 0 ? void 0 : _data$scene3.children)) {
         data.scene.children.forEach(function (child) {
-          var _child$userData1, _compData$defaultBeha;
-          var libraryId = (_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.libraryId;
+          var _child$userData0, _compData$defaultBeha;
+          var libraryId = (_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.libraryId;
           if (!libraryId) return;
           var instanceUuid = child.uuid;
           // Skip instances whose defaults were already resolved by Step A
@@ -31917,8 +31861,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
     key: "_saveOriginalWorldMatrices",
     value: function _saveOriginalWorldMatrices(scene) {
       scene.traverse(function (object) {
-        var _object$userData2;
-        if ((_object$userData2 = object.userData) !== null && _object$userData2 !== void 0 && _object$userData2.direction) {
+        var _object$userData;
+        if ((_object$userData = object.userData) !== null && _object$userData !== void 0 && _object$userData.direction) {
           var originalMatrix = new THREE__namespace.Matrix4();
           originalMatrix.copy(object.matrixWorld);
         }
@@ -32122,8 +32066,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         // Process children (connectors, etc.) if they exist
         if (componentModel.children && componentModel.children.length > 0) {
           componentModel.children.forEach(function (child) {
-            var _child$userData10, _child$userData11;
-            var childType = ((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.objectType) || ((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType);
+            var _child$userData1, _child$userData10;
+            var childType = ((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.objectType) || ((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.objectType);
             if (childType === 'connector') {
               var _child$geometry;
               var childBoundingBox = new THREE__namespace.Box3().setFromObject(child);
@@ -32208,8 +32152,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       if (segment.children && segment.children.length > 0) {
         var childrenToRemove = _toConsumableArray(segment.children);
         childrenToRemove.forEach(function (child) {
-          var _child$userData12;
-          if ((_child$userData12 = child.userData) !== null && _child$userData12 !== void 0 && _child$userData12.isPipeElbow) {
+          var _child$userData11;
+          if ((_child$userData11 = child.userData) !== null && _child$userData11 !== void 0 && _child$userData11.isPipeElbow) {
             console.log("\uD83D\uDDD1\uFE0F Removing elbow child from segment before manualization: ".concat(child.uuid));
             segment.remove(child);
             if (child.geometry) child.geometry.dispose();
@@ -35479,6 +35423,18 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
     // Map of viewport instances by viewType or custom key
     _this2.viewports = new Map();
 
+    // Per-refresh-cycle bbox cache: keyed by object.uuid, cleared each refresh()
+    // so each component bbox is computed once per cycle regardless of viewport count
+    _this2._bboxCache = new Map();
+
+    // Per-refresh-cycle component list cache: eliminates redundant scene traversals
+    // when all 3 viewports render in the same cycle
+    _this2._componentListCache = null;
+
+    // rAF debounce flag — prevents multiple same-frame refresh() calls from
+    // stacking up independent renderComponents() runs
+    _this2._refreshPending = false;
+
     // Event listener reference for cleanup
     _this2._objectTransformedListener = null;
     console.log('🔲 Viewport2DManager initialized (multi-instance support)');
@@ -35500,7 +35456,6 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
 
       // Listen for object transformations to refresh all viewports
       this._objectTransformedListener = function (eventData) {
-        console.log('🔲 Viewport2DManager detected object transformation, refreshing all viewports');
         _this3.refresh(); // Refresh all viewports
       };
 
@@ -35566,6 +35521,7 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
             case 3:
               // Create new viewport instance
               viewport = new Viewport2DInstance(this.sceneViewer, this.Konva, viewType, container);
+              viewport._instanceKey = key;
               this.viewports.set(key, viewport);
 
               // Initialize the stage for this viewport
@@ -35743,9 +35699,9 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
         viewport.stage.width(width);
         viewport.stage.height(height);
 
-        // Redraw content
+        // Redraw grid immediately; schedule debounced component render
         this.drawGrid(viewport);
-        this.renderComponents(viewport);
+        this.refresh(viewport._instanceKey);
       }
     }
 
@@ -35922,32 +35878,19 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
   }, {
     key: "renderComponent",
     value: function renderComponent(viewport, component, centerX, centerY, scale) {
-      var _component$position$x, _component$position, _component$position$y, _component$position2, _component$position$z, _component$position3, _component$rotation$x, _component$rotation, _component$rotation$y, _component$rotation2, _component$rotation$z, _component$rotation3;
-      // Get component position and rotation
-      var pos3D = {
-        x: (_component$position$x = (_component$position = component.position) === null || _component$position === void 0 ? void 0 : _component$position.x) !== null && _component$position$x !== void 0 ? _component$position$x : 0,
-        y: (_component$position$y = (_component$position2 = component.position) === null || _component$position2 === void 0 ? void 0 : _component$position2.y) !== null && _component$position$y !== void 0 ? _component$position$y : 0,
-        z: (_component$position$z = (_component$position3 = component.position) === null || _component$position3 === void 0 ? void 0 : _component$position3.z) !== null && _component$position$z !== void 0 ? _component$position$z : 0
-      };
-      var rot3D = {
-        x: (_component$rotation$x = (_component$rotation = component.rotation) === null || _component$rotation === void 0 ? void 0 : _component$rotation.x) !== null && _component$rotation$x !== void 0 ? _component$rotation$x : 0,
-        y: (_component$rotation$y = (_component$rotation2 = component.rotation) === null || _component$rotation2 === void 0 ? void 0 : _component$rotation2.y) !== null && _component$rotation$y !== void 0 ? _component$rotation$y : 0,
-        z: (_component$rotation$z = (_component$rotation3 = component.rotation) === null || _component$rotation3 === void 0 ? void 0 : _component$rotation3.z) !== null && _component$rotation$z !== void 0 ? _component$rotation$z : 0
-      };
-
-      // Get bounding box dimensions
+      // Get world-space bounding box dimensions and center
       var _this$getComponentDim = this.getComponentDimensions(component),
         worldWidth = _this$getComponentDim.worldWidth,
         worldDepth = _this$getComponentDim.worldDepth,
-        worldHeight = _this$getComponentDim.worldHeight;
+        worldHeight = _this$getComponentDim.worldHeight,
+        bboxCenter = _this$getComponentDim.bboxCenter;
 
-      // Project 3D coordinates to 2D based on view type
-      var _this$project3DTo2D = this.project3DTo2D(viewport, pos3D, rot3D, worldWidth, worldDepth, worldHeight),
+      // Project 3D bbox center to 2D based on view type
+      var _this$project3DTo2D = this.project3DTo2D(viewport, bboxCenter, worldWidth, worldDepth, worldHeight),
         posX = _this$project3DTo2D.posX,
         posY = _this$project3DTo2D.posY,
         rectWidth = _this$project3DTo2D.rectWidth,
         rectHeight = _this$project3DTo2D.rectHeight;
-        _this$project3DTo2D.rotationDegrees;
       var screenX = centerX + posX * scale;
       var screenY = centerY - posY * scale; // Flip Y for screen coords
 
@@ -35991,105 +35934,156 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
       });
 
       // Add mouse event handlers
-      this.addComponentInteractions(viewport, rect, componentGroup, component, worldWidth, worldDepth, worldHeight);
+      this.addComponentInteractions(viewport, rect, componentGroup, component, worldWidth, worldDepth, worldHeight, bboxCenter);
       componentGroup.add(rect);
       componentGroup.add(label);
       viewport.componentLayer.add(componentGroup);
     }
 
     /**
-     * Get component dimensions from various sources
+     * Compute worldBoundingBox for a live Three.js Object3D using the same
+     * vertex-accurate approach as computeFilteredBoundingBox (explicitly calls
+     * geometry.computeBoundingBox() on each mesh before measuring).
+     * @param {THREE.Object3D} object
+     * @returns {{min: number[], max: number[]}}
+     */
+  }, {
+    key: "_getOrComputeWorldBoundingBox",
+    value: function _getOrComputeWorldBoundingBox(object) {
+      var _object$userData, _object$userData2;
+      // Fast path: offset the stored world bbox by the position delta since load time.
+      // Translation only shifts the bbox center — extents stay identical — so this is O(1)
+      // instead of O(meshes × vertices) from a full geometry traversal.
+      var stored = (_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.worldBoundingBox;
+      var basePos = (_object$userData2 = object.userData) === null || _object$userData2 === void 0 ? void 0 : _object$userData2._wbbBasePosition;
+      if (stored && basePos) {
+        var dx = object.position.x - basePos.x;
+        var dy = object.position.y - basePos.y;
+        var dz = object.position.z - basePos.z;
+        if (dx === 0 && dy === 0 && dz === 0) return stored;
+        return {
+          min: [stored.min[0] + dx, stored.min[1] + dy, stored.min[2] + dz],
+          max: [stored.max[0] + dx, stored.max[1] + dy, stored.max[2] + dz]
+        };
+      }
+
+      // Slow path: full vertex-accurate traversal (fallback when userData not populated)
+      if (this._bboxCache.has(object.uuid)) {
+        return this._bboxCache.get(object.uuid);
+      }
+      var box = computeFilteredBoundingBox(object, []);
+      var result;
+      if (box.isEmpty()) {
+        // Object has no geometry; fall back to a point at world position
+        var wp = new THREE__namespace.Vector3();
+        object.getWorldPosition(wp);
+        result = {
+          min: [wp.x, wp.y, wp.z],
+          max: [wp.x, wp.y, wp.z]
+        };
+      } else {
+        result = {
+          min: [box.min.x, box.min.y, box.min.z],
+          max: [box.max.x, box.max.y, box.max.z]
+        };
+      }
+      this._bboxCache.set(object.uuid, result);
+      return result;
+    }
+
+    /**
+     * Get component dimensions and world-space center from worldBoundingBox
      */
   }, {
     key: "getComponentDimensions",
     value: function getComponentDimensions(component) {
-      var _component$userData, _component$userData2, _component$geometry;
-      var worldWidth = 1,
-        worldHeight = 1,
-        worldDepth = 1;
-
-      // Try adaptedBoundingBox first
-      if ((_component$userData = component.userData) !== null && _component$userData !== void 0 && _component$userData.adaptedBoundingBox) {
-        var bbox = component.userData.adaptedBoundingBox;
-        if (bbox.max && bbox.min) {
-          worldWidth = Math.abs(bbox.max.x - bbox.min.x);
-          worldDepth = Math.abs(bbox.max.y - bbox.min.y);
-          worldHeight = Math.abs(bbox.max.z - bbox.min.z);
-        }
-      }
-      // Fallback to dimensions from userData
-      else if ((_component$userData2 = component.userData) !== null && _component$userData2 !== void 0 && _component$userData2.dimensions) {
-        var dims = component.userData.dimensions;
-        worldWidth = Math.abs(dims.x);
-        worldDepth = Math.abs(dims.y);
-        worldHeight = Math.abs(dims.z);
-      }
-      // Last resort: geometry bounding box
-      else if ((_component$geometry = component.geometry) !== null && _component$geometry !== void 0 && _component$geometry.boundingBox) {
-        var _bbox = component.geometry.boundingBox;
-        worldWidth = Math.abs(_bbox.max.x - _bbox.min.x);
-        worldDepth = Math.abs(_bbox.max.y - _bbox.min.y);
-        worldHeight = Math.abs(_bbox.max.z - _bbox.min.z);
+      var _component$getWorldPo;
+      // Always recompute from the live Three.js object so that the rect reflects
+      // the current world position after translate/drag operations.
+      // userData.worldBoundingBox is a load-time snapshot and goes stale whenever
+      // the object moves, so we cannot rely on it here.
+      var wbb = this._getOrComputeWorldBoundingBox(component);
+      if (wbb !== null && wbb !== void 0 && wbb.min && wbb !== null && wbb !== void 0 && wbb.max) {
+        var _wbb$min = _slicedToArray(wbb.min, 3),
+          minX = _wbb$min[0],
+          minY = _wbb$min[1],
+          minZ = _wbb$min[2];
+        var _wbb$max = _slicedToArray(wbb.max, 3),
+          maxX = _wbb$max[0],
+          maxY = _wbb$max[1],
+          maxZ = _wbb$max[2];
+        var cx = (minX + maxX) / 2;
+        var cy = (minY + maxY) / 2;
+        var cz = (minZ + maxZ) / 2;
+        // Guard against Infinity/NaN from empty or degenerate boxes
+        if (isFinite(cx) && isFinite(cy) && isFinite(cz)) {
+          return {
+            worldWidth: Math.max(maxX - minX, 0.01),
+            worldDepth: Math.max(maxY - minY, 0.01),
+            worldHeight: Math.max(maxZ - minZ, 0.01),
+            bboxCenter: {
+              x: cx,
+              y: cy,
+              z: cz
+            }
+          };
+        }
       }
+      // Fallback: world position of the object, unit dimensions
+      var wp = new THREE__namespace.Vector3();
+      (_component$getWorldPo = component.getWorldPosition) === null || _component$getWorldPo === void 0 || _component$getWorldPo.call(component, wp);
       return {
-        worldWidth: worldWidth,
-        worldDepth: worldDepth,
-        worldHeight: worldHeight
+        worldWidth: 1,
+        worldDepth: 1,
+        worldHeight: 1,
+        bboxCenter: {
+          x: wp.x,
+          y: wp.y,
+          z: wp.z
+        }
       };
     }
 
     /**
-     * Project 3D coordinates to 2D based on view type
+     * Project world-space bbox center to 2D based on view type.
+     * worldBoundingBox is an AABB so rotation is already encoded in the extents —
+     * no separate rotation correction is needed.
      * @param {Viewport2DInstance} viewport - The viewport instance
+     * @param {Object} bboxCenter - World-space center {x, y, z}
+     * @param {number} worldWidth  - X extent (max[0] - min[0])
+     * @param {number} worldDepth  - Y extent (max[1] - min[1])
+     * @param {number} worldHeight - Z extent (max[2] - min[2])
      */
   }, {
     key: "project3DTo2D",
-    value: function project3DTo2D(viewport, pos3D, rot3D, worldWidth, worldDepth, worldHeight) {
-      var posX, posY, rectWidth, rectHeight;
-      var rotationAngle = rot3D.z;
-      var rotationDegrees = rotationAngle * 180 / Math.PI;
+    value: function project3DTo2D(viewport, bboxCenter, worldWidth, worldDepth, worldHeight) {
       var scale = viewport.PIXELS_PER_UNIT;
+      var posX, posY, rectWidth, rectHeight;
       switch (viewport.viewType) {
         case 'top':
-          // Top view: Looking down Z-axis, X-Y plane
-          posX = pos3D.x;
-          posY = pos3D.y;
-
-          // Swap width and depth when rotated 90° or 270°
-          if (Math.abs(rotationDegrees) === 90 || Math.abs(rotationDegrees) === 270) {
-            rectWidth = worldDepth * scale;
-            rectHeight = worldWidth * scale;
-          } else {
-            rectWidth = worldWidth * scale;
-            rectHeight = worldDepth * scale;
-          }
+          // Looking down Z-axis — X/Y plane
+          posX = bboxCenter.x;
+          posY = bboxCenter.y;
+          rectWidth = worldWidth * scale;
+          rectHeight = worldDepth * scale;
           break;
         case 'front':
-          // Front view: Looking along Y-axis, X-Z plane
-          posX = pos3D.x;
-          posY = pos3D.z + worldHeight / 2; // Offset Z by half height
-
-          if (Math.abs(rotationDegrees) === 90 || Math.abs(rotationDegrees) === 270) {
-            rectWidth = worldDepth * scale;
-          } else {
-            rectWidth = worldWidth * scale;
-          }
+          // Looking along Y-axis — X/Z plane
+          posX = bboxCenter.x;
+          posY = bboxCenter.z;
+          rectWidth = worldWidth * scale;
           rectHeight = worldHeight * scale;
           break;
         case 'side':
-          // Side view: Looking along X-axis, Y-Z plane (flipped)
-          posX = -pos3D.y; // Flipped
-          posY = pos3D.z + worldHeight / 2;
-          if (Math.abs(rotationDegrees) === 90 || Math.abs(rotationDegrees) === 270) {
-            rectWidth = worldWidth * scale;
-          } else {
-            rectWidth = worldDepth * scale;
-          }
+          // Looking along X-axis — Y/Z plane (Y negated for left-right orientation)
+          posX = -bboxCenter.y;
+          posY = bboxCenter.z;
+          rectWidth = worldDepth * scale;
           rectHeight = worldHeight * scale;
           break;
         default:
-          posX = pos3D.x;
-          posY = pos3D.y;
+          posX = bboxCenter.x;
+          posY = bboxCenter.y;
           rectWidth = worldWidth * scale;
           rectHeight = worldDepth * scale;
       }
@@ -36097,8 +36091,7 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
         posX: posX,
         posY: posY,
         rectWidth: rectWidth,
-        rectHeight: rectHeight,
-        rotationDegrees: rotationDegrees
+        rectHeight: rectHeight
       };
     }
 
@@ -36108,7 +36101,7 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
      */
   }, {
     key: "addComponentInteractions",
-    value: function addComponentInteractions(viewport, rect, componentGroup, component, worldWidth, worldDepth, worldHeight) {
+    value: function addComponentInteractions(viewport, rect, componentGroup, component, worldWidth, worldDepth, worldHeight, bboxCenter) {
       var _this6 = this;
       if (!this.Konva) return;
       var colors = this.generateComponentColor(component.id);
@@ -36120,7 +36113,7 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
           rect.stroke('#007bff');
           rect.strokeWidth(3);
           viewport.stage.container().style.cursor = 'grab';
-          viewport.componentLayer.draw();
+          viewport.componentLayer.batchDraw();
         }
       });
       rect.on('mouseleave', function () {
@@ -36129,7 +36122,7 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
           rect.stroke(colors.stroke);
           rect.strokeWidth(2);
           viewport.stage.container().style.cursor = 'default';
-          viewport.componentLayer.draw();
+          viewport.componentLayer.batchDraw();
         }
       });
 
@@ -36173,7 +36166,7 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
         // Snap to grid
         var snappedPos = _this6.snapScreenToGrid(viewport, currentPos.x, currentPos.y, scale, worldOriginX, worldOriginY);
         componentGroup.position(snappedPos);
-        viewport.componentLayer.draw();
+        viewport.componentLayer.batchDraw();
       });
 
       // DRAG END
@@ -36191,9 +36184,9 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
           // Convert screen to world coordinates
           var worldCoords = _this6.screenToWorldCoords(viewport, finalPos.x, finalPos.y, scale, worldOriginX, worldOriginY);
 
-          // Calculate new position
+          // Calculate new position: delta from old bbox center to new bbox center
           var currentPos = component.position;
-          var newPosition = _this6.worldCoordsToObjectPosition(viewport, worldCoords, currentPos, worldWidth, worldDepth, worldHeight);
+          var newPosition = _this6.worldCoordsToObjectPosition(viewport, worldCoords, currentPos, bboxCenter);
 
           // Apply translation via centralPlant API
           var deltaX = newPosition.x - currentPos.x;
@@ -36296,37 +36289,45 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
     }
 
     /**
-     * Convert world coordinates to 3D object position
+     * Convert dragged 2D world coordinates to a new 3D object position.
+     * coord1/coord2 represent where the bbox CENTER should be in the view's 2D plane;
+     * we compute the delta from the old bbox center and apply it to the pivot position.
      * @param {Viewport2DInstance} viewport - The viewport instance
+     * @param {{coord1, coord2}} worldCoords - Projected world coordinates from screen
+     * @param {{x,y,z}} currentPosition - Current Three.js object position (pivot)
+     * @param {{x,y,z}} bboxCenter - Old world-space bbox center
      */
   }, {
     key: "worldCoordsToObjectPosition",
-    value: function worldCoordsToObjectPosition(viewport, worldCoords, currentPosition, worldWidth, worldDepth, worldHeight) {
+    value: function worldCoordsToObjectPosition(viewport, worldCoords, currentPosition, bboxCenter) {
       var coord1 = worldCoords.coord1,
         coord2 = worldCoords.coord2;
       switch (viewport.viewType) {
         case 'top':
+          // coord1=X, coord2=Y in world space
           return {
-            x: coord1,
-            y: coord2,
+            x: currentPosition.x + (coord1 - bboxCenter.x),
+            y: currentPosition.y + (coord2 - bboxCenter.y),
             z: currentPosition.z
           };
         case 'front':
+          // coord1=X, coord2=Z in world space
           return {
-            x: coord1,
+            x: currentPosition.x + (coord1 - bboxCenter.x),
             y: currentPosition.y,
-            z: coord2 - worldHeight / 2
+            z: currentPosition.z + (coord2 - bboxCenter.z)
           };
         case 'side':
+          // coord1=-Y (negated), coord2=Z in world space
           return {
             x: currentPosition.x,
-            y: -coord1,
-            z: coord2 - worldHeight / 2
+            y: currentPosition.y + (-coord1 - bboxCenter.y),
+            z: currentPosition.z + (coord2 - bboxCenter.z)
           };
         default:
           return {
-            x: coord1,
-            y: coord2,
+            x: currentPosition.x + (coord1 - bboxCenter.x),
+            y: currentPosition.y + (coord2 - bboxCenter.y),
             z: currentPosition.z
           };
       }
@@ -36338,17 +36339,20 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
   }, {
     key: "getSceneComponents",
     value: function getSceneComponents() {
+      if (this._componentListCache) return this._componentListCache;
       if (!this.sceneViewer || !this.sceneViewer.scene) {
         return [];
       }
       var components = [];
       this.sceneViewer.scene.traverse(function (object) {
-        var _object$userData, _object$userData2;
-        var objectType = ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.objectType) || ((_object$userData2 = object.userData) === null || _object$userData2 === void 0 ? void 0 : _object$userData2.objectType);
-        if (object.userData && objectType === 'component') {
+        var _object$userData3, _object$userData4;
+        // Only match the ROOT component object — must have both objectType:'component'
+        // AND libraryId (inner GLB mesh nodes don't have libraryId)
+        if (((_object$userData3 = object.userData) === null || _object$userData3 === void 0 ? void 0 : _object$userData3.objectType) === 'component' && (_object$userData4 = object.userData) !== null && _object$userData4 !== void 0 && _object$userData4.libraryId) {
           components.push(object);
         }
       });
+      this._componentListCache = components;
       return components;
     }
 
@@ -36454,35 +36458,45 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
     }
 
     /**
-     * Refresh a specific viewport or all viewports
+     * Refresh a specific viewport or all viewports.
+     * Debounced via requestAnimationFrame so multiple calls within the same
+     * frame (e.g. from Viewport2D mount + refreshAll2DViews) collapse into one.
      * @param {string} key - Optional viewport key. If not provided, refreshes all viewports
      */
   }, {
     key: "refresh",
     value: function refresh() {
+      var _this7 = this;
       var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-      if (key) {
-        var viewport = this.viewports.get(key);
-        if (viewport && viewport.isReady) {
-          this.renderComponents(viewport);
-        }
-      } else {
-        // Refresh all viewports
-        var _iterator = _createForOfIteratorHelper(this.viewports.values()),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var _viewport = _step.value;
-            if (_viewport.isReady) {
-              this.renderComponents(_viewport);
+      if (this._refreshPending) return;
+      this._refreshPending = true;
+      requestAnimationFrame(function () {
+        _this7._refreshPending = false;
+        // Clear per-cycle caches so each component is measured/traversed once per paint
+        _this7._bboxCache.clear();
+        _this7._componentListCache = null;
+        if (key) {
+          var viewport = _this7.viewports.get(key);
+          if (viewport && viewport.isReady) {
+            _this7.renderComponents(viewport);
+          }
+        } else {
+          var _iterator = _createForOfIteratorHelper(_this7.viewports.values()),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var _viewport = _step.value;
+              if (_viewport.isReady) {
+                _this7.renderComponents(_viewport);
+              }
             }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
           }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
         }
-      }
+      });
     }
 
     /**
@@ -37802,7 +37816,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.3.4
+   * @version 0.3.6
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.