@2112-lab/central-plant 0.3.47 → 0.3.48

package/dist/esm/src/managers/pathfinding/pathfindingManager.js

@@ -1,9 +1,9 @@
-import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, objectSpread2 as _objectSpread2, slicedToArray as _slicedToArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, typeof as _typeof } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, objectSpread2 as _objectSpread2, slicedToArray as _slicedToArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, typeof as _typeof, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { Pathfinder } from '@2112-lab/pathfinder';
 import { BaseDisposable } from '../../core/baseDisposable.js';
 import { PathData } from '../../core/pathfindingData.js';
-import { computeFilteredBoundingBox, computeIODeviceBoundingBoxes, computeConnectorBoundingBoxes } from '../../utils/boundingBoxUtils.js';
+import { computeFilteredBoundingBox, computeConnectorBoundingBoxes, computeIODeviceBoundingBoxes } from '../../utils/boundingBoxUtils.js';
 import { SceneDataManager } from './sceneDataManager.js';
 import { PathRenderingManager } from './PathRenderingManager.js';
 import { ConnectorManager } from './ConnectorManager.js';
@@ -137,10 +137,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_matrixHash",
     value: function _matrixHash(obj) {
+      // Force matrix update to ensure we're looking at the latest data
+      obj.updateMatrixWorld(true);
       var e = obj.matrixWorld.elements;
-      // Use position (12-14) + first diagonal entries (0,5,10) — covers
-      // translation AND rotation/scale changes with minimal work.
-      return "".concat(e[0].toFixed(5), ",").concat(e[5].toFixed(5), ",").concat(e[10].toFixed(5), ",").concat(e[12].toFixed(5), ",").concat(e[13].toFixed(5), ",").concat(e[14].toFixed(5));
+      // Just hash the position/rotation/scale part of the matrix (12 elements)
+      return "".concat(e[0].toFixed(3), ",").concat(e[1].toFixed(3), ",").concat(e[2].toFixed(3), ",").concat(e[4].toFixed(3), ",").concat(e[5].toFixed(3), ",").concat(e[6].toFixed(3), ",").concat(e[8].toFixed(3), ",").concat(e[9].toFixed(3), ",").concat(e[10].toFixed(3), ",").concat(e[12].toFixed(3), ",").concat(e[13].toFixed(3), ",").concat(e[14].toFixed(3));
     }
 
     /**
@@ -158,11 +159,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
      * Compute a lightweight fingerprint of the pathfinding inputs so that
      * consecutive identical runs can be skipped entirely.
      *
-     * The fingerprint captures:
-     *  • The connections list (from / to pairs)
-     *  • The world transform of every top-level child in sceneData
-     *
-     * @param {Object} sceneData  - scene data object with .children
+     * @param {Object} sceneData  - scene object or manifest
      * @param {Array}  connections - array of {from, to}
      * @returns {string}
      * @private
@@ -170,277 +167,241 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_computePathfindingFingerprint",
     value: function _computePathfindingFingerprint(sceneData, connections) {
+      var _this3 = this;
       var parts = [];
 
       // 1. Connections (sorted so order doesn't matter)
-      parts.push(connections.map(function (c) {
+      parts.push((connections || []).map(function (c) {
         return "".concat(c.from, "->").concat(c.to);
       }).sort().join(','));
 
-      // 2. World transforms of every referenced scene object
-      if (sceneData.children) {
-        var _iterator = _createForOfIteratorHelper(sceneData.children),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var child = _step.value;
-            var obj = this.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
-            if (obj) {
-              parts.push("".concat(child.uuid, ":").concat(this._matrixHash(obj)));
-            } else {
-              var _p$x, _p$y, _p$z;
-              // Object only in data, not in scene — include its serialised position
-              var p = child.position || {};
-              parts.push("".concat(child.uuid, ":").concat(((_p$x = p.x) !== null && _p$x !== void 0 ? _p$x : 0).toFixed(5), ",").concat(((_p$y = p.y) !== null && _p$y !== void 0 ? _p$y : 0).toFixed(5), ",").concat(((_p$z = p.z) !== null && _p$z !== void 0 ? _p$z : 0).toFixed(5)));
-            }
+      // 2. World transforms of every referenced scene object (recursive)
+      var _addTransformsRecursive = function addTransformsRecursive(node) {
+        if (node.uuid) {
+          var obj = _this3.sceneViewer.scene.getObjectByProperty('uuid', node.uuid);
+          if (obj) {
+            parts.push("".concat(node.uuid, ":").concat(_this3._matrixHash(obj)));
+          } else {
+            var _p$x, _p$y, _p$z;
+            // Object only in data, not in scene — include its serialised position
+            var p = node.position || {};
+            parts.push("".concat(node.uuid, ":").concat(((_p$x = p.x) !== null && _p$x !== void 0 ? _p$x : 0).toFixed(5), ",").concat(((_p$y = p.y) !== null && _p$y !== void 0 ? _p$y : 0).toFixed(5), ",").concat(((_p$z = p.z) !== null && _p$z !== void 0 ? _p$z : 0).toFixed(5)));
           }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
         }
+
+        // Handle both flattened array and nested Three.js JSON structures
+        var children = node.children || node.object && node.object.children;
+        if (children && Array.isArray(children)) {
+          children.forEach(_addTransformsRecursive);
+        }
+      };
+      if (sceneData) {
+        _addTransformsRecursive(sceneData);
       }
       return parts.join('|');
     }
 
     /**
-     * Enrich sceneData with worldBoundingBox for segments and components
-     * Connectors remain with just position information.
-     *
-     * Uses _bboxCache to avoid recomputing filtered / io-device bboxes
-     * when the underlying object's world matrix has not changed.
-     *
-     * @param {Object} sceneData - Original scene data
-     * @returns {Object} Enriched scene data (shallow copy with modifications)
+     * Enrich scene data with world-space bounding boxes and positions for collision avoidance
+     * @param {Object|Array} sceneData - Original scene data or array of children
+     * @returns {Object|Array} Enriched scene data (shallow copy with modifications)
      * @private
      */
   }, {
     key: "_enrichSceneDataWithBoundingBoxes",
     value: function _enrichSceneDataWithBoundingBoxes(sceneData) {
-      var _this3 = this;
-      // Create a shallow copy of sceneData structure
-      var enriched = _objectSpread2({}, sceneData);
-      if (!sceneData.children || !Array.isArray(sceneData.children)) {
-        console.warn('⚠️ sceneData has no children array');
-        return enriched;
-      }
+      var _this4 = this;
+      if (!sceneData) return sceneData;
+
+      // Recursive helper to enrich a node and its children
+      var _enrichNode = function enrichNode(node) {
+        if (!node) return node;
+        var enrichedNode = _objectSpread2({}, node);
 
-      // Process children to add worldBoundingBox to segments and components
-      enriched.children = sceneData.children.map(function (child) {
-        // Enrich segments (check if objectType is 'segment' in userData)
-        if (child.userData && child.userData.objectType === 'segment') {
-          // Find the actual segment object in the scene
-          var segmentObject = _this3.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
+        // Skip computed objects ( elbows etc )
+        if (node.userData && (node.userData.isComputed === true || node.userData.objectType === 'elbow')) {
+          return node;
+        }
+
+        // ── Enrich Segments ──
+        if (node.userData && node.userData.objectType === 'segment') {
+          var segmentObject = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.uuid);
           if (segmentObject) {
-            // ── Cache check ──
-            var hash = _this3._matrixHash(segmentObject);
-            var cached = _this3._bboxCache.get(child.uuid);
+            var hash = _this4._matrixHash(segmentObject);
+            var cached = _this4._bboxCache.get(node.uuid);
             if (cached && cached.matrixHash === hash && cached.segmentBBox) {
-              return _objectSpread2(_objectSpread2({}, child), {}, {
-                userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-                  worldBoundingBox: cached.segmentBBox
-                })
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+                worldBoundingBox: cached.segmentBBox
               });
-            }
-
-            // Compute world bounding box
-            var worldBBox = new THREE.Box3().setFromObject(segmentObject);
-            var bboxData = {
-              min: [worldBBox.min.x, worldBBox.min.y, worldBBox.min.z],
-              max: [worldBBox.max.x, worldBBox.max.y, worldBBox.max.z]
-            };
-
-            // Store in cache
-            _this3._bboxCache.set(child.uuid, {
-              matrixHash: hash,
-              segmentBBox: bboxData
-            });
-            return _objectSpread2(_objectSpread2({}, child), {}, {
-              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
+            } else {
+              var worldBBox = new THREE.Box3().setFromObject(segmentObject);
+              var bboxData = {
+                min: [worldBBox.min.x, worldBBox.min.y, worldBBox.min.z],
+                max: [worldBBox.max.x, worldBBox.max.y, worldBBox.max.z]
+              };
+              _this4._bboxCache.set(node.uuid, {
+                matrixHash: hash,
+                segmentBBox: bboxData
+              });
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
                 worldBoundingBox: bboxData
-              })
-            });
-          } else {
-            console.warn("\u26A0\uFE0F Could not find segment object in scene: ".concat(child.uuid));
+              });
+            }
           }
         }
 
-        // Enrich components (check if objectType is 'component' in userData)
-        if (child.userData && child.userData.objectType === 'component') {
-          // Find the actual component object in the scene
-          var componentObject = _this3.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
+        // ── Enrich Components ──
+        else if (node.userData && node.userData.objectType === 'component') {
+          var componentObject = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.uuid);
           if (componentObject) {
-            // ── Cache check ──
-            var _hash = _this3._matrixHash(componentObject);
-            var _cached = _this3._bboxCache.get(child.uuid);
+            componentObject.updateMatrixWorld(true);
+            var _hash = _this4._matrixHash(componentObject);
+            var _cached = _this4._bboxCache.get(node.uuid);
             if (_cached && _cached.matrixHash === _hash && _cached.filteredBBox) {
-              // Rebuild enriched child from cached data
-              var _enrichedChild = _objectSpread2(_objectSpread2({}, child), {}, {
-                userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-                  worldBoundingBox: _cached.filteredBBox
-                })
+              enrichedNode.position = {
+                x: componentObject.position.x,
+                y: componentObject.position.y,
+                z: componentObject.position.z
+              };
+              enrichedNode.rotation = {
+                x: THREE.MathUtils.radToDeg(componentObject.rotation.x),
+                y: THREE.MathUtils.radToDeg(componentObject.rotation.y),
+                z: THREE.MathUtils.radToDeg(componentObject.rotation.z)
+              };
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+                worldBoundingBox: _cached.filteredBBox,
+                position: [componentObject.position.x, componentObject.position.y, componentObject.position.z]
               });
-              if (_cached.ioDeviceBBoxes && _cached.ioDeviceBBoxes.length > 0) {
-                if (!_enrichedChild.children) _enrichedChild.children = [];
-                _cached.ioDeviceBBoxes.forEach(function (deviceBBox) {
-                  var existingIndex = _enrichedChild.children.findIndex(function (c) {
-                    return c.uuid === deviceBBox.uuid;
-                  });
-                  if (existingIndex >= 0) {
-                    _enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex]), {}, {
-                      userData: _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex].userData), {}, {
-                        objectType: 'io-device',
-                        worldBoundingBox: deviceBBox.worldBoundingBox
-                      })
-                    });
-                  } else {
-                    _enrichedChild.children.push({
-                      uuid: deviceBBox.uuid,
-                      userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
-                        worldBoundingBox: deviceBBox.worldBoundingBox
-                      }),
-                      children: []
-                    });
-                  }
+
+              // Re-merge cached connectors and devices if they exist
+              if (!enrichedNode.children) enrichedNode.children = [];
+              if (_cached.connectorBBoxes) {
+                _cached.connectorBBoxes.forEach(function (conn) {
+                  return _this4._mergeEnrichedChild(enrichedNode.children, conn);
                 });
               }
-
-              // Also reinject connectors from cache
-              if (_cached.connectorBBoxes && _cached.connectorBBoxes.length > 0) {
-                if (!_enrichedChild.children) _enrichedChild.children = [];
-                _cached.connectorBBoxes.forEach(function (connBBox) {
-                  var existingIndex = _enrichedChild.children.findIndex(function (c) {
-                    return c.uuid === connBBox.uuid;
-                  });
-                  if (existingIndex >= 0) {
-                    _enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex]), {}, {
-                      userData: _objectSpread2(_objectSpread2({}, _enrichedChild.children[existingIndex].userData), {}, {
-                        worldBoundingBox: connBBox.worldBoundingBox
-                      })
-                    });
-                  } else {
-                    _enrichedChild.children.push({
-                      uuid: connBBox.uuid,
-                      userData: _objectSpread2(_objectSpread2({}, connBBox.userData), {}, {
-                        worldBoundingBox: connBBox.worldBoundingBox
-                      }),
-                      children: []
-                    });
-                  }
+              if (_cached.ioDeviceBBoxes) {
+                _cached.ioDeviceBBoxes.forEach(function (dev) {
+                  return _this4._mergeEnrichedChild(enrichedNode.children, dev);
                 });
               }
-              return _enrichedChild;
+            } else {
+              var filteredBBox = computeFilteredBoundingBox(componentObject, ['io-device', 'connector']);
+              var _bboxData = {
+                min: [filteredBBox.min.x, filteredBBox.min.y, filteredBBox.min.z],
+                max: [filteredBBox.max.x, filteredBBox.max.y, filteredBBox.max.z]
+              };
+              enrichedNode.position = {
+                x: componentObject.position.x,
+                y: componentObject.position.y,
+                z: componentObject.position.z
+              };
+              enrichedNode.rotation = {
+                x: THREE.MathUtils.radToDeg(componentObject.rotation.x),
+                y: THREE.MathUtils.radToDeg(componentObject.rotation.y),
+                z: THREE.MathUtils.radToDeg(componentObject.rotation.z)
+              };
+              enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+                worldBoundingBox: _bboxData,
+                position: [componentObject.position.x, componentObject.position.y, componentObject.position.z]
+              });
+              var connectorBBoxes = computeConnectorBoundingBoxes(componentObject);
+              var ioDeviceBBoxes = computeIODeviceBoundingBoxes(componentObject);
+              if (!enrichedNode.children) enrichedNode.children = [];
+              connectorBBoxes.forEach(function (conn) {
+                return _this4._mergeEnrichedChild(enrichedNode.children, conn);
+              });
+              ioDeviceBBoxes.forEach(function (dev) {
+                return _this4._mergeEnrichedChild(enrichedNode.children, dev);
+              });
+              _this4._bboxCache.set(node.uuid, {
+                matrixHash: _hash,
+                filteredBBox: _bboxData,
+                ioDeviceBBoxes: ioDeviceBBoxes,
+                connectorBBoxes: connectorBBoxes
+              });
             }
+          }
+        }
 
-            // Compute FILTERED bounding box — excludes io-device and connector subtrees
-            // so the component body bbox is tight-fitting and doesn't envelop attached devices
-            var filteredBBox = computeFilteredBoundingBox(componentObject, ['io-device', 'connector']);
-            console.log("\uD83D\uDD04 Updated worldBoundingBox for component ".concat(child.uuid, " (filtered): min=[").concat(filteredBBox.min.x.toFixed(2), ", ").concat(filteredBBox.min.y.toFixed(2), ", ").concat(filteredBBox.min.z.toFixed(2), "], max=[").concat(filteredBBox.max.x.toFixed(2), ", ").concat(filteredBBox.max.y.toFixed(2), ", ").concat(filteredBBox.max.z.toFixed(2), "]"));
-            var _bboxData = {
-              min: [filteredBBox.min.x, filteredBBox.min.y, filteredBBox.min.z],
-              max: [filteredBBox.max.x, filteredBBox.max.y, filteredBBox.max.z]
+        // ── Enrich Standalone Objects (Gateways/Connectors) ──
+        else if (node.userData && (node.userData.objectType === 'gateway' || node.userData.objectType === 'connector')) {
+          var _node$userData;
+          var object = _this4.sceneViewer.scene.getObjectByProperty('uuid', node.uuid) || _this4.sceneViewer.scene.getObjectByProperty('uuid', (_node$userData = node.userData) === null || _node$userData === void 0 ? void 0 : _node$userData.originalUuid);
+          if (object) {
+            var worldPos = new THREE.Vector3();
+            object.getWorldPosition(worldPos);
+            enrichedNode.position = {
+              x: worldPos.x,
+              y: worldPos.y,
+              z: worldPos.z
             };
-
-            // Build the enriched component entry
-            var enrichedChild = _objectSpread2(_objectSpread2({}, child), {}, {
-              userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-                worldBoundingBox: _bboxData
-              })
+            enrichedNode.userData = _objectSpread2(_objectSpread2({}, node.userData), {}, {
+              position: [worldPos.x, worldPos.y, worldPos.z]
             });
 
-            // Compute separate bounding boxes for each attached io-device
-            var ioDeviceBBoxes = computeIODeviceBoundingBoxes(componentObject);
-            if (ioDeviceBBoxes.length > 0) {
-              // Ensure children array exists (may already contain connectors)
-              if (!enrichedChild.children) {
-                enrichedChild.children = [];
-              }
-
-              // Inject io-device entries with their own worldBoundingBox
-              ioDeviceBBoxes.forEach(function (deviceBBox) {
-                var existingIndex = enrichedChild.children.findIndex(function (c) {
-                  return c.uuid === deviceBBox.uuid;
-                });
-                if (existingIndex >= 0) {
-                  enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex]), {}, {
-                    userData: _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex].userData), {}, {
-                      objectType: 'io-device',
-                      worldBoundingBox: deviceBBox.worldBoundingBox
-                    })
-                  });
-                } else {
-                  enrichedChild.children.push({
-                    uuid: deviceBBox.uuid,
-                    userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
-                      worldBoundingBox: deviceBBox.worldBoundingBox
-                    }),
-                    children: []
-                  });
-                }
-                console.log("\uD83D\uDCE6 Injected io-device bbox for ".concat(deviceBBox.uuid, ": min=[").concat(deviceBBox.worldBoundingBox.min.map(function (v) {
-                  return v.toFixed(2);
-                }).join(', '), "], max=[").concat(deviceBBox.worldBoundingBox.max.map(function (v) {
-                  return v.toFixed(2);
-                }).join(', '), "]"));
-              });
-              console.log("\uD83D\uDCE6 Injected ".concat(ioDeviceBBoxes.length, " io-device bounding box(es) for component ").concat(child.uuid));
-            }
-
-            // PHASE 2: Enrich Connectors (CRITICAL for pathfinding API)
-            // Also compute world bounding boxes for connectors and inject into children.
-            // This ensures endpoints have world coordinates in sceneDataCopy.
-            var connectorBBoxes = computeConnectorBoundingBoxes(componentObject);
-            if (connectorBBoxes.length > 0) {
-              if (!enrichedChild.children) enrichedChild.children = [];
-              connectorBBoxes.forEach(function (connBBox) {
-                var existingIndex = enrichedChild.children.findIndex(function (c) {
-                  return c.uuid === connBBox.uuid;
-                });
-                if (existingIndex >= 0) {
-                  enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex]), {}, {
-                    userData: _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex].userData), {}, {
-                      worldBoundingBox: connBBox.worldBoundingBox
-                    })
-                  });
-                } else {
-                  enrichedChild.children.push({
-                    uuid: connBBox.uuid,
-                    userData: _objectSpread2(_objectSpread2({}, connBBox.userData), {}, {
-                      worldBoundingBox: connBBox.worldBoundingBox
-                    }),
-                    children: []
-                  });
-                }
-              });
+            // If it's a connector, also sync direction
+            if (node.userData.objectType === 'connector') {
+              var worldDir = new THREE.Vector3(0, 0, 1);
+              if (node.userData.direction) worldDir.set(node.userData.direction[0], node.userData.direction[1], node.userData.direction[2]);
+              worldDir.applyQuaternion(object.getWorldQuaternion(new THREE.Quaternion())).normalize();
+              enrichedNode.userData.direction = [worldDir.x, worldDir.y, worldDir.z];
             }
-
-            // Store in cache
-            _this3._bboxCache.set(child.uuid, {
-              matrixHash: _hash,
-              filteredBBox: _bboxData,
-              ioDeviceBBoxes: ioDeviceBBoxes,
-              connectorBBoxes: connectorBBoxes
-            });
-            return enrichedChild;
-          } else {
-            console.warn("\u26A0\uFE0F Could not find component object in scene: ".concat(child.uuid));
           }
         }
 
-        // For non-segments and non-components (including connectors), return as-is
-        return child;
-      });
-      return enriched;
+        // Recurse into children
+        if (node.children && Array.isArray(node.children)) {
+          enrichedNode.children = node.children.map(_enrichNode);
+        }
+        return enrichedNode;
+      };
+
+      // Handle root being an array or object
+      if (Array.isArray(sceneData)) {
+        return sceneData.map(_enrichNode);
+      } else if (sceneData.children && Array.isArray(sceneData.children)) {
+        var enrichedRoot = _objectSpread2({}, sceneData);
+        enrichedRoot.children = sceneData.children.map(_enrichNode);
+        return enrichedRoot;
+      } else {
+        return _enrichNode(sceneData);
+      }
     }
 
     /**
-     * Core pathfinding logic shared across initialization and updates
+     * Helper to merge an enriched child (connector/device) into a children array
+     * @private
      */
+  }, {
+    key: "_mergeEnrichedChild",
+    value: function _mergeEnrichedChild(childrenArray, enrichedData) {
+      var existingIndex = childrenArray.findIndex(function (c) {
+        return c.uuid === enrichedData.uuid;
+      });
+      var nodeToMerge = {
+        uuid: enrichedData.uuid,
+        position: {
+          x: enrichedData.userData.position[0],
+          y: enrichedData.userData.position[1],
+          z: enrichedData.userData.position[2]
+        },
+        userData: _objectSpread2(_objectSpread2({}, enrichedData.userData), {}, {
+          worldBoundingBox: enrichedData.worldBoundingBox
+        }),
+        children: []
+      };
+      if (existingIndex >= 0) {
+        childrenArray[existingIndex] = _objectSpread2(_objectSpread2({}, childrenArray[existingIndex]), nodeToMerge);
+      } else {
+        childrenArray.push(nodeToMerge);
+      }
+    }
   }, {
     key: "_executePathfinding",
-    value: (function () {
+    value: function () {
       var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(sceneData, connections) {
-        var _this4 = this,
+        var _this5 = this,
           _sceneDataCopy$childr,
           _sceneDataCopy$childr2,
           _pathfindingResult$pa,
@@ -452,6 +413,12 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           totalStart,
           inputGenStart,
           enrichedSceneData,
+          _from$userData,
+          _to$userData,
+          firstConn,
+          findEndpoint,
+          from,
+          to,
           connectionsCopy,
           sceneDataCopy,
           algoStart,
@@ -468,6 +435,10 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           while (1) switch (_context.n) {
             case 0:
               options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+              // Fallback to sceneData connections if not explicitly provided (e.g. during transform updates)
+              if (!connections && sceneData && sceneData.connections) {
+                connections = sceneData.connections;
+              }
               options.createGateways, _options$context = options.context, context = _options$context === void 0 ? 'Pathfinding' : _options$context;
               timers = {};
               totalStart = performance.now(); // Create pathfinder instance with configuration only
@@ -496,7 +467,50 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               console.log("\uD83D\uDD04 Updated matrix world for ".concat(context, " pathfinding execution"));
 
               // Enrich sceneData with worldBoundingBox for segments before deep copy
-              enrichedSceneData = this._enrichSceneDataWithBoundingBoxes(sceneData); // Deep copy connections and sceneData to prevent pathfinder from mutating the original
+              enrichedSceneData = this._enrichSceneDataWithBoundingBoxes(sceneData); // DEBUG: Log first connection endpoints in enriched data
+              if (connections && connections.length > 0 && enrichedSceneData.children) {
+                firstConn = connections[0];
+                findEndpoint = function findEndpoint(uuid) {
+                  var _iterator = _createForOfIteratorHelper(enrichedSceneData.children),
+                    _step;
+                  try {
+                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                      var child = _step.value;
+                      if (child.uuid === uuid) return child;
+                      if (child.children) {
+                        var _iterator2 = _createForOfIteratorHelper(child.children),
+                          _step2;
+                        try {
+                          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                            var nested = _step2.value;
+                            if (nested.uuid === uuid) return nested;
+                          }
+                        } catch (err) {
+                          _iterator2.e(err);
+                        } finally {
+                          _iterator2.f();
+                        }
+                      }
+                    }
+                  } catch (err) {
+                    _iterator.e(err);
+                  } finally {
+                    _iterator.f();
+                  }
+                  return null;
+                };
+                from = findEndpoint(firstConn.from);
+                to = findEndpoint(firstConn.to);
+                console.log("\uD83D\uDCE1 [DEBUG] Pathfinding from ".concat(firstConn.from, " to ").concat(firstConn.to));
+                if (from) console.log("   From BBox: min=[".concat((_from$userData = from.userData) === null || _from$userData === void 0 || (_from$userData = _from$userData.worldBoundingBox) === null || _from$userData === void 0 || (_from$userData = _from$userData.min) === null || _from$userData === void 0 ? void 0 : _from$userData.map(function (v) {
+                  return v.toFixed(2);
+                }), "]"));
+                if (to) console.log("   To BBox: min=[".concat((_to$userData = to.userData) === null || _to$userData === void 0 || (_to$userData = _to$userData.worldBoundingBox) === null || _to$userData === void 0 || (_to$userData = _to$userData.min) === null || _to$userData === void 0 ? void 0 : _to$userData.map(function (v) {
+                  return v.toFixed(2);
+                }), "]"));
+              }
+
+              // Deep copy connections and sceneData to prevent pathfinder from mutating the original
               connectionsCopy = structuredClone(connections);
               sceneDataCopy = structuredClone(enrichedSceneData);
               timers.inputGeneration = performance.now() - inputGenStart;
@@ -527,7 +541,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               if (pathfindingResult.paths) {
                 pathfindingResult.paths.forEach(function (path) {
                   var pathId = "".concat(path.from, "-->").concat(path.to);
-                  _this4._getOrCreatePathData(pathId, path.from, path.to);
+                  _this5._getOrCreatePathData(pathId, path.from, path.to);
                 });
               }
               timers.pathRendering = performance.now() - renderStart;
@@ -560,7 +574,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
         return _executePathfinding2.apply(this, arguments);
       }
       return _executePathfinding;
-    }())
+    }()
   }, {
     key: "getSimplifiedSceneData",
     value: function getSimplifiedSceneData() {
@@ -599,7 +613,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_propagateFlowAttributesAndApplyVisualizations",
     value: function _propagateFlowAttributesAndApplyVisualizations(connections, pathfindingResult) {
-      var _this5 = this,
+      var _this6 = this,
         _this$sceneViewer;
       if (!Array.isArray(connections) || !pathfindingResult) return;
 
@@ -627,7 +641,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
         var subPathIds = new Set(originalToSubPaths.get(origId) || []);
         subPathIds.add(origId);
         subPathIds.forEach(function (subPathId) {
-          var pd = _this5.pathDataStore.get(subPathId);
+          var pd = _this6.pathDataStore.get(subPathId);
           if (pd && Object.keys(pd.flowAttributes).length === 0) {
             Object.entries(conn.flowAttributes).forEach(function (_ref2) {
               var _ref3 = _slicedToArray(_ref2, 2),
@@ -691,7 +705,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "initializePathfinder",
     value: (function () {
       var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(data, crosscubeTextureSet) {
-        var _this6 = this;
+        var _this7 = this;
         var pathfindingResult;
         return _regenerator().w(function (_context2) {
           while (1) switch (_context2.n) {
@@ -705,7 +719,7 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
                 data.connections.forEach(function (conn) {
                   if (conn.flowAttributes && _typeof(conn.flowAttributes) === 'object') {
                     var pathId = "".concat(conn.from, "-->").concat(conn.to);
-                    var pd = _this6._getOrCreatePathData(pathId, conn.from, conn.to);
+                    var pd = _this7._getOrCreatePathData(pathId, conn.from, conn.to);
                     Object.entries(conn.flowAttributes).forEach(function (_ref6) {
                       var _ref7 = _slicedToArray(_ref6, 2),
                         key = _ref7[0],
@@ -823,33 +837,47 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "updatePathfindingAfterTransform",
     value: (function () {
       var _updatePathfindingAfterTransform = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(currentSceneData) {
-        var fingerprint, result;
+        var _currentSceneData$sce;
+        var fingerprint, dataRoot, connections, result;
         return _regenerator().w(function (_context3) {
           while (1) switch (_context3.n) {
             case 0:
+              if (!(!currentSceneData || !currentSceneData.scene)) {
+                _context3.n = 1;
+                break;
+              }
+              console.warn('⚠️ updatePathfindingAfterTransform: Invalid scene data');
+              return _context3.a(2, null);
+            case 1:
               // ── Skip-unchanged-paths check ──────────────────────────────────
               // Ensure matrices are fresh so the fingerprint is accurate.
               this.sceneViewer.scene.updateMatrixWorld(true);
               fingerprint = this._computePathfindingFingerprint(currentSceneData.scene, currentSceneData.connections);
+              console.log("\uD83D\uDD0D Pathfinding update check. Fingerprint: ".concat(fingerprint.substring(0, 50), "..."));
               if (!(fingerprint === this._lastPathfindingFingerprint && this._lastPathfindingResult)) {
-                _context3.n = 1;
+                _context3.n = 2;
                 break;
               }
               console.log('⏭️  Pathfinding skipped — inputs unchanged since last run');
               return _context3.a(2, this._lastPathfindingResult);
-            case 1:
+            case 2:
+              // Clear the cache for the specific fingerprint mismatch to ensure fresh enrichment
+              this.invalidateBBoxCache();
+
               // Remove all existing paths from the scene
               this.removeComputedObjects();
               console.log('🔄 Starting pathfinding with updated scene data...');
 
-              // Note: Matrix updates and bounding box recomputation now handled in _executePathfinding
+              // Robust root discovery for different manifest structures
+              dataRoot = ((_currentSceneData$sce = currentSceneData.scene) === null || _currentSceneData$sce === void 0 ? void 0 : _currentSceneData$sce.object) || currentSceneData.scene || currentSceneData;
+              connections = currentSceneData.connections || []; // Note: Matrix updates and bounding box recomputation now handled in _executePathfinding
               // Use shared pathfinding logic (no gateways needed for transform updates)
-              _context3.n = 2;
-              return this._executePathfinding(currentSceneData.scene, currentSceneData.connections, {
+              _context3.n = 3;
+              return this._executePathfinding(dataRoot, connections, {
                 createGateways: true,
                 context: 'Transform Update'
               });
-            case 2:
+            case 3:
               result = _context3.v;
               // Re-apply flow attribute colors (new materials are created on each execution)
               this._propagateFlowAttributesAndApplyVisualizations(currentSceneData.connections, result);