@2112-lab/central-plant 0.1.28 → 0.1.30

package/dist/bundle/index.js

@@ -6,7 +6,6 @@ console.log("Loading Central Plant Utils Bundle...");
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var THREE = require('three');
-var pathfinder = require('@2112-lab/pathfinder');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -17362,6 +17361,1845 @@ var KeyboardControlsManager = /*#__PURE__*/function () {
   }]);
 }();
 
+/**
+ * A simple 3D vector class for internal use
+ * @class Vector3
+ */
+var Vector3 = /*#__PURE__*/function () {
+  /**
+   * Create a new Vector3
+   * @param {number} [x=0] - The x component
+   * @param {number} [y=0] - The y component
+   * @param {number} [z=0] - The z component
+   */
+  function Vector3() {
+    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    _classCallCheck(this, Vector3);
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+
+  /**
+   * Create a copy of this vector
+   * @returns {Vector3} A new vector with the same components
+   */
+  return _createClass(Vector3, [{
+    key: "clone",
+    value: function clone() {
+      return new Vector3(this.x, this.y, this.z);
+    }
+
+    /**
+     * Convert the vector to an array
+     * @returns {Array<number>} Array representation [x, y, z]
+     */
+  }, {
+    key: "toArray",
+    value: function toArray() {
+      return [this.x, this.y, this.z];
+    }
+
+    /**
+     * Normalize this vector (make it unit length)
+     * @returns {Vector3} This vector (for chaining)
+     */
+  }, {
+    key: "normalize",
+    value: function normalize() {
+      var length = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+      if (length > 0) {
+        this.x /= length;
+        this.y /= length;
+        this.z /= length;
+      }
+      return this;
+    }
+
+    /**
+     * Subtract another vector from this one
+     * @param {Vector3} v - Vector to subtract
+     * @returns {Vector3} This vector (for chaining)
+     */
+  }, {
+    key: "sub",
+    value: function sub(v) {
+      this.x -= v.x;
+      this.y -= v.y;
+      this.z -= v.z;
+      return this;
+    }
+
+    /**
+     * Multiply this vector by a scalar value
+     * @param {number} scalar - The scalar value to multiply by
+     * @returns {Vector3} This vector (for chaining)
+     */
+  }, {
+    key: "multiplyScalar",
+    value: function multiplyScalar(scalar) {
+      this.x *= scalar;
+      this.y *= scalar;
+      this.z *= scalar;
+      return this;
+    }
+
+    /**
+     * Add another vector to this one
+     * @param {Vector3} v - Vector to add
+     * @returns {Vector3} This vector (for chaining)
+     */
+  }, {
+    key: "add",
+    value: function add(v) {
+      this.x += v.x;
+      this.y += v.y;
+      this.z += v.z;
+      return this;
+    }
+  }]);
+}();
+
+/**
+ * Manages scene operations including object finding, position calculations, and hierarchy traversal
+ */
+var SceneManager = /*#__PURE__*/function () {
+  /**
+   * Create a new SceneManager instance
+   * @param {Object} scene - The scene configuration object
+   */
+  function SceneManager(scene) {
+    _classCallCheck(this, SceneManager);
+    this.scene = scene;
+  }
+
+  /**
+   * Get the root scene object
+   * @returns {Object} The root scene object
+   */
+  return _createClass(SceneManager, [{
+    key: "getRoot",
+    value: function getRoot() {
+      return this.scene.object;
+    }
+
+    /**
+     * Get world position from worldBoundingBox center
+     * @param {Object} object - Scene object
+     * @returns {Vector3} World position
+     */
+  }, {
+    key: "getWorldPosition",
+    value: function getWorldPosition(object) {
+      var _object$userData;
+      if (!((_object$userData = object.userData) !== null && _object$userData !== void 0 && _object$userData.worldBoundingBox)) {
+        console.log("[DEBUG] Object ".concat(object.uuid, " has no worldBoundingBox in userData"));
+        return new Vector3();
+      }
+      var _object$userData$worl = object.userData.worldBoundingBox,
+        min = _object$userData$worl.min,
+        max = _object$userData$worl.max;
+      return new Vector3((min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2);
+    }
+
+    /**
+     * Get bounding box from worldBoundingBox in userData
+     * @param {Object} object - Scene object
+     * @returns {{min: Vector3, max: Vector3}|null} Bounding box or null if no worldBoundingBox
+     */
+  }, {
+    key: "getBoundingBox",
+    value: function getBoundingBox(object) {
+      var _object$userData2;
+      if (!((_object$userData2 = object.userData) !== null && _object$userData2 !== void 0 && _object$userData2.worldBoundingBox)) {
+        console.log("[DEBUG] Object ".concat(object.uuid, " has no worldBoundingBox in userData"));
+        return null;
+      }
+      var _object$userData$worl2 = object.userData.worldBoundingBox,
+        min = _object$userData$worl2.min,
+        max = _object$userData$worl2.max;
+      return {
+        min: new Vector3(min[0], min[1], min[2]),
+        max: new Vector3(max[0], max[1], max[2])
+      };
+    }
+
+    /**
+     * Find an object by UUID in the scene hierarchy
+     * @param {string} uuid - UUID to search for
+     * @returns {Object|null} Found object or null
+     */
+  }, {
+    key: "findObjectByUUID",
+    value: function findObjectByUUID(uuid) {
+      return this._findObjectByUUIDRecursive(this.getRoot(), uuid);
+    }
+
+    /**
+     * Recursive helper for findObjectByUUID
+     * @private
+     * @param {Object} node - Current node to search
+     * @param {string} uuid - UUID to search for
+     * @returns {Object|null} Found object or null
+     */
+  }, {
+    key: "_findObjectByUUIDRecursive",
+    value: function _findObjectByUUIDRecursive(node, uuid) {
+      if (node.uuid === uuid) {
+        return node;
+      }
+      if (node.children) {
+        var _iterator = _createForOfIteratorHelper(node.children),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var child = _step.value;
+            var found = this._findObjectByUUIDRecursive(child, uuid);
+            if (found) return found;
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Find the parent object of a given object in the scene hierarchy
+     * @param {Object} target - Target object to find parent for
+     * @returns {Object|null} Parent object or null if not found or if parent is the scene
+     */
+  }, {
+    key: "findParentObject",
+    value: function findParentObject(target) {
+      if (target.userData && Array.isArray(target.userData.direction)) {
+        return {
+          isDirectionParent: true
+        };
+      }
+      return this._findParentObjectRecursive(this.getRoot(), target);
+    }
+
+    /**
+     * Recursive helper for findParentObject
+     * @private
+     * @param {Object} root - Root object to search from
+     * @param {Object} target - Target object to find parent for
+     * @returns {Object|null} Parent object or null
+     */
+  }, {
+    key: "_findParentObjectRecursive",
+    value: function _findParentObjectRecursive(root, target) {
+      if (root.children) {
+        var _iterator2 = _createForOfIteratorHelper(root.children),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var child = _step2.value;
+            if (child.uuid === target.uuid) {
+              if (root.type === 'Scene') {
+                return null;
+              }
+              return root;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        var _iterator3 = _createForOfIteratorHelper(root.children),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _child = _step3.value;
+            var parent = this._findParentObjectRecursive(_child, target);
+            if (parent) {
+              return parent;
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Check if a voxel is occupied by any mesh object
+     * @param {string} voxelKey - Voxel key to check
+     * @param {number} gridSize - Size of each grid cell
+     * @returns {boolean} True if the voxel is occupied by a mesh object
+     */
+  }, {
+    key: "isVoxelOccupiedByMesh",
+    value: function isVoxelOccupiedByMesh(voxelKey, gridSize) {
+      var _voxelKey$split$map = voxelKey.split(',').map(Number),
+        _voxelKey$split$map2 = _slicedToArray(_voxelKey$split$map, 3),
+        x = _voxelKey$split$map2[0],
+        y = _voxelKey$split$map2[1],
+        z = _voxelKey$split$map2[2];
+      var worldPos = new Vector3(x * gridSize, y * gridSize, z * gridSize);
+      return this._checkObjectOccupancy(this.getRoot(), worldPos);
+    }
+
+    /**
+     * Recursive helper for isVoxelOccupiedByMesh
+     * @private
+     * @param {Object} object - Object to check
+     * @param {Vector3} worldPos - World position to check
+     * @returns {boolean} True if the position is occupied
+     */
+  }, {
+    key: "_checkObjectOccupancy",
+    value: function _checkObjectOccupancy(object, worldPos) {
+      if (object.type === 'Mesh') {
+        var bbox = this.getBoundingBox(object);
+        if (bbox) {
+          if (worldPos.x >= bbox.min.x && worldPos.x <= bbox.max.x && worldPos.y >= bbox.min.y && worldPos.y <= bbox.max.y && worldPos.z >= bbox.min.z && worldPos.z <= bbox.max.z) {
+            return true;
+          }
+        }
+      }
+      if (object.children) {
+        var _iterator4 = _createForOfIteratorHelper(object.children),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var child = _step4.value;
+            if (this._checkObjectOccupancy(child, worldPos)) return true;
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+      return false;
+    }
+  }]);
+}();
+
+/**
+ * Manages grid operations including voxel conversions, neighbor calculations, and distance metrics
+ */
+var GridSystem = /*#__PURE__*/function () {
+  /**
+   * Create a new GridSystem instance
+   * @param {number} gridSize - Size of each grid cell in world units
+   * @param {number} safetyMargin - Safety margin around obstacles in world units
+   */
+  function GridSystem() {
+    var gridSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.5;
+    var safetyMargin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    _classCallCheck(this, GridSystem);
+    this.gridSize = gridSize;
+    this.safetyMargin = safetyMargin;
+  }
+
+  /**
+   * Convert a position to a voxel key
+   * @param {Vector3|Object} pos - Position to convert
+   * @param {number} pos.x - X coordinate
+   * @param {number} pos.y - Y coordinate
+   * @param {number} pos.z - Z coordinate
+   * @returns {string} Voxel key in format "x,y,z"
+   */
+  return _createClass(GridSystem, [{
+    key: "voxelKey",
+    value: function voxelKey(pos) {
+      return [Math.round(pos.x / this.gridSize), Math.round(pos.y / this.gridSize), Math.round(pos.z / this.gridSize)].join(',');
+    }
+
+    /**
+     * Convert a voxel key to a Vector3
+     * @param {string} key - Voxel key
+     * @returns {Vector3} Vector3 position
+     */
+  }, {
+    key: "voxelToVec3",
+    value: function voxelToVec3(key) {
+      var _key$split$map = key.split(',').map(Number),
+        _key$split$map2 = _slicedToArray(_key$split$map, 3),
+        x = _key$split$map2[0],
+        y = _key$split$map2[1],
+        z = _key$split$map2[2];
+      return new Vector3(x * this.gridSize, y * this.gridSize, z * this.gridSize);
+    }
+
+    /**
+     * Get neighboring voxels (axis-aligned)
+     * @param {string} vox - Voxel key
+     * @returns {string[]} Array of neighboring voxel keys
+     */
+  }, {
+    key: "getNeighbors",
+    value: function getNeighbors(vox) {
+      var _vox$split$map = vox.split(',').map(Number),
+        _vox$split$map2 = _slicedToArray(_vox$split$map, 3),
+        x = _vox$split$map2[0],
+        y = _vox$split$map2[1],
+        z = _vox$split$map2[2];
+      return [[x + 1, y, z], [x - 1, y, z], [x, y + 1, z], [x, y - 1, z], [x, y, z + 1], [x, y, z - 1]].map(function (arr) {
+        return arr.join(',');
+      });
+    }
+
+    /**
+     * Calculate Manhattan distance between two voxels
+     * @param {string} a - First voxel key
+     * @param {string} b - Second voxel key
+     * @returns {number} Manhattan distance
+     */
+  }, {
+    key: "manhattan",
+    value: function manhattan(a, b) {
+      var _a$split$map = a.split(',').map(Number),
+        _a$split$map2 = _slicedToArray(_a$split$map, 3),
+        ax = _a$split$map2[0],
+        ay = _a$split$map2[1],
+        az = _a$split$map2[2];
+      var _b$split$map = b.split(',').map(Number),
+        _b$split$map2 = _slicedToArray(_b$split$map, 3),
+        bx = _b$split$map2[0],
+        by = _b$split$map2[1],
+        bz = _b$split$map2[2];
+      return Math.abs(ax - bx) + Math.abs(ay - by) + Math.abs(az - bz);
+    }
+
+    /**
+     * Calculate the number of voxels needed for a given world distance
+     * @param {number} worldDistance - Distance in world units
+     * @returns {number} Number of voxels
+     */
+  }, {
+    key: "worldToVoxelDistance",
+    value: function worldToVoxelDistance(worldDistance) {
+      return Math.ceil(worldDistance / this.gridSize);
+    }
+
+    /**
+     * Calculate the world distance for a given number of voxels
+     * @param {number} voxelCount - Number of voxels
+     * @returns {number} Distance in world units
+     */
+  }, {
+    key: "voxelToWorldDistance",
+    value: function voxelToWorldDistance(voxelCount) {
+      return voxelCount * this.gridSize;
+    }
+
+    /**
+     * Get the safety margin in voxel units
+     * @returns {number} Safety margin in voxels
+     */
+  }, {
+    key: "getSafetyMarginVoxels",
+    value: function getSafetyMarginVoxels() {
+      return this.worldToVoxelDistance(this.safetyMargin);
+    }
+
+    /**
+     * Check if a voxel is within the safety margin of a bounding box
+     * @param {string} voxelKey - Voxel key to check
+     * @param {Object} bbox - Bounding box
+     * @param {Vector3} bbox.min - Minimum coordinates
+     * @param {Vector3} bbox.max - Maximum coordinates
+     * @returns {boolean} True if the voxel is within the safety margin
+     */
+  }, {
+    key: "isVoxelInSafetyMargin",
+    value: function isVoxelInSafetyMargin(voxelKey, bbox) {
+      var voxelPos = this.voxelToVec3(voxelKey);
+      var margin = this.safetyMargin;
+      return voxelPos.x >= bbox.min.x - margin && voxelPos.x <= bbox.max.x + margin && voxelPos.y >= bbox.min.y - margin && voxelPos.y <= bbox.max.y + margin && voxelPos.z >= bbox.min.z - margin && voxelPos.z <= bbox.max.z + margin;
+    }
+
+    /**
+     * Get all voxel keys within a bounding box plus safety margin
+     * @param {Object} bbox - Bounding box
+     * @param {Vector3} bbox.min - Minimum coordinates
+     * @param {Vector3} bbox.max - Maximum coordinates
+     * @returns {string[]} Array of voxel keys
+     */
+  }, {
+    key: "getVoxelsInBoundingBox",
+    value: function getVoxelsInBoundingBox(bbox) {
+      var margin = this.getSafetyMarginVoxels();
+      var min = bbox.min;
+      var max = bbox.max;
+      var voxels = [];
+      for (var x = Math.round(min.x / this.gridSize) - margin; x <= Math.round(max.x / this.gridSize) + margin; x++) {
+        for (var y = Math.round(min.y / this.gridSize) - margin; y <= Math.round(max.y / this.gridSize) + margin; y++) {
+          for (var z = Math.round(min.z / this.gridSize) - margin; z <= Math.round(max.z / this.gridSize) + margin; z++) {
+            voxels.push("".concat(x, ",").concat(y, ",").concat(z));
+          }
+        }
+      }
+      return voxels;
+    }
+  }]);
+}();
+
+/**
+ * Manages connector-related operations for the pathfinding system
+ * @class ConnectorManager
+ */
+var ConnectorManager = /*#__PURE__*/function () {
+  /**
+   * Create a new ConnectorManager instance
+   * @param {Object} config - The configuration object
+   * @param {Array<Object>} config.connections - Array of connections between objects
+   * @param {string} config.connections[].from - UUID of the source object
+   * @param {string} config.connections[].to - UUID of the target object
+   * @param {number} minSegmentLength - Minimum length for straight pipe segments in world units
+   * @param {SceneManager} sceneManager - Instance of SceneManager for scene operations
+   * @param {GridSystem} gridSystem - Instance of GridSystem for grid operations
+   */
+  function ConnectorManager(config, minSegmentLength, sceneManager, gridSystem) {
+    _classCallCheck(this, ConnectorManager);
+    this.config = config;
+    this.MIN_SEGMENT_LENGTH = minSegmentLength;
+    this.sceneManager = sceneManager;
+    this.gridSystem = gridSystem;
+  }
+
+  /**
+   * Check if an object is a connector by checking if it's mentioned in connections
+   * @param {Object} object - Scene object
+   * @returns {boolean} True if the object is a connector
+   */
+  return _createClass(ConnectorManager, [{
+    key: "isConnector",
+    value: function isConnector(object) {
+      if (!this.config.connections) return false;
+
+      // Check if the object's UUID appears in any connection
+      return this.config.connections.some(function (conn) {
+        return conn.from === object.uuid || conn.to === object.uuid;
+      });
+    }
+
+    /**
+     * Calculate direction vector for a connector
+     * @param {Object} connector - Connector object
+     * @returns {Vector3|null} Direction vector or null if no parent or direction
+     */
+  }, {
+    key: "getConnectorDirection",
+    value: function getConnectorDirection(connector) {
+      // First check if direction is directly specified in userData
+      if (connector.userData && Array.isArray(connector.userData.direction)) {
+        var _connector$userData$d = _slicedToArray(connector.userData.direction, 3),
+          x = _connector$userData$d[0],
+          y = _connector$userData$d[1],
+          z = _connector$userData$d[2];
+        return new Vector3(x, y, z);
+      }
+
+      // If no direction in userData and no parent, return null
+      if (!connector.parent) {
+        return null;
+      }
+
+      // For backward compatibility, calculate direction from parent if no userData.direction
+      console.log("[WARNING] No direction in userData for ".concat(connector.name || connector.uuid, " - using parent-based calculation (legacy mode)"));
+
+      // Get world position of the connector
+      var connectorPos = this.sceneManager.getWorldPosition(connector);
+
+      // For the parent, use the center of its bounding box if available
+      var parentPos;
+      var parentBBox = this.sceneManager.getBoundingBox(connector.parent);
+      if (parentBBox) {
+        // Calculate the center of the parent's bounding box
+        parentPos = new Vector3((parentBBox.min.x + parentBBox.max.x) / 2, (parentBBox.min.y + parentBBox.max.y) / 2, (parentBBox.min.z + parentBBox.max.z) / 2);
+      } else {
+        // Fall back to parent's position if bounding box is not available
+        parentPos = this.sceneManager.getWorldPosition(connector.parent);
+      }
+
+      // Calculate the direction vector from parent to connector
+      var direction = new Vector3(connectorPos.x - parentPos.x, connectorPos.y - parentPos.y, connectorPos.z - parentPos.z).normalize();
+
+      // Enforce orthogonality by aligning with the dominant axis
+      var absX = Math.abs(direction.x);
+      var absY = Math.abs(direction.y);
+      var absZ = Math.abs(direction.z);
+      if (absX >= absY && absX >= absZ) {
+        // X is dominant
+        direction.y = 0;
+        direction.z = 0;
+        direction.x = Math.sign(direction.x);
+      } else if (absY >= absX && absY >= absZ) {
+        // Y is dominant
+        direction.x = 0;
+        direction.z = 0;
+        direction.y = Math.sign(direction.y);
+      } else {
+        // Z is dominant
+        direction.x = 0;
+        direction.y = 0;
+        direction.z = Math.sign(direction.z);
+      }
+      return direction;
+    }
+
+    /**
+     * Create a virtual segment for a connector
+     * @param {Object} connector - Connector object
+     * @param {Vector3} connectorPos - World position of the connector
+     * @returns {Object|null} Virtual segment info or null if no parent
+     */
+  }, {
+    key: "createVirtualSegment",
+    value: function createVirtualSegment(connector, connectorPos) {
+      var direction = this.getConnectorDirection(connector);
+      if (!direction) {
+        return null;
+      }
+
+      // Create a virtual segment starting from the connector position
+      // and extending in the direction vector for MIN_SEGMENT_LENGTH
+      var endPos = new Vector3(connectorPos.x + direction.x * this.MIN_SEGMENT_LENGTH, connectorPos.y + direction.y * this.MIN_SEGMENT_LENGTH, connectorPos.z + direction.z * this.MIN_SEGMENT_LENGTH);
+
+      // Convert to voxel keys
+      var startKey = this.gridSystem.voxelKey(connectorPos);
+      var endKey = this.gridSystem.voxelKey(endPos);
+      return {
+        startPos: connectorPos,
+        endPos: endPos,
+        direction: direction,
+        startKey: startKey,
+        endKey: endKey
+      };
+    }
+
+    /**
+     * Process all connectors in the scene and mark their virtual segments as occupied
+     * @param {Object} sceneRoot - Root scene object
+     * @param {Set<string>} pathOccupied - Set of occupied voxel keys
+     * @param {string} excludeUUID1 - UUID of first object to exclude
+     * @param {string} excludeUUID2 - UUID of second object to exclude
+     */
+  }, {
+    key: "processConnectors",
+    value: function processConnectors(sceneRoot, pathOccupied, excludeUUID1, excludeUUID2) {
+      this._processConnectorsRecursive(sceneRoot, pathOccupied, excludeUUID1, excludeUUID2);
+    }
+
+    /**
+     * Recursive helper for processConnectors
+     * @private
+     * @param {Object} object - Current object to process
+     * @param {Set<string>} pathOccupied - Set of occupied voxel keys
+     * @param {string} excludeUUID1 - UUID of first object to exclude
+     * @param {string} excludeUUID2 - UUID of second object to exclude
+     */
+  }, {
+    key: "_processConnectorsRecursive",
+    value: function _processConnectorsRecursive(object, pathOccupied, excludeUUID1, excludeUUID2) {
+      // Process current object if it's a mesh
+      if (object.type === 'Mesh') {
+        // Skip the excluded objects
+        if (object.uuid === excludeUUID1 || object.uuid === excludeUUID2) {
+          return;
+        }
+        var connectorPos = this.sceneManager.getWorldPosition(object);
+        var segment = this.createVirtualSegment(object, connectorPos);
+        if (segment) {
+          this._markVirtualSegmentAsOccupied(segment, connectorPos, pathOccupied);
+        }
+      }
+
+      // Process children recursively
+      if (object.children) {
+        var _iterator = _createForOfIteratorHelper(object.children),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var child = _step.value;
+            this._processConnectorsRecursive(child, pathOccupied, excludeUUID1, excludeUUID2);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    }
+
+    /**
+     * Mark voxels in a virtual segment as occupied
+     * @private
+     * @param {Object} segment - Virtual segment info
+     * @param {Vector3} connectorPos - Position of the connector
+     * @param {Set<string>} pathOccupied - Set of occupied voxel keys
+     */
+  }, {
+    key: "_markVirtualSegmentAsOccupied",
+    value: function _markVirtualSegmentAsOccupied(segment, connectorPos, pathOccupied) {
+      var direction = segment.direction;
+      var distance = this.gridSystem.worldToVoxelDistance(this.MIN_SEGMENT_LENGTH + this.gridSystem.safetyMargin * 2);
+      for (var i = 0; i <= distance; i++) {
+        var x = Math.round(connectorPos.x / this.gridSystem.gridSize + direction.x * i);
+        var y = Math.round(connectorPos.y / this.gridSystem.gridSize + direction.y * i);
+        var z = Math.round(connectorPos.z / this.gridSystem.gridSize + direction.z * i);
+        var key = "".concat(x, ",").concat(y, ",").concat(z);
+        pathOccupied.add(key);
+      }
+    }
+
+    /**
+     * Cluster connections by shared objects
+     * @param {Array<Object>} connections - Array of connections between objects
+     * @returns {Array<Object>} Array of clusters
+     */
+  }, {
+    key: "clusterConnections",
+    value: function clusterConnections(connections) {
+      var _this = this;
+      var clusters = new Map(); // Map of object UUID to its cluster
+      var clusterMap = new Map(); // Map of cluster ID to set of object UUIDs
+      var nextClusterId = 0;
+
+      // First pass: create initial clusters for each object
+      connections.forEach(function (conn) {
+        var from = conn.from,
+          to = conn.to;
+
+        // If neither object is in a cluster, create new cluster
+        if (!clusters.has(from) && !clusters.has(to)) {
+          var clusterId = nextClusterId++;
+          clusters.set(from, clusterId);
+          clusters.set(to, clusterId);
+          clusterMap.set(clusterId, new Set([from, to]));
+        }
+        // If only 'from' is in a cluster, add 'to' to that cluster
+        else if (clusters.has(from) && !clusters.has(to)) {
+          var _clusterId = clusters.get(from);
+          clusters.set(to, _clusterId);
+          clusterMap.get(_clusterId).add(to);
+        }
+        // If only 'to' is in a cluster, add 'from' to that cluster
+        else if (!clusters.has(from) && clusters.has(to)) {
+          var _clusterId2 = clusters.get(to);
+          clusters.set(from, _clusterId2);
+          clusterMap.get(_clusterId2).add(from);
+        }
+        // If both are in different clusters, merge the clusters
+        else if (clusters.has(from) && clusters.has(to)) {
+          var fromCluster = clusters.get(from);
+          var toCluster = clusters.get(to);
+          if (fromCluster !== toCluster) {
+            // Merge toCluster into fromCluster
+            var toClusterObjects = clusterMap.get(toCluster);
+            toClusterObjects.forEach(function (objId) {
+              clusters.set(objId, fromCluster);
+              clusterMap.get(fromCluster).add(objId);
+            });
+            clusterMap.delete(toCluster);
+          }
+        }
+      });
+
+      // Convert clusters to array format
+      var clustersArray = Array.from(clusterMap.entries()).map(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          clusterId = _ref2[0],
+          objects = _ref2[1];
+        return {
+          clusterId: clusterId,
+          objects: Array.from(objects)
+        };
+      });
+
+      // Filter out clusters containing objects with "GATEWAY" in their UUID
+      var filteredClusters = clustersArray.filter(function (cluster) {
+        return !cluster.objects.some(function (uuid) {
+          return uuid.includes('GATEWAY');
+        });
+      });
+
+      // Enrich clusters with point and direction information
+      filteredClusters.forEach(function (cluster) {
+        cluster.objectPoints = cluster.objects.map(function (uuid) {
+          var object = _this.sceneManager.findObjectByUUID(uuid);
+          if (object && object.userData.worldBoundingBox) {
+            var center = _this.sceneManager.getWorldPosition(object);
+            return {
+              uuid: uuid,
+              point: center,
+              direction: object.userData.direction ? _construct(Vector3, _toConsumableArray(object.userData.direction)) : null
+            };
+          }
+          return null;
+        }).filter(function (point) {
+          return point !== null;
+        });
+
+        // Add displaced points to each cluster
+        cluster.displacedPoints = cluster.objectPoints.map(function (objPoint) {
+          var displacedPoint = objPoint.direction ? objPoint.point.clone().add(objPoint.direction.multiplyScalar(0.5)) : objPoint.point.clone();
+          return {
+            uuid: objPoint.uuid,
+            originalPoint: objPoint.point,
+            displacedPoint: displacedPoint,
+            direction: objPoint.direction
+          };
+        });
+      });
+      return filteredClusters;
+    }
+  }]);
+}();
+
+/**
+ * Manages path-related operations for the pathfinding system
+ * @class PathManager
+ */
+var PathManager = /*#__PURE__*/function () {
+  /**
+   * Create a new PathManager instance
+   * @param {SceneManager} sceneManager - Instance of SceneManager for scene operations
+   * @param {GridSystem} gridSystem - Instance of GridSystem for grid operations
+   * @param {ConnectorManager} connectorManager - Instance of ConnectorManager for connector operations
+   * @param {number} minSegmentLength - Minimum length for straight pipe segments in world units
+   * @param {number} astarTimeout - Timeout for A* pathfinding in milliseconds
+   */
+  function PathManager(sceneManager, gridSystem, connectorManager, minSegmentLength, astarTimeout) {
+    _classCallCheck(this, PathManager);
+    this.sceneManager = sceneManager;
+    this.gridSystem = gridSystem;
+    this.connectorManager = connectorManager;
+    this.MIN_SEGMENT_LENGTH = minSegmentLength;
+    this.ASTAR_TIMEOUT = astarTimeout;
+  }
+
+  /**
+   * A* pathfinding algorithm
+   * @private
+   * @param {string} start - Start voxel key
+   * @param {string} goal - Goal voxel key
+   * @param {Set<string>} occupied - Set of occupied voxel keys
+   * @returns {string[]|null} Path as array of voxel keys or null if no path found
+   */
+  return _createClass(PathManager, [{
+    key: "astar",
+    value: function astar(start, goal, occupied) {
+      var open = new Set([start]);
+      var cameFrom = {};
+      var gScore = _defineProperty({}, start, 0);
+      var fScore = _defineProperty({}, start, this.gridSystem.manhattan(start, goal));
+
+      // Add timeout to prevent infinite loops
+      var startTime = Date.now();
+      while (open.size > 0) {
+        // Check for timeout
+        if (Date.now() - startTime > this.ASTAR_TIMEOUT) {
+          console.log('[Warning] Pathfinding timed out');
+          return null;
+        }
+
+        // Get node in open with lowest fScore
+        var current = null;
+        var minF = Infinity;
+        var _iterator = _createForOfIteratorHelper(open),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var node = _step.value;
+            if (fScore[node] < minF) {
+              minF = fScore[node];
+              current = node;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        if (current === goal) {
+          // Reconstruct path
+          var path = [current];
+          while (cameFrom[current]) {
+            current = cameFrom[current];
+            path.unshift(current);
+          }
+          return path;
+        }
+        open.delete(current);
+        var _iterator2 = _createForOfIteratorHelper(this.gridSystem.getNeighbors(current)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _gScore$neighbor;
+            var neighbor = _step2.value;
+            if (occupied.has(neighbor)) continue;
+            var tentativeG = gScore[current] + 1;
+            if (tentativeG < ((_gScore$neighbor = gScore[neighbor]) !== null && _gScore$neighbor !== void 0 ? _gScore$neighbor : Infinity)) {
+              cameFrom[neighbor] = current;
+              gScore[neighbor] = tentativeG;
+              fScore[neighbor] = tentativeG + this.gridSystem.manhattan(neighbor, goal);
+              open.add(neighbor);
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Find a path respecting virtual segments
+     * @private
+     * @param {string} startKey - Start voxel key
+     * @param {string} endKey - End voxel key
+     * @param {Set<string>} occupied - Set of occupied voxel keys
+     * @param {Object} startSegment - Virtual segment for start connector (optional)
+     * @param {Object} endSegment - Virtual segment for end connector (optional)
+     * @returns {string[]|null} Path as array of voxel keys or null if no path found
+     */
+  }, {
+    key: "findPathWithVirtualSegments",
+    value: function findPathWithVirtualSegments(startKey, endKey, occupied, startSegment, endSegment) {
+      // If we have virtual segments, we need to ensure the path starts and ends with them
+      var actualStartKey = startKey;
+      var actualEndKey = endKey;
+
+      // Create a copy of occupied set to avoid modifying the original
+      var pathOccupied = new Set(occupied);
+
+      // If we have a start segment, use its end as the actual start for pathfinding
+      // and mark the segment as occupied
+      if (startSegment) {
+        actualStartKey = startSegment.endKey;
+        // Mark all voxels in the start segment as occupied
+        var startPos = startSegment.startPos;
+        var direction = startSegment.direction;
+        var distance = this.gridSystem.worldToVoxelDistance(this.MIN_SEGMENT_LENGTH);
+        // Note: we go up to distance-1 to exclude the connecting end point
+        for (var i = 0; i < distance; i++) {
+          var x = Math.round(startPos.x / this.gridSystem.gridSize + direction.x * i);
+          var y = Math.round(startPos.y / this.gridSystem.gridSize + direction.y * i);
+          var z = Math.round(startPos.z / this.gridSystem.gridSize + direction.z * i);
+          var key = "".concat(x, ",").concat(y, ",").concat(z);
+          pathOccupied.add(key);
+        }
+      }
+
+      // If we have an end segment, use its end as the actual end for pathfinding
+      // and mark the segment as occupied
+      if (endSegment) {
+        actualEndKey = endSegment.endKey;
+        // Mark all voxels in the end segment as occupied
+        var endPos = endSegment.startPos;
+        var _direction = endSegment.direction;
+        var _distance = this.gridSystem.worldToVoxelDistance(this.MIN_SEGMENT_LENGTH);
+        // Note: we go up to distance-1 to exclude the connecting end point
+        for (var _i = 0; _i < _distance; _i++) {
+          var _x = Math.round(endPos.x / this.gridSystem.gridSize + _direction.x * _i);
+          var _y = Math.round(endPos.y / this.gridSystem.gridSize + _direction.y * _i);
+          var _z = Math.round(endPos.z / this.gridSystem.gridSize + _direction.z * _i);
+          var _key = "".concat(_x, ",").concat(_y, ",").concat(_z);
+          pathOccupied.add(_key);
+        }
+      }
+
+      // Find a path between the actual start and end
+      var middlePath = this.astar(actualStartKey, actualEndKey, pathOccupied);
+      if (!middlePath) {
+        return null;
+      }
+
+      // Construct the full path
+      var fullPath = [];
+
+      // Add the start segment if we have one
+      if (startSegment) {
+        fullPath.push(startSegment.startKey);
+      }
+
+      // Add the middle path
+      fullPath = fullPath.concat(middlePath);
+
+      // Add the end segment if we have one
+      if (endSegment) {
+        fullPath.push(endSegment.startKey);
+      }
+      return fullPath;
+    }
+
+    /**
+     * Mark all mesh objects' voxels as occupied in the scene
+     * @private
+     * @param {Object} sceneRoot - Root scene object
+     * @returns {Object} Object containing occupied sets and maps
+     */
+  }, {
+    key: "markAllMeshesAsOccupiedVoxels",
+    value: function markAllMeshesAsOccupiedVoxels(sceneRoot) {
+      var _this = this;
+      var occupied = new Set();
+      var occupiedByUUID = new Map();
+      var _processObject = function processObject(object) {
+        // Skip non-mesh objects
+        if (object.type !== 'Mesh') return;
+
+        // Get object's bounding box
+        var bbox = _this.sceneManager.getBoundingBox(object);
+        if (!bbox) return;
+
+        // Get all voxels in the bounding box plus safety margin
+        var voxels = _this.gridSystem.getVoxelsInBoundingBox(bbox);
+
+        // Create a set for this object's occupied voxels
+        var objectOccupied = new Set(voxels);
+
+        // Add all voxels to the global occupied set
+        var _iterator3 = _createForOfIteratorHelper(voxels),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var key = _step3.value;
+            occupied.add(key);
+          }
+
+          // Store the object's occupied voxels in the map
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+        occupiedByUUID.set(object.uuid, objectOccupied);
+
+        // Process children recursively
+        if (object.children) {
+          var _iterator4 = _createForOfIteratorHelper(object.children),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var child = _step4.value;
+              _processObject(child);
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      };
+
+      // Process all objects in the scene's children array
+      if (sceneRoot.children) {
+        var _iterator5 = _createForOfIteratorHelper(sceneRoot.children),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var object = _step5.value;
+            _processObject(object);
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }
+      return {
+        occupied: occupied,
+        occupiedByUUID: occupiedByUUID
+      };
+    }
+
+    /**
+     * Process a single connection and find its path
+     * @private
+     * @param {Object} connection - Connection object
+     * @param {Set<string>} occupied - Set of occupied voxel keys
+     * @param {Map<string, Set<string>>} occupiedByUUID - Map of occupied voxels by UUID
+     * @returns {Object|null} Path result object or null if connection is invalid
+     */
+  }, {
+    key: "processConnection",
+    value: function processConnection(connection, occupied, occupiedByUUID) {
+      var _this2 = this;
+      var fromObject = this.sceneManager.findObjectByUUID(connection.from);
+      var toObject = this.sceneManager.findObjectByUUID(connection.to);
+      if (!fromObject || !toObject) {
+        console.log("[ERROR] Could not find objects for connection ".concat(connection.from, " - ").concat(connection.to));
+        return null;
+      }
+
+      // Verify that both objects are meshes
+      if (fromObject.type !== 'Mesh' || toObject.type !== 'Mesh') {
+        console.log("[ERROR] Connection endpoints must be meshes: ".concat(fromObject.type, " - ").concat(toObject.type));
+        return null;
+      }
+
+      // Store the parent for each object to access later
+      fromObject.parent = this.sceneManager.findParentObject(fromObject);
+      toObject.parent = this.sceneManager.findParentObject(toObject);
+
+      // Get world positions for both objects
+      var worldPos1 = this.sceneManager.getWorldPosition(fromObject);
+      var worldPos2 = this.sceneManager.getWorldPosition(toObject);
+
+      // Create virtual segments for both connectors
+      var startSegment = this.connectorManager.createVirtualSegment(fromObject, worldPos1);
+      var endSegment = this.connectorManager.createVirtualSegment(toObject, worldPos2);
+
+      // Create a copy of occupied set for this path
+      var pathOccupied = new Set(occupied);
+
+      // Debug copy 1: Initial state after copying from global occupied
+      var debugOccupiedInitial = Array.from(pathOccupied).map(function (key) {
+        return _this2.gridSystem.voxelToVec3(key);
+      });
+
+      // Get bounding boxes for the two objects
+      var fromBbox = this.sceneManager.getBoundingBox(fromObject);
+      var toBbox = this.sceneManager.getBoundingBox(toObject);
+      if (!fromBbox || !toBbox) return null;
+
+      // Clear voxels in bounding boxes only for objects that do NOT have virtual segments
+      if (!startSegment) {
+        var voxels = this.gridSystem.getVoxelsInBoundingBox(fromBbox);
+        var _iterator6 = _createForOfIteratorHelper(voxels),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var key = _step6.value;
+            pathOccupied.delete(key);
+          }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+      }
+      if (!endSegment) {
+        var _voxels = this.gridSystem.getVoxelsInBoundingBox(toBbox);
+        var _iterator7 = _createForOfIteratorHelper(_voxels),
+          _step7;
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var _key2 = _step7.value;
+            pathOccupied.delete(_key2);
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+      }
+
+      // Also clear the voxels for the virtual segments if they exist
+      if (startSegment) {
+        var direction = startSegment.direction;
+        var distance = this.gridSystem.worldToVoxelDistance(this.MIN_SEGMENT_LENGTH + this.gridSystem.safetyMargin * 2);
+        for (var i = 0; i <= distance; i++) {
+          var x = Math.round(worldPos1.x / this.gridSystem.gridSize + direction.x * i);
+          var y = Math.round(worldPos1.y / this.gridSystem.gridSize + direction.y * i);
+          var z = Math.round(worldPos1.z / this.gridSystem.gridSize + direction.z * i);
+          pathOccupied.delete("".concat(x, ",").concat(y, ",").concat(z));
+        }
+      }
+      if (endSegment) {
+        var _direction2 = endSegment.direction;
+        var _distance2 = this.gridSystem.worldToVoxelDistance(this.MIN_SEGMENT_LENGTH + this.gridSystem.safetyMargin * 2);
+        for (var _i2 = 0; _i2 <= _distance2; _i2++) {
+          var _x2 = Math.round(worldPos2.x / this.gridSystem.gridSize + _direction2.x * _i2);
+          var _y2 = Math.round(worldPos2.y / this.gridSystem.gridSize + _direction2.y * _i2);
+          var _z2 = Math.round(worldPos2.z / this.gridSystem.gridSize + _direction2.z * _i2);
+          pathOccupied.delete("".concat(_x2, ",").concat(_y2, ",").concat(_z2));
+        }
+      }
+
+      // Process all other connectors in the scene
+      this.connectorManager.processConnectors(this.sceneManager.getRoot(), pathOccupied, fromObject.uuid, toObject.uuid);
+
+      // Debug copy 3: After clearing virtual segments and adding back previous paths
+      var debugOccupiedAfterSegments = Array.from(pathOccupied).map(function (key) {
+        return _this2.gridSystem.voxelToVec3(key);
+      });
+
+      // Get start and end voxel keys
+      var startKey = this.gridSystem.voxelKey(worldPos1);
+      var endKey = this.gridSystem.voxelKey(worldPos2);
+
+      // Find a path with virtual segments
+      var pathKeys = this.findPathWithVirtualSegments(startKey, endKey, pathOccupied, startSegment, endSegment);
+      var occupiedVoxels = Array.from(pathOccupied).map(function (key) {
+        return _this2.gridSystem.voxelToVec3(key);
+      });
+      if (pathKeys) {
+        var path = pathKeys.map(function (key) {
+          return _this2.gridSystem.voxelToVec3(key);
+        });
+
+        // Create a set for this path's occupied voxels
+        var _pathOccupied = new Set();
+
+        // Mark path points as occupied for next routes
+        var _iterator8 = _createForOfIteratorHelper(path),
+          _step8;
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var p = _step8.value;
+            var _key3 = this.gridSystem.voxelKey(p);
+            occupied.add(_key3);
+            _pathOccupied.add(_key3);
+          }
+
+          // Store the path's occupied voxels in the map with a special key
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+        var pathKey = "path_".concat(connection.from, "_").concat(connection.to);
+        occupiedByUUID.set(pathKey, _pathOccupied);
+        return {
+          from: connection.from,
+          to: connection.to,
+          path: path,
+          occupied: occupiedVoxels,
+          debug: {
+            initial: debugOccupiedInitial,
+            afterSegments: debugOccupiedAfterSegments
+          },
+          occupiedByUUID: occupiedByUUID // Include the map in the result
+        };
+      } else {
+        console.log("[ERROR] No orthogonal path found for ".concat(connection.from, "-").concat(connection.to));
+        return {
+          from: connection.from,
+          to: connection.to,
+          path: null,
+          start: worldPos1,
+          end: worldPos2,
+          occupied: occupiedVoxels,
+          debug: {
+            initial: debugOccupiedInitial,
+            afterSegments: debugOccupiedAfterSegments
+          },
+          occupiedByUUID: occupiedByUUID // Include the map in the result
+        };
+      }
+    }
+
+    /**
+     * Find paths for all connections
+     * @param {Array<Object>} connections - Array of connections to process
+     * @returns {Array<Object>} Array of path results
+     */
+  }, {
+    key: "findPaths",
+    value: function findPaths(connections) {
+      console.log('[DEBUG] Starting findPaths()');
+
+      // Validate scene structure
+      if (!this.sceneManager.getRoot()) {
+        console.log('[ERROR] Invalid scene structure: missing scene root');
+        return [];
+      }
+
+      // Process all objects in the scene
+      var _this$markAllMeshesAs = this.markAllMeshesAsOccupiedVoxels(this.sceneManager.getRoot()),
+        occupied = _this$markAllMeshesAs.occupied,
+        occupiedByUUID = _this$markAllMeshesAs.occupiedByUUID;
+      var paths = [];
+
+      // For each connection in the config, find a path
+      var _iterator9 = _createForOfIteratorHelper(connections),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var connection = _step9.value;
+          var result = this.processConnection(connection, occupied, occupiedByUUID);
+          if (result) {
+            paths.push(result);
+          }
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+      return paths;
+    }
+  }]);
+}();
+
+/**
+ * Manages tree path calculations and Minimum Spanning Tree (MST) operations
+ * @class TreePathManager
+ */
+var TreePathManager = /*#__PURE__*/function () {
+  function TreePathManager() {
+    var gridSystem = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var sceneManager = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    _classCallCheck(this, TreePathManager);
+    this.gridSystem = gridSystem;
+    this.sceneManager = sceneManager;
+  }
+
+  /**
+   * Calculate distance between two points
+   * @param {Vector3} p1 - First point
+   * @param {Vector3} p2 - Second point
+   * @returns {number} Distance between points
+   */
+  return _createClass(TreePathManager, [{
+    key: "distance",
+    value: function distance(p1, p2) {
+      var dx = p2.x - p1.x;
+      var dy = p2.y - p1.y;
+      var dz = p2.z - p1.z;
+      return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    /**
+     * Find Minimum Spanning Tree using Prim's algorithm
+     * @param {Array<Vector3>} points - Array of points to connect
+     * @returns {Array<Array<number>>} Array of edges in the MST
+     */
+  }, {
+    key: "findMST",
+    value: function findMST(points) {
+      var n = points.length;
+      var mst = [];
+      var visited = new Set();
+
+      // Start with the first point
+      visited.add(0);
+      while (visited.size < n) {
+        var minDist = Infinity;
+        var minEdge = null;
+
+        // Find the minimum edge from visited to unvisited
+        var _iterator = _createForOfIteratorHelper(visited),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var i = _step.value;
+            for (var j = 0; j < n; j++) {
+              if (!visited.has(j)) {
+                var dist = this.distance(points[i], points[j]);
+                if (dist < minDist) {
+                  minDist = dist;
+                  minEdge = [i, j];
+                }
+              }
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        if (minEdge) {
+          mst.push(minEdge);
+          visited.add(minEdge[1]);
+        } else {
+          break; // Break if we can't find any more edges
+        }
+      }
+      return mst;
+    }
+
+    /**
+     * Find the nearest free voxel to a given position
+     * @param {Vector3} position - Position to find free voxel near
+     * @param {number} maxSearchRadius - Maximum search radius in voxel units
+     * @returns {Vector3|null} Nearest free position or null if none found
+     */
+  }, {
+    key: "findNearestFreeVoxel",
+    value: function findNearestFreeVoxel(position) {
+      var maxSearchRadius = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
+      if (!this.gridSystem || !this.sceneManager) {
+        return position; // Return original position if systems not available
+      }
+      var originalVoxelKey = this.gridSystem.voxelKey(position);
+
+      // Check if original position is free
+      if (!this.sceneManager.isVoxelOccupiedByMesh(originalVoxelKey, this.gridSystem.gridSize)) {
+        return position;
+      }
+
+      // Search in expanding rings around the position
+      for (var radius = 1; radius <= maxSearchRadius; radius++) {
+        var _originalVoxelKey$spl = originalVoxelKey.split(',').map(Number),
+          _originalVoxelKey$spl2 = _slicedToArray(_originalVoxelKey$spl, 3),
+          x = _originalVoxelKey$spl2[0],
+          y = _originalVoxelKey$spl2[1],
+          z = _originalVoxelKey$spl2[2];
+
+        // Generate all voxels at this radius
+        var candidates = [];
+
+        // Generate all combinations of offsets at this radius
+        for (var dx = -radius; dx <= radius; dx++) {
+          for (var dy = -radius; dy <= radius; dy++) {
+            for (var dz = -radius; dz <= radius; dz++) {
+              // Only consider voxels exactly at this radius
+              if (Math.abs(dx) + Math.abs(dy) + Math.abs(dz) === radius) {
+                candidates.push([x + dx, y + dy, z + dz]);
+              }
+            }
+          }
+        }
+
+        // Check each candidate
+        for (var _i = 0, _candidates = candidates; _i < _candidates.length; _i++) {
+          var _candidates$_i = _slicedToArray(_candidates[_i], 3),
+            cx = _candidates$_i[0],
+            cy = _candidates$_i[1],
+            cz = _candidates$_i[2];
+          var candidateKey = "".concat(cx, ",").concat(cy, ",").concat(cz);
+          if (!this.sceneManager.isVoxelOccupiedByMesh(candidateKey, this.gridSystem.gridSize)) {
+            return this.gridSystem.voxelToVec3(candidateKey);
+          }
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Find joint point 
+     * @param {Array<Vector3>} points - Array of points to connect
+     * @returns {Vector3|null} Joint point or null if not possible
+     */
+  }, {
+    key: "findJointPoint",
+    value: function findJointPoint(points) {
+      if (points.length <= 2) {
+        return null;
+      }
+
+      // Find MST first
+      var mst = this.findMST(points);
+      if (mst.length === 0) {
+        return null;
+      }
+
+      // Find the best edge in MST
+      var bestEdge = null;
+      var maxScore = -1;
+      mst.forEach(function (_ref, edgeIndex) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          i = _ref2[0],
+          j = _ref2[1];
+        var pointA = points[i];
+        var pointB = points[j];
+
+        // Calculate edge components
+        var dx = Math.abs(pointB.x - pointA.x);
+        var dy = Math.abs(pointB.y - pointA.y);
+        var dz = Math.abs(pointB.z - pointA.z);
+
+        // Calculate total length
+        var totalLength = dx + dy + dz;
+        if (totalLength > 0) {
+          // Calculate score
+          // Higher score = more orthogonal (closer to being axis-aligned) relative to the total length of the edge
+          var maxComponent = Math.max(dx, dy, dz);
+          var score = maxComponent / totalLength / totalLength;
+
+          // Check if this edge has a better orthogonality score
+          if (score > maxScore) {
+            maxScore = score;
+            bestEdge = [pointA, pointB];
+          }
+        }
+      });
+      if (!bestEdge) {
+        return null;
+      }
+
+      // Place joint point at the midpoint of the most orthogonal edge
+      var jointPoint = new Vector3((bestEdge[0].x + bestEdge[1].x) * 0.5, (bestEdge[0].y + bestEdge[1].y) * 0.5, (bestEdge[0].z + bestEdge[1].z) * 0.5);
+
+      // Snap to 0.5 grid
+      var snapToGrid = function snapToGrid(value) {
+        return Math.round(value * 2) / 2;
+      };
+      jointPoint.x = snapToGrid(jointPoint.x);
+      jointPoint.y = snapToGrid(jointPoint.y);
+      jointPoint.z = snapToGrid(jointPoint.z);
+
+      // Check if the joint point is in an occupied voxel and move it if necessary
+      var freeJointPoint = this.findNearestFreeVoxel(jointPoint);
+      if (freeJointPoint) {
+        return freeJointPoint;
+      } else {
+        return jointPoint; // Return original if no free position found
+      }
+    }
+  }]);
+}();
+
+/**
+ * A 3D pathfinding system that finds orthogonal paths between objects
+ * @class Pathfinder
+ */
+var Pathfinder = /*#__PURE__*/function () {
+  /**
+   * Create a new Pathfinding instance
+   * @param {Object} [config] - Optional configuration object
+   * @param {Object} [config.grid] - Grid system configuration
+   * @param {number} [config.grid.size=0.5] - Size of each grid cell in world units
+   * @param {number} [config.grid.safetyMargin=0] - Safety margin around obstacles in world units
+   * @param {number} [config.grid.minSegmentLength=0.5] - Minimum length for straight pipe segments in world units
+   * @param {number} [config.grid.timeout=1000] - Timeout for A* pathfinding in milliseconds
+   */
+  function Pathfinder() {
+    var _gridConfig$size, _gridConfig$safetyMar, _gridConfig$minSegmen, _gridConfig$timeout;
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, Pathfinder);
+    this.config = config;
+
+    // Grid system settings with defaults
+    var gridConfig = config.grid || {};
+    this.gridSystem = new GridSystem((_gridConfig$size = gridConfig.size) !== null && _gridConfig$size !== void 0 ? _gridConfig$size : 0.5, (_gridConfig$safetyMar = gridConfig.safetyMargin) !== null && _gridConfig$safetyMar !== void 0 ? _gridConfig$safetyMar : 0);
+    this.MIN_SEGMENT_LENGTH = (_gridConfig$minSegmen = gridConfig.minSegmentLength) !== null && _gridConfig$minSegmen !== void 0 ? _gridConfig$minSegmen : 0.5;
+    this.ASTAR_TIMEOUT = (_gridConfig$timeout = gridConfig.timeout) !== null && _gridConfig$timeout !== void 0 ? _gridConfig$timeout : 1000;
+
+    // Initialize connector manager
+    this.connectorManager = new ConnectorManager({
+      grid: gridConfig
+    },
+    // Only pass grid config
+    this.MIN_SEGMENT_LENGTH, null,
+    // sceneManager will be set in findPaths
+    this.gridSystem);
+
+    // Initialize path manager
+    this.pathManager = new PathManager(null,
+    // sceneManager will be set in findPaths
+    this.gridSystem, this.connectorManager, this.MIN_SEGMENT_LENGTH, this.ASTAR_TIMEOUT);
+
+    // Initialize tree path manager
+    this.treePathManager = new TreePathManager(this.gridSystem, null);
+  }
+
+  /**
+   * Find paths for all connections
+   * @param {Object} scene - The scene configuration
+   * @param {Object} scene.object - The scene object containing children
+   * @param {string} scene.object.uuid - Unique identifier for the scene object
+   * @param {string} scene.object.type - Type of the scene object (typically "Scene")
+   * @param {Array<Object>} scene.object.children - Array of scene objects
+   * @param {string} scene.object.children[].uuid - Unique identifier for the child object
+   * @param {string} scene.object.children[].type - Type of the child object (must be "Mesh")
+   * @param {Object} scene.object.children[].userData - User data for the child object
+   * @param {Object} scene.object.children[].userData.worldBoundingBox - Bounding box data
+   * @param {Array<number>} scene.object.children[].userData.worldBoundingBox.min - Minimum coordinates [x,y,z]
+   * @param {Array<number>} scene.object.children[].userData.worldBoundingBox.max - Maximum coordinates [x,y,z]
+   * @param {Array<number>} [scene.object.children[].userData.direction] - Optional direction vector [x,y,z]
+   * @param {Array<Object>} connections - Array of connections between objects
+   * @param {string} connections[].from - UUID of the source object
+   * @param {string} connections[].to - UUID of the target object
+   * @returns {Object} Result object containing paths, rewired connections, and gateways
+   * @property {Array<Object>} paths - Array of path results
+   * @property {string} paths[].from - Source object UUID
+   * @property {string} paths[].to - Target object UUID
+   * @property {Array<Vector3>|null} paths[].path - Array of path points or null if no path found
+   * @property {Array<Vector3>} [paths[].occupied] - Array of occupied points
+   * @property {Vector3} [paths[].start] - Start position (if no path found)
+   * @property {Vector3} [paths[].end] - End position (if no path found)
+   * @property {Array<Object>} rewiredConnections - Array of connections after gateway optimization
+   * @property {string} rewiredConnections[].from - Source object UUID
+   * @property {string} rewiredConnections[].to - Target object UUID
+   * @property {Array<Object>} gateways - Array of gateway information
+   * @property {string} gateways[].clusterId - ID of the cluster this gateway belongs to
+   * @property {number} gateways[].id - Unique identifier for the gateway
+   * @property {Vector3} gateways[].position - Position of the gateway in 3D space
+   * @property {Object} gateways[].connections - Connection mapping information
+   * @property {Array<Object>} gateways[].connections.removed - Array of original connections that were removed
+   * @property {string} gateways[].connections.removed[].from - Source object UUID
+   * @property {string} gateways[].connections.removed[].to - Target object UUID
+   * @property {Array<Object>} gateways[].connections.added - Array of new connections that were added
+   * @property {string} gateways[].connections.added[].from - Source object UUID
+   * @property {string} gateways[].connections.added[].to - Target object UUID
+   */
+  return _createClass(Pathfinder, [{
+    key: "findPaths",
+    value: function findPaths(scene, connections) {
+      var _this = this;
+      // Create scene manager with the provided scene
+      var sceneManager = new SceneManager(scene);
+
+      // Update scene manager references
+      this.connectorManager.sceneManager = sceneManager;
+      this.pathManager.sceneManager = sceneManager;
+      this.treePathManager.sceneManager = sceneManager;
+
+      // Cluster the connections
+      var clusters = this.connectorManager.clusterConnections(connections);
+
+      // Filter clusters to only include those with more than 2 objects
+      var filteredClusters = clusters.filter(function (cluster) {
+        return cluster.objects.length > 2;
+      });
+
+      // Calculate joint points for each cluster
+      filteredClusters.forEach(function (cluster, index) {
+        var points = cluster.displacedPoints.map(function (p) {
+          return p.displacedPoint;
+        });
+        cluster.jointPoint = _this.treePathManager.findJointPoint(points);
+      });
+      var gatewayMap = new Map();
+      filteredClusters.forEach(function (cluster) {
+        if (cluster.jointPoint) {
+          // Generate a shorter unique ID (8 characters)
+          var uuid = crypto.randomUUID().replace(/-/g, '').substring(0, 8);
+          var gatewayId = "Gateway-".concat(uuid);
+          gatewayMap.set(cluster.clusterId, gatewayId);
+        }
+      });
+
+      // Create virtual gateway objects in the scene
+      filteredClusters.forEach(function (cluster) {
+        if (cluster.jointPoint) {
+          var gatewayId = gatewayMap.get(cluster.clusterId);
+          var gatewayObject = {
+            uuid: gatewayId,
+            type: 'Mesh',
+            userData: {
+              worldBoundingBox: {
+                min: [cluster.jointPoint.x - 0.25, cluster.jointPoint.y - 0.25, cluster.jointPoint.z - 0.25],
+                max: [cluster.jointPoint.x + 0.25, cluster.jointPoint.y + 0.25, cluster.jointPoint.z + 0.25]
+              }
+            }
+          };
+          scene.object.children.push(gatewayObject);
+        }
+      });
+
+      // Rewire connections through gateways
+      var rewiredConnections = [];
+      var connectionSet = new Set(); // Track unique connections
+      var gatewayConnectionMappings = new Map(); // Track which original connections are replaced by which gateway connections
+
+      // Find direct connections (not part of clusters with >2 objects)
+      var directConnections = connections.filter(function (conn) {
+        var fromCluster = clusters.find(function (cluster) {
+          return cluster.objects.includes(conn.from);
+        });
+        var toCluster = clusters.find(function (cluster) {
+          return cluster.objects.includes(conn.to);
+        });
+        return !fromCluster || !toCluster || fromCluster.objects.length <= 2 || toCluster.objects.length <= 2;
+      });
+
+      // First add direct connections
+      directConnections.forEach(function (conn) {
+        if (!connectionSet.has(JSON.stringify(conn))) {
+          rewiredConnections.push(conn);
+          connectionSet.add(JSON.stringify(conn));
+        }
+      });
+
+      // Then add gateway connections
+      var gatewayConnections = [];
+      connections.forEach(function (conn) {
+        var _clusters$find, _clusters$find2;
+        var fromCluster = (_clusters$find = clusters.find(function (cluster) {
+          return cluster.objects.includes(conn.from);
+        })) === null || _clusters$find === void 0 ? void 0 : _clusters$find.clusterId;
+        var toCluster = (_clusters$find2 = clusters.find(function (cluster) {
+          return cluster.objects.includes(conn.to);
+        })) === null || _clusters$find2 === void 0 ? void 0 : _clusters$find2.clusterId;
+        if (fromCluster !== undefined && toCluster !== undefined) {
+          var fromGateway = gatewayMap.get(fromCluster);
+          var toGateway = gatewayMap.get(toCluster);
+          if (fromGateway !== undefined && toGateway !== undefined) {
+            var fromGatewayId = fromGateway;
+            var toGatewayId = toGateway;
+
+            // Track the original connection that will be replaced
+            var originalConnection = {
+              from: conn.from,
+              to: conn.to
+            };
+            var addedConnections = [];
+
+            // If both objects are in the same cluster, connect through their gateway
+            if (fromCluster === toCluster) {
+              var conn1 = {
+                from: conn.from,
+                to: fromGatewayId
+              };
+              var conn2 = {
+                from: fromGatewayId,
+                to: conn.to
+              };
+
+              // Only add if not already present
+              if (!connectionSet.has(JSON.stringify(conn1))) {
+                gatewayConnections.push(conn1);
+                connectionSet.add(JSON.stringify(conn1));
+                addedConnections.push(conn1);
+              }
+              if (!connectionSet.has(JSON.stringify(conn2))) {
+                gatewayConnections.push(conn2);
+                connectionSet.add(JSON.stringify(conn2));
+                addedConnections.push(conn2);
+              }
+            } else {
+              // If objects are in different clusters, connect through both gateways
+              var _conn = {
+                from: conn.from,
+                to: fromGatewayId
+              };
+              var _conn2 = {
+                from: fromGatewayId,
+                to: toGatewayId
+              };
+              var conn3 = {
+                from: toGatewayId,
+                to: conn.to
+              };
+
+              // Only add if not already present
+              if (!connectionSet.has(JSON.stringify(_conn))) {
+                gatewayConnections.push(_conn);
+                connectionSet.add(JSON.stringify(_conn));
+                addedConnections.push(_conn);
+              }
+              if (!connectionSet.has(JSON.stringify(_conn2))) {
+                gatewayConnections.push(_conn2);
+                connectionSet.add(JSON.stringify(_conn2));
+                addedConnections.push(_conn2);
+              }
+              if (!connectionSet.has(JSON.stringify(conn3))) {
+                gatewayConnections.push(conn3);
+                connectionSet.add(JSON.stringify(conn3));
+                addedConnections.push(conn3);
+              }
+            }
+
+            // Store the mapping for this connection
+            if (addedConnections.length > 0) {
+              gatewayConnectionMappings.set(JSON.stringify(originalConnection), {
+                removed: [originalConnection],
+                added: addedConnections
+              });
+            }
+          }
+        }
+      });
+
+      // Sort gateway connections by edge length
+      gatewayConnections.sort(function (a, b) {
+        var objA1 = sceneManager.findObjectByUUID(a.from);
+        var objA2 = sceneManager.findObjectByUUID(a.to);
+        var objB1 = sceneManager.findObjectByUUID(b.from);
+        var objB2 = sceneManager.findObjectByUUID(b.to);
+        if (!objA1 || !objA2 || !objB1 || !objB2) return 0;
+        var distA = _this.treePathManager.distance(sceneManager.getWorldPosition(objA1), sceneManager.getWorldPosition(objA2));
+        var distB = _this.treePathManager.distance(sceneManager.getWorldPosition(objB1), sceneManager.getWorldPosition(objB2));
+        return distA - distB;
+      });
+
+      // Add sorted gateway connections to rewiredConnections
+      rewiredConnections.push.apply(rewiredConnections, gatewayConnections);
+      var paths = this.pathManager.findPaths(rewiredConnections || []);
+
+      // Aggregate connection mappings by gateway
+      var gatewayConnectionsMap = new Map();
+
+      // Initialize connection mappings for each gateway
+      Array.from(gatewayMap.entries()).forEach(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2);
+          _ref2[0];
+          var gatewayId = _ref2[1];
+        gatewayConnectionsMap.set(gatewayId, {
+          removed: [],
+          added: []
+        });
+      });
+
+      // Populate connection mappings
+      gatewayConnectionMappings.forEach(function (mapping, connectionKey) {
+        var _clusters$find3, _clusters$find4;
+        var originalConnection = JSON.parse(connectionKey);
+        var fromCluster = (_clusters$find3 = clusters.find(function (cluster) {
+          return cluster.objects.includes(originalConnection.from);
+        })) === null || _clusters$find3 === void 0 ? void 0 : _clusters$find3.clusterId;
+        var toCluster = (_clusters$find4 = clusters.find(function (cluster) {
+          return cluster.objects.includes(originalConnection.to);
+        })) === null || _clusters$find4 === void 0 ? void 0 : _clusters$find4.clusterId;
+        if (fromCluster !== undefined && toCluster !== undefined) {
+          var fromGateway = gatewayMap.get(fromCluster);
+          var toGateway = gatewayMap.get(toCluster);
+          if (fromGateway !== undefined && toGateway !== undefined) {
+            // Add to both gateways if they're different
+            if (fromGateway === toGateway) {
+              var _gatewayConnections$a;
+              // Same gateway
+              var _gatewayConnections = gatewayConnectionsMap.get(fromGateway);
+              _gatewayConnections.removed.push(originalConnection);
+              (_gatewayConnections$a = _gatewayConnections.added).push.apply(_gatewayConnections$a, _toConsumableArray(mapping.added));
+            } else {
+              // Different gateways - split the connections
+              var fromGatewayConnections = gatewayConnectionsMap.get(fromGateway);
+              var toGatewayConnections = gatewayConnectionsMap.get(toGateway);
+
+              // Add the original connection to both gateways' removed list
+              fromGatewayConnections.removed.push(originalConnection);
+              toGatewayConnections.removed.push(originalConnection);
+
+              // Split added connections by gateway
+              mapping.added.forEach(function (conn) {
+                if (conn.from === originalConnection.from || conn.to === fromGateway) {
+                  fromGatewayConnections.added.push(conn);
+                }
+                if (conn.from === toGateway || conn.to === originalConnection.to) {
+                  toGatewayConnections.added.push(conn);
+                }
+              });
+            }
+          }
+        }
+      });
+      return {
+        paths: paths,
+        rewiredConnections: rewiredConnections,
+        gateways: Array.from(gatewayMap.entries()).map(function (_ref3) {
+          var _clusters$find5;
+          var _ref4 = _slicedToArray(_ref3, 2),
+            clusterId = _ref4[0],
+            gatewayId = _ref4[1];
+          return {
+            clusterId: clusterId,
+            id: gatewayId,
+            position: (_clusters$find5 = clusters.find(function (c) {
+              return c.clusterId === clusterId;
+            })) === null || _clusters$find5 === void 0 ? void 0 : _clusters$find5.jointPoint,
+            connections: gatewayConnectionsMap.get(gatewayId) || {
+              removed: [],
+              added: []
+            }
+          };
+        })
+      };
+    }
+  }]);
+}();
+
 var PathfindingManager = /*#__PURE__*/function () {
   function PathfindingManager(sceneViewer) {
     _classCallCheck(this, PathfindingManager);
@@ -17492,7 +19330,7 @@ var PathfindingManager = /*#__PURE__*/function () {
               return this.logPathfinderVersion(context);
             case 1:
               // Create pathfinder instance with configuration only
-              this.pathfinder = new pathfinder.Pathfinder(this.pathfinderConfig);
+              this.pathfinder = new Pathfinder(this.pathfinderConfig);
               this.sceneViewer.pathfinder = this.pathfinder;
 
               // Add debugging for pathfinder input