@2112-lab/central-plant 0.1.51 → 0.1.53

package/dist/bundle/index.js

@@ -239,6 +239,26 @@ function _objectSpread2(e) {
   }
   return e;
 }
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
 function _possibleConstructorReturn(t, e) {
   if (e && ("object" == typeof e || "function" == typeof e)) return e;
   if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
@@ -19090,23 +19110,30 @@ var TransformOperationsManager = /*#__PURE__*/function () {
      * @param {number} value - The value to translate by
      * @returns {boolean} True if translation was successful, false otherwise
      */
+    /**
+     * Validate all preconditions for translateSegment operation
+     * @param {string} segmentId - The UUID of the segment to translate
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by
+     * @returns {Object|null} Returns { segment } if all checks pass, null otherwise
+     * @private
+     */
   }, {
-    key: "translateSegment",
-    value: function translateSegment(segmentId, axis, value) {
-      var _segment$userData, _segment$userData2, _segment$userData3, _this$sceneViewer2, _this$sceneViewer$man2, _this$sceneViewer$man3, _this$sceneViewer$man4;
-      var skipPathUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    key: "validateTranslateSegment",
+    value: function validateTranslateSegment(segmentId, axis, value) {
+      var _segment$userData, _segment$userData2, _segment$userData3;
       // Validate parameters
       if (!segmentId || !axis || value === undefined || value === null) {
         console.error('❌ translateSegment(): Invalid parameters');
-        return false;
+        return null;
       }
       if (!['x', 'y', 'z'].includes(axis)) {
         console.error("\u274C translateSegment(): Invalid axis '".concat(axis, "'. Must be 'x', 'y', or 'z'"));
-        return false;
+        return null;
       }
       if (!this.sceneViewer || !this.sceneViewer.scene) {
         console.error('❌ translateSegment(): Scene viewer or scene not available');
-        return false;
+        return null;
       }
 
       // Find the segment in the scene
@@ -19119,25 +19146,25 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       });
       if (!segment) {
         console.error("\u274C translateSegment(): Segment with ID '".concat(segmentId, "' not found in scene"));
-        return false;
+        return null;
       }
 
       // Validate that it's actually a pipe segment
       if (!((_segment$userData = segment.userData) !== null && _segment$userData !== void 0 && _segment$userData.objectType) === 'segment') {
         console.error("\u274C translateSegment(): Object with ID '".concat(segmentId, "' is not a valid pipe segment"));
-        return false;
+        return null;
       }
 
       // Check if segment is transformable
       if (((_segment$userData2 = segment.userData) === null || _segment$userData2 === void 0 ? void 0 : _segment$userData2.transformable) === false) {
         console.warn("\u26A0\uFE0F translateSegment(): Segment '".concat(segmentId, "' is marked as non-transformable (stub segment)"));
-        return false;
+        return null;
       }
 
       // Check if segment is immutable (computed from pathfinder)
       if (((_segment$userData3 = segment.userData) === null || _segment$userData3 === void 0 ? void 0 : _segment$userData3.immutable) === true) {
         console.warn("\u26A0\uFE0F translateSegment(): Segment '".concat(segmentId, "' is immutable (computed from pathfinder)"));
-        return false;
+        return null;
       }
 
       // Check segment orientation and cancel invalid translations
@@ -19156,62 +19183,74 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       if (absX > tolerance && axis === 'x') {
         console.warn("\u26A0\uFE0F translateSegment(): Cannot translate segment along ".concat(axis.toUpperCase(), " axis - segment runs along this axis"));
         console.warn("   Segment direction: [".concat(direction.x.toFixed(3), ", ").concat(direction.y.toFixed(3), ", ").concat(direction.z.toFixed(3), "]"));
-        return false;
+        return null;
       }
       if (absY > tolerance && axis === 'y') {
         console.warn("\u26A0\uFE0F translateSegment(): Cannot translate segment along ".concat(axis.toUpperCase(), " axis - segment runs along this axis"));
         console.warn("   Segment direction: [".concat(direction.x.toFixed(3), ", ").concat(direction.y.toFixed(3), ", ").concat(direction.z.toFixed(3), "]"));
-        return false;
+        return null;
       }
       if (absZ > tolerance && axis === 'z') {
         console.warn("\u26A0\uFE0F translateSegment(): Cannot translate segment along ".concat(axis.toUpperCase(), " axis - segment runs along this axis"));
         console.warn("   Segment direction: [".concat(direction.x.toFixed(3), ", ").concat(direction.y.toFixed(3), ", ").concat(direction.z.toFixed(3), "]"));
-        return false;
+        return null;
       }
-      console.log('[translateSegment] segment:', segment);
 
-      // Calculate segment endpoints to check for nearby connectors
-      var segmentEndpoints = this.calculateSegmentEndpoints(segment);
+      // All checks passed - return the segment
+      return {
+        segment: segment
+      };
+    }
 
-      // Check if there are any connectors (component or manual) at segment endpoints
-      var connectorsAtEndpoints = this.findConnectorsAtPositions([segmentEndpoints.start, segmentEndpoints.end], 0.15 // tolerance for position matching
-      );
-      console.log("\uD83D\uDD0D Found ".concat(connectorsAtEndpoints.length, " total connectors at segment endpoints:"), connectorsAtEndpoints.map(function (c) {
-        var _c$userData, _c$parent, _c$parent2;
-        return {
-          uuid: c.uuid,
-          type: (_c$userData = c.userData) === null || _c$userData === void 0 ? void 0 : _c$userData.objectType,
-          parent: (_c$parent = c.parent) === null || _c$parent === void 0 ? void 0 : _c$parent.uuid,
-          parentType: (_c$parent2 = c.parent) === null || _c$parent2 === void 0 || (_c$parent2 = _c$parent2.userData) === null || _c$parent2 === void 0 ? void 0 : _c$parent2.objectType
-        };
-      }));
-      console.log("\uD83D\uDD04 translateSegment(): Translating segment ".concat(segmentId, " on ").concat(axis, " axis by ").concat(value));
+    /**
+     * Validate collision constraints for translateSegment operation
+     * Temporarily applies the translation to check for collisions, then reverts
+     * @param {THREE.Object3D} segment - The segment to check
+     * @param {string} axis - The axis to translate on ('x', 'y', or 'z')
+     * @param {number} value - The value to translate by
+     * @returns {boolean} True if no collisions detected, false if translation would cause collision
+     * @private
+     */
+  }, {
+    key: "validateTranslateSegmentCollisions",
+    value: function validateTranslateSegmentCollisions(segment, axis, value) {
+      var _this$sceneViewer2;
+      // Store original position for reverting
+      var originalPosition = segment.position[axis];
 
       // Temporarily apply the translation to check for collisions
-      var originalPosition = segment.position[axis];
       segment.position[axis] += value;
       segment.updateMatrix();
       segment.updateMatrixWorld(true);
 
       // Check for collision with component connectors along the segment's path
-      var collision = this.checkSegmentPathConnectorCollision(segment);
-      if (collision) {
+      var connectorCollision = this.checkSegmentPathConnectorCollision(segment);
+      if (connectorCollision) {
         // Revert the translation
         segment.position[axis] = originalPosition;
         segment.updateMatrix();
         segment.updateMatrixWorld(true);
         console.warn("\u26A0\uFE0F translateSegment(): Translation canceled - segment path comes within 0.5 radius of component connector");
-        console.warn("   Distance to connector: ".concat(collision.distance.toFixed(3), " (max allowed: 0.5)"));
-        console.warn("   Closest point on segment: [".concat(collision.collisionPoint.x.toFixed(3), ", ").concat(collision.collisionPoint.y.toFixed(3), ", ").concat(collision.collisionPoint.z.toFixed(3), "]"));
-        console.warn("   Connector position: [".concat(collision.connectorPos.x.toFixed(3), ", ").concat(collision.connectorPos.y.toFixed(3), ", ").concat(collision.connectorPos.z.toFixed(3), "]"));
-        console.warn("   Colliding connector: ".concat(collision.connectorId, " on component: ").concat(collision.componentId));
+        console.warn("   Distance to connector: ".concat(connectorCollision.distance.toFixed(3), " (max allowed: 0.5)"));
+        console.warn("   Closest point on segment: [".concat(connectorCollision.collisionPoint.x.toFixed(3), ", ").concat(connectorCollision.collisionPoint.y.toFixed(3), ", ").concat(connectorCollision.collisionPoint.z.toFixed(3), "]"));
+        console.warn("   Connector position: [".concat(connectorCollision.connectorPos.x.toFixed(3), ", ").concat(connectorCollision.connectorPos.y.toFixed(3), ", ").concat(connectorCollision.connectorPos.z.toFixed(3), "]"));
+        console.warn("   Colliding connector: ".concat(connectorCollision.connectorId, " on component: ").concat(connectorCollision.componentId));
         return false;
       }
 
-      // Revert the temporary translation before continuing with the normal flow
-      segment.position[axis] = originalPosition;
-      segment.updateMatrix();
-      segment.updateMatrixWorld(true);
+      // Check for collision with component bounding boxes
+      var componentCollision = this.checkSegmentComponentBoundingBoxCollision(segment);
+      if (componentCollision) {
+        // Revert the translation
+        segment.position[axis] = originalPosition;
+        segment.updateMatrix();
+        segment.updateMatrixWorld(true);
+        console.warn("\u26A0\uFE0F translateSegment(): Translation canceled - segment would collide with component bounding box");
+        console.warn("   Component ID: ".concat(componentCollision.componentId));
+        console.warn("   Component Name: ".concat(componentCollision.componentName));
+        console.warn("   Component Type: ".concat(componentCollision.componentType));
+        return false;
+      }
 
       // Check if translationalOverrideForAutomaticSegments is enabled
       var translationalOverride = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.managers) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.settingsManager) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.getSetting('scene', 'translationalOverrideForAutomaticSegments');
@@ -19220,33 +19259,50 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       if (translationalOverride === false) {
         console.log('🔍 Checking for intersections with computed segments (translationalOverrideForAutomaticSegments is disabled)');
 
-        // Temporarily apply the translation to check for intersections
-        var _originalPosition = segment.position[axis];
-        segment.position[axis] += value;
-        segment.updateMatrix();
-        segment.updateMatrixWorld(true);
-
         // Check if the translated segment intersects with any computed segments
         var hasIntersection = this.checkSegmentIntersection(segment);
         console.log("\uD83D\uDD04 translateSegment() hasIntersection:", hasIntersection);
         if (hasIntersection) {
           // Revert the translation
-          segment.position[axis] = _originalPosition;
+          segment.position[axis] = originalPosition;
           segment.updateMatrix();
           segment.updateMatrixWorld(true);
           console.warn("\u26A0\uFE0F translateSegment(): Translation canceled - segment would intersect with computed segment(s)");
           return false;
         }
         console.log('✅ No intersections detected, proceeding with translation');
-      } else {
-        // Apply the translation to the Three.js object
-        segment.position[axis] += value;
+      }
 
-        // Update matrices
-        segment.updateMatrix();
-        segment.updateMatrixWorld(true);
+      // Revert the temporary translation
+      segment.position[axis] = originalPosition;
+      segment.updateMatrix();
+      segment.updateMatrixWorld(true);
+      return true;
+    }
+  }, {
+    key: "translateSegment",
+    value: function translateSegment(segmentId, axis, value) {
+      var _this$sceneViewer$man2, _this$sceneViewer$man3, _this$sceneViewer$man4;
+      var skipPathUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      // Run all basic validation checks
+      var validationResult = this.validateTranslateSegment(segmentId, axis, value);
+      if (!validationResult) {
+        return false;
+      }
+      var segment = validationResult.segment;
+      console.log("\uD83D\uDD04 translateSegment(): Translating segment ".concat(segmentId, " on ").concat(axis, " axis by ").concat(value));
+
+      // Run collision validation checks
+      var collisionValidation = this.validateTranslateSegmentCollisions(segment, axis, value);
+      if (!collisionValidation) {
+        return false;
       }
 
+      // All validations passed - apply the translation
+      segment.position[axis] += value;
+      segment.updateMatrix();
+      segment.updateMatrixWorld(true);
+
       // Validate PathfindingManager and SceneOperationsManager availability
       var pathfindingManager = (_this$sceneViewer$man2 = this.sceneViewer.managers) === null || _this$sceneViewer$man2 === void 0 ? void 0 : _this$sceneViewer$man2.pathfindingManager;
       var sceneOperationsManager = (_this$sceneViewer$man3 = this.sceneViewer.managers) === null || _this$sceneViewer$man3 === void 0 ? void 0 : _this$sceneViewer$man3.sceneOperationsManager;
@@ -19723,7 +19779,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "updateSegmentConnectorPositions",
     value: function updateSegmentConnectorPositions(segment) {
-      var _this$sceneViewer4;
+      var _this$sceneViewer4,
+        _this = this;
       console.log("updateSegmentConnectorPositions started:", segment);
       if (!segment || !((_this$sceneViewer4 = this.sceneViewer) !== null && _this$sceneViewer4 !== void 0 && (_this$sceneViewer4 = _this$sceneViewer4.currentSceneData) !== null && _this$sceneViewer4 !== void 0 && _this$sceneViewer4.scene)) {
         console.warn('⚠️ updateSegmentConnectorPositions(): Missing segment or scene data');
@@ -19735,7 +19792,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         return Math.abs(value) < 1e-10 ? 0 : value;
       };
 
-      // Find all child connectors of the segment
+      // Find all child connectors of the segment in the Three.js scene
       var connectors = [];
       segment.traverse(function (child) {
         var _child$userData8;
@@ -19749,29 +19806,14 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       }
       console.log("\uD83D\uDCCD Updating ".concat(connectors.length, " connector positions in scene data for segment ").concat(segment.uuid));
 
-      // First, find the segment in scene data
-      var sceneDataSegment = this.sceneViewer.currentSceneData.scene.children.find(function (child) {
-        var _segment$userData4;
-        return child.uuid === segment.uuid || child.uuid === ((_segment$userData4 = segment.userData) === null || _segment$userData4 === void 0 ? void 0 : _segment$userData4.originalUuid);
-      });
-      if (!sceneDataSegment) {
-        console.warn("\u26A0\uFE0F Segment ".concat(segment.uuid, " not found in scene data"));
-        return;
-      }
-      if (!sceneDataSegment.children || !Array.isArray(sceneDataSegment.children)) {
-        console.warn("\u26A0\uFE0F Segment ".concat(segment.uuid, " has no children array in scene data"));
-        return;
-      }
-      console.log("\u2705 Found segment in scene data with ".concat(sceneDataSegment.children.length, " children"));
-
-      // Update each connector's position in scene data
+      // Update each connector's position in scene data (connectors are at root level)
       connectors.forEach(function (connector) {
         // Get world position
         var worldPosition = new THREE__namespace.Vector3();
         connector.getWorldPosition(worldPosition);
 
-        // Find the connector in the segment's children array (not root scene.children)
-        var sceneDataConnector = sceneDataSegment.children.find(function (child) {
+        // Find the connector at root level in scene data
+        var sceneDataConnector = _this.sceneViewer.currentSceneData.scene.children.find(function (child) {
           var _connector$userData;
           return child.uuid === connector.uuid || child.uuid === ((_connector$userData = connector.userData) === null || _connector$userData === void 0 ? void 0 : _connector$userData.originalUuid);
         });
@@ -19780,9 +19822,14 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           sceneDataConnector.userData.position = [cleanPosition(worldPosition.x), cleanPosition(worldPosition.y), cleanPosition(worldPosition.z)];
           console.log("\u2705 Updated connector ".concat(connector.uuid, " position to [").concat(sceneDataConnector.userData.position.join(', '), "]"));
         } else {
-          console.warn("\u26A0\uFE0F Connector ".concat(connector.uuid, " not found in segment's children in scene data"));
+          console.warn("\u26A0\uFE0F Connector ".concat(connector.uuid, " not found in scene data root level"));
         }
       });
+
+      // Update segment matrix and all connector matrices
+      segment.updateMatrix();
+      segment.updateMatrixWorld(true);
+      console.log("\u2705 Updated matrices for segment ".concat(segment.uuid, " and its ").concat(connectors.length, " connectors"));
     }
 
     /**
@@ -19796,7 +19843,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
     key: "checkSegmentIntersection",
     value: function checkSegmentIntersection(segment) {
       var _this$sceneViewer5,
-        _this = this;
+        _this2 = this;
       if (!((_this$sceneViewer5 = this.sceneViewer) !== null && _this$sceneViewer5 !== void 0 && _this$sceneViewer5.scene)) {
         return false;
       }
@@ -19819,7 +19866,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Only check computed segments (isDeclared === false or undefined)
         if (((_child$userData9 = child.userData) === null || _child$userData9 === void 0 ? void 0 : _child$userData9.objectType) === 'segment' && ((_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.isDeclared) !== true) {
           // Get endpoints of the computed segment
-          var computedEndpoints = _this.calculateSegmentEndpoints(child);
+          var computedEndpoints = _this2.calculateSegmentEndpoints(child);
           var computedRadius = child.geometry.parameters.radiusTop || 0.05;
 
           // Combined radius threshold - segments intersect if closer than this
@@ -19844,7 +19891,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
           }
 
           // Calculate the minimum distance between the two line segments
-          var distance = _this.calculateSegmentToSegmentDistance(segmentEndpoints.start, segmentEndpoints.end, computedEndpoints.start, computedEndpoints.end);
+          var distance = _this2.calculateSegmentToSegmentDistance(segmentEndpoints.start, segmentEndpoints.end, computedEndpoints.start, computedEndpoints.end);
 
           // Only flag as intersection if segments are closer than combined radius
           if (distance < combinedRadius) {
@@ -20030,6 +20077,48 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       return collision;
     }
 
+    /**
+     * Check if a segment would collide with any component's bounding box
+     * @param {THREE.Object3D} segment - The segment to check for collisions
+     * @returns {Object|null} Collision info {componentId, componentName, componentType} if collision detected, null otherwise
+     * @private
+     */
+  }, {
+    key: "checkSegmentComponentBoundingBoxCollision",
+    value: function checkSegmentComponentBoundingBoxCollision(segment) {
+      var _this$sceneViewer8;
+      if (!((_this$sceneViewer8 = this.sceneViewer) !== null && _this$sceneViewer8 !== void 0 && _this$sceneViewer8.scene) || !segment) {
+        return null;
+      }
+
+      // Create a bounding box for the segment
+      var segmentBBox = new THREE__namespace.Box3().setFromObject(segment);
+      var collision = null;
+
+      // Traverse scene to find all components
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData11, _child$userData12;
+        if (collision) return; // Stop if collision already found
+
+        // Check if this is a component (equipment)
+        if (((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType) === 'component' && (_child$userData12 = child.userData) !== null && _child$userData12 !== void 0 && _child$userData12.libraryId) {
+          // Create bounding box for the component
+          var componentBBox = new THREE__namespace.Box3().setFromObject(child);
+
+          // Check if bounding boxes intersect
+          if (segmentBBox.intersectsBox(componentBBox)) {
+            console.log('⚠️ TransformOperationsManager: Segment bounding box collision with component:', child.userData.libraryId || child.name || child.uuid);
+            collision = {
+              componentId: child.uuid,
+              componentName: child.name || 'Unknown',
+              componentType: child.userData.libraryId || 'Unknown'
+            };
+          }
+        }
+      });
+      return collision;
+    }
+
     /**
      * Calculate the minimum distance between two line segments in 3D space
      * @param {THREE.Vector3} p1 - Start point of first segment
@@ -20139,10 +20228,10 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "snapSegmentConnectorsToNearbyEndpoints",
     value: function snapSegmentConnectorsToNearbyEndpoints(movedSegment) {
-      var _this$sceneViewer8,
-        _this$sceneViewer9,
-        _this2 = this;
-      if (!movedSegment || !((_this$sceneViewer8 = this.sceneViewer) !== null && _this$sceneViewer8 !== void 0 && _this$sceneViewer8.scene)) {
+      var _this$sceneViewer9,
+        _this$sceneViewer0,
+        _this3 = this;
+      if (!movedSegment || !((_this$sceneViewer9 = this.sceneViewer) !== null && _this$sceneViewer9 !== void 0 && _this$sceneViewer9.scene)) {
         return [];
       }
       console.log('🔗 Finding adjacent segments connected to moved segment...');
@@ -20150,8 +20239,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Get the moved segment's connectors
       var movedConnectors = [];
       movedSegment.traverse(function (child) {
-        var _child$userData11;
-        if (((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType) === 'segment-connector') {
+        var _child$userData13;
+        if (((_child$userData13 = child.userData) === null || _child$userData13 === void 0 ? void 0 : _child$userData13.objectType) === 'segment-connector') {
           movedConnectors.push(child);
         }
       });
@@ -20164,7 +20253,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       var newEndpoints = this.calculateSegmentEndpoints(movedSegment);
 
       // Check scene data for connections involving the moved segment's connectors
-      var connections = ((_this$sceneViewer9 = this.sceneViewer) === null || _this$sceneViewer9 === void 0 || (_this$sceneViewer9 = _this$sceneViewer9.currentSceneData) === null || _this$sceneViewer9 === void 0 ? void 0 : _this$sceneViewer9.connections) || [];
+      var connections = ((_this$sceneViewer0 = this.sceneViewer) === null || _this$sceneViewer0 === void 0 || (_this$sceneViewer0 = _this$sceneViewer0.currentSceneData) === null || _this$sceneViewer0 === void 0 ? void 0 : _this$sceneViewer0.connections) || [];
       var movedConnectorIds = movedConnectors.map(function (c) {
         return c.uuid;
       });
@@ -20199,7 +20288,7 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Find the adjacent connector in the scene
         var adjacentConnector = null;
         var adjacentSegment = null;
-        _this2.sceneViewer.scene.traverse(function (object) {
+        _this3.sceneViewer.scene.traverse(function (object) {
           var _object$userData;
           if (object.uuid === pair.adjacentConnectorId && ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.objectType) === 'segment-connector') {
             adjacentConnector = object;
@@ -20221,8 +20310,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Get all connectors of the adjacent segment
         var adjacentConnectors = [];
         adjacentSegment.traverse(function (child) {
-          var _child$userData12;
-          if (((_child$userData12 = child.userData) === null || _child$userData12 === void 0 ? void 0 : _child$userData12.objectType) === 'segment-connector') {
+          var _child$userData14;
+          if (((_child$userData14 = child.userData) === null || _child$userData14 === void 0 ? void 0 : _child$userData14.objectType) === 'segment-connector') {
             adjacentConnectors.push(child);
           }
         });
@@ -20248,12 +20337,12 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Constrain movement to maintain orthogonal alignment
         // Horizontal segments: only adjust X and Y, keep Z constant
         // Vertical segments: only adjust Z, keep X and Y constant
-        var constrainedPosition = _this2.constrainPositionToOrthogonal(pair.newPosition, stationaryWorldPos, adjacentSegment);
+        var constrainedPosition = _this3.constrainPositionToOrthogonal(pair.newPosition, stationaryWorldPos, adjacentSegment);
 
         // Recreate the segment mesh with new length using explicit endpoint positions
         // Pass the intended positions, not the connector objects (which may have temporary positions)
         // Pass movedSegment as activeSegment context so zero-length removal knows which segment to extend
-        _this2.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, constrainedPosition, stationaryWorldPos, movedSegment);
+        _this3.recreateSegmentMeshWithNewLength(adjacentSegment, adjacentConnectors, constrainedPosition, stationaryWorldPos, movedSegment);
 
         // CRITICAL: After recreating the mesh, BOTH connectors need to be repositioned
         // because the segment's center and rotation have changed
@@ -20262,13 +20351,13 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         var movingLocalPos = adjacentSegment.worldToLocal(constrainedPosition.clone());
         movingConnector.position.copy(movingLocalPos);
         movingConnector.updateMatrixWorld(true);
-        _this2.updateConnectorPositionInSceneData(movingConnector, constrainedPosition, adjacentSegment);
+        _this3.updateConnectorPositionInSceneData(movingConnector, constrainedPosition, adjacentSegment);
 
         // Position stationary connector at its original world position
         var stationaryLocalPos = adjacentSegment.worldToLocal(stationaryWorldPos.clone());
         stationaryConnector.position.copy(stationaryLocalPos);
         stationaryConnector.updateMatrixWorld(true);
-        _this2.updateConnectorPositionInSceneData(stationaryConnector, stationaryWorldPos, adjacentSegment);
+        _this3.updateConnectorPositionInSceneData(stationaryConnector, stationaryWorldPos, adjacentSegment);
 
         // Record this connection as satisfied
         satisfiedConnections.push({
@@ -20320,27 +20409,27 @@ var TransformOperationsManager = /*#__PURE__*/function () {
   }, {
     key: "updateConnectorPositionInSceneData",
     value: function updateConnectorPositionInSceneData(connector, worldPosition, parentSegment) {
-      var _this$sceneViewer0;
+      var _this$sceneViewer1;
       // Update scene data if available
-      if (!((_this$sceneViewer0 = this.sceneViewer) !== null && _this$sceneViewer0 !== void 0 && _this$sceneViewer0.currentSceneData)) {
+      if (!((_this$sceneViewer1 = this.sceneViewer) !== null && _this$sceneViewer1 !== void 0 && (_this$sceneViewer1 = _this$sceneViewer1.currentSceneData) !== null && _this$sceneViewer1 !== void 0 && _this$sceneViewer1.scene)) {
         return;
       }
       var cleanPosition = function cleanPosition(value) {
         return Math.abs(value) < 1e-10 ? 0 : value;
       };
 
-      // Find connector in scene data and update position
-      var segmentInSceneData = this.sceneViewer.currentSceneData.scene.children.find(function (child) {
-        return child.uuid === parentSegment.uuid;
+      // Find the connector at root level in scene data
+      // Manual segment connectors are stored at the root level, not nested under the segment
+      var sceneDataConnector = this.sceneViewer.currentSceneData.scene.children.find(function (child) {
+        var _connector$userData2;
+        return child.uuid === connector.uuid || child.uuid === ((_connector$userData2 = connector.userData) === null || _connector$userData2 === void 0 ? void 0 : _connector$userData2.originalUuid);
       });
-      if (segmentInSceneData !== null && segmentInSceneData !== void 0 && segmentInSceneData.children) {
-        var connectorInSceneData = segmentInSceneData.children.find(function (child) {
-          return child.uuid === connector.uuid;
-        });
-        if (connectorInSceneData !== null && connectorInSceneData !== void 0 && connectorInSceneData.userData) {
-          connectorInSceneData.userData.position = [cleanPosition(worldPosition.x), cleanPosition(worldPosition.y), cleanPosition(worldPosition.z)];
-          console.log("\u2705 Updated connector ".concat(connector.uuid, " position in scene data to [").concat(connectorInSceneData.userData.position.join(', '), "]"));
-        }
+      if (sceneDataConnector && sceneDataConnector.userData) {
+        // Update position as array [x, y, z] for pathfinder compatibility
+        sceneDataConnector.userData.position = [cleanPosition(worldPosition.x), cleanPosition(worldPosition.y), cleanPosition(worldPosition.z)];
+        console.log("\u2705 Updated connector ".concat(connector.uuid, " position in scene data to [").concat(sceneDataConnector.userData.position.join(', '), "]"));
+      } else {
+        console.warn("\u26A0\uFE0F Connector ".concat(connector.uuid, " not found at root level in scene data"));
       }
     }
 
@@ -20532,135 +20621,167 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       currentSceneData.connections = newConnections;
       console.log("\u2705 Updated connections: removed ".concat(removedConnections.length, ", added ").concat(externalId1 && externalId2 ? 1 : 0, ", total now: ").concat(newConnections.length));
 
-      // If there's an active segment (the one being translated), extend it to physically connect
-      if (activeSegment && externalId1 && externalId2) {
-        this._extendActiveSegmentToConnector(activeSegment, externalId1, externalId2, connector1Uuid, connector2Uuid);
-      }
+      // Remove the segment's connectors from the scene and scene data
+      connectors.forEach(function (connector) {
+        var connectorUuid = connector.uuid;
+
+        // Remove connector from Three.js scene
+        if (connector.parent) {
+          connector.parent.remove(connector);
+          console.log("\uD83D\uDDD1\uFE0F Removed connector ".concat(connectorUuid, " from Three.js scene"));
+        }
+
+        // Dispose connector geometry and material
+        if (connector.geometry) {
+          connector.geometry.dispose();
+        }
+        if (connector.material) {
+          if (Array.isArray(connector.material)) {
+            connector.material.forEach(function (mat) {
+              return mat.dispose();
+            });
+          } else {
+            connector.material.dispose();
+          }
+        }
+
+        // Remove connector from scene data (connectors are at root level)
+        if (currentSceneData.scene && currentSceneData.scene.children) {
+          var connectorIndex = currentSceneData.scene.children.findIndex(function (child) {
+            var _connector$userData3;
+            return child.uuid === connectorUuid || child.uuid === ((_connector$userData3 = connector.userData) === null || _connector$userData3 === void 0 ? void 0 : _connector$userData3.originalUuid);
+          });
+          if (connectorIndex !== -1) {
+            currentSceneData.scene.children.splice(connectorIndex, 1);
+            console.log("\u2705 Removed connector ".concat(connectorUuid, " from scene data at index ").concat(connectorIndex));
+          }
+        }
+      });
 
       // Remove the segment from the scene
       if (segment.parent) {
         segment.parent.remove(segment);
+        console.log("\uD83D\uDDD1\uFE0F Removed segment ".concat(segment.uuid, " from Three.js scene"));
       }
 
-      // Dispose segment geometry and remove from scene data
+      // Dispose segment geometry and material
       if (segment.geometry) {
         segment.geometry.dispose();
       }
+      if (segment.material) {
+        if (Array.isArray(segment.material)) {
+          segment.material.forEach(function (mat) {
+            return mat.dispose();
+          });
+        } else {
+          segment.material.dispose();
+        }
+      }
 
       // Remove segment from scene data
       if (currentSceneData.scene && currentSceneData.scene.children) {
         var segmentIndex = currentSceneData.scene.children.findIndex(function (child) {
-          var _segment$userData5;
-          return child.uuid === segment.uuid || child.uuid === ((_segment$userData5 = segment.userData) === null || _segment$userData5 === void 0 ? void 0 : _segment$userData5.originalUuid);
+          var _segment$userData4;
+          return child.uuid === segment.uuid || child.uuid === ((_segment$userData4 = segment.userData) === null || _segment$userData4 === void 0 ? void 0 : _segment$userData4.originalUuid);
         });
         if (segmentIndex !== -1) {
           currentSceneData.scene.children.splice(segmentIndex, 1);
           console.log("\u2705 Removed segment from scene data at index ".concat(segmentIndex));
         }
       }
-      console.log("\u2705 Zero-length segment removed successfully: ".concat(segment.uuid));
-
-      // Trigger path regeneration to create new segments for the merged connections
-      console.log('🔄 Triggering path regeneration to handle merged connections...');
-      if (sceneViewer && typeof sceneViewer.updatePaths === 'function') {
-        sceneViewer.updatePaths();
-      }
-    }
-
-    /**
-     * Extend the active segment to physically connect with the connector on the other side
-     * @param {THREE.Object3D} activeSegment - The segment being translated (that caused the collapse)
-     * @param {string} externalId1 - First external connector UUID
-     * @param {string} externalId2 - Second external connector UUID
-     * @param {string} collapsedConnector1Uuid - First connector of the collapsed segment
-     * @param {string} collapsedConnector2Uuid - Second connector of the collapsed segment
-     * @private
-     */
-  }, {
-    key: "_extendActiveSegmentToConnector",
-    value: function _extendActiveSegmentToConnector(activeSegment, externalId1, externalId2, collapsedConnector1Uuid, collapsedConnector2Uuid) {
-      console.log("\uD83D\uDD17 Extending active segment ".concat(activeSegment.uuid, " to connect with external connector"));
-
-      // Get the active segment's connectors
-      var activeConnectors = [];
-      activeSegment.traverse(function (child) {
-        var _child$userData13;
-        if (((_child$userData13 = child.userData) === null || _child$userData13 === void 0 ? void 0 : _child$userData13.objectType) === 'segment-connector') {
-          activeConnectors.push(child);
-        }
-      });
-      if (activeConnectors.length !== 2) {
-        console.warn("\u26A0\uFE0F Active segment doesn't have exactly 2 connectors, cannot extend");
-        return;
-      }
-
-      // Determine which external connector is connected to the active segment
-      // and which one is on the other side (needs to be extended to)
-      var activeConnectorId = null;
-      var targetConnectorId = null;
+      console.log("\u2705 Zero-length segment and its connectors removed successfully: ".concat(segment.uuid));
 
-      // Check if externalId1 or externalId2 is one of the active segment's connectors
-      var activeConnectorIds = activeConnectors.map(function (c) {
-        return c.uuid;
-      });
-      if (activeConnectorIds.includes(externalId1)) {
-        activeConnectorId = externalId1;
-        targetConnectorId = externalId2;
-      } else if (activeConnectorIds.includes(externalId2)) {
-        activeConnectorId = externalId2;
-        targetConnectorId = externalId1;
-      } else {
-        console.warn("\u26A0\uFE0F Neither external connector belongs to active segment - cannot extend");
-        return;
-      }
-      console.log("\uD83C\uDFAF Extending from active connector ".concat(activeConnectorId, " to target connector ").concat(targetConnectorId));
+      // If there's an active segment being moved, extend it to connect to the external connector
+      if (activeSegment && externalId1 && externalId2) {
+        console.log('🔗 Extending active segment to maintain connection with external connector...');
+
+        // Find which connector belongs to the active segment
+        var activeSegmentConnectorId = null;
+        var externalConnectorToReach = null;
+
+        // Check if either external connector belongs to the active segment
+        var activeSegmentConnectors = [];
+        activeSegment.traverse(function (child) {
+          var _child$userData15;
+          if (((_child$userData15 = child.userData) === null || _child$userData15 === void 0 ? void 0 : _child$userData15.objectType) === 'segment-connector') {
+            activeSegmentConnectors.push(child.uuid);
+          }
+        });
+        if (activeSegmentConnectors.includes(externalId1)) {
+          activeSegmentConnectorId = externalId1;
+          externalConnectorToReach = externalId2;
+        } else if (activeSegmentConnectors.includes(externalId2)) {
+          activeSegmentConnectorId = externalId2;
+          externalConnectorToReach = externalId1;
+        }
+        if (activeSegmentConnectorId && externalConnectorToReach) {
+          console.log("\uD83D\uDCCD Active segment connector: ".concat(activeSegmentConnectorId));
+          console.log("\uD83D\uDCCD External connector to reach: ".concat(externalConnectorToReach));
+
+          // Find the external connector object in the scene
+          var externalConnectorObj = null;
+          sceneViewer.scene.traverse(function (child) {
+            if (child.uuid === externalConnectorToReach) {
+              externalConnectorObj = child;
+            }
+          });
+          if (externalConnectorObj) {
+            // Get the external connector's world position
+            var externalWorldPos = new THREE__namespace.Vector3();
+            externalConnectorObj.getWorldPosition(externalWorldPos);
+            console.log("\uD83C\uDFAF Extending active segment connector to position: [".concat(externalWorldPos.x.toFixed(3), ", ").concat(externalWorldPos.y.toFixed(3), ", ").concat(externalWorldPos.z.toFixed(3), "]"));
+
+            // Find the active segment's connector object
+            var activeConnectorObj = null;
+            activeSegment.traverse(function (child) {
+              if (child.uuid === activeSegmentConnectorId) {
+                activeConnectorObj = child;
+              }
+            });
+            if (activeConnectorObj) {
+              // Get all connectors of the active segment
+              var activeConnectors = [];
+              activeSegment.traverse(function (child) {
+                var _child$userData16;
+                if (((_child$userData16 = child.userData) === null || _child$userData16 === void 0 ? void 0 : _child$userData16.objectType) === 'segment-connector') {
+                  activeConnectors.push(child);
+                }
+              });
 
-      // Find the target connector in the scene
-      var targetConnector = null;
-      this.sceneViewer.scene.traverse(function (object) {
-        if (object.uuid === targetConnectorId) {
-          targetConnector = object;
+              // Find the stationary connector (the one we're NOT moving)
+              var stationaryConnector = activeConnectors.find(function (c) {
+                return c.uuid !== activeSegmentConnectorId;
+              });
+              if (stationaryConnector && activeConnectors.length === 2) {
+                var stationaryWorldPos = new THREE__namespace.Vector3();
+                stationaryConnector.getWorldPosition(stationaryWorldPos);
+
+                // Recreate the active segment with new length to reach the external connector
+                this.recreateSegmentMeshWithNewLength(activeSegment, activeConnectors, externalWorldPos, stationaryWorldPos);
+
+                // Update connector positions in scene data
+                var movingLocalPos = activeSegment.worldToLocal(externalWorldPos.clone());
+                activeConnectorObj.position.copy(movingLocalPos);
+                activeConnectorObj.updateMatrixWorld(true);
+                this.updateConnectorPositionInSceneData(activeConnectorObj, externalWorldPos, activeSegment);
+                var stationaryLocalPos = activeSegment.worldToLocal(stationaryWorldPos.clone());
+                stationaryConnector.position.copy(stationaryLocalPos);
+                stationaryConnector.updateMatrixWorld(true);
+                this.updateConnectorPositionInSceneData(stationaryConnector, stationaryWorldPos, activeSegment);
+                console.log("\u2705 Active segment extended to connect with external connector");
+              }
+            }
+          }
+        } else {
+          console.log('ℹ️ No active segment connector found in the connection - will regenerate paths instead');
         }
-      });
-      if (!targetConnector) {
-        console.warn("\u26A0\uFE0F Could not find target connector ".concat(targetConnectorId));
-        return;
       }
 
-      // Get target connector's world position
-      var targetWorldPos = new THREE__namespace.Vector3();
-      targetConnector.getWorldPosition(targetWorldPos);
-
-      // Find which connector on the active segment needs to be moved
-      var movingConnector = activeConnectors.find(function (c) {
-        return c.uuid === activeConnectorId;
-      });
-      var stationaryConnector = activeConnectors.find(function (c) {
-        return c.uuid !== activeConnectorId;
-      });
-      if (!movingConnector || !stationaryConnector) {
-        console.warn("\u26A0\uFE0F Could not identify moving/stationary connectors");
-        return;
+      // Trigger path regeneration to create new segments for any remaining unconnected endpoints
+      console.log('🔄 Triggering path regeneration to handle any remaining connections...');
+      if (sceneViewer && typeof sceneViewer.updatePaths === 'function') {
+        sceneViewer.updatePaths();
       }
-
-      // Get stationary connector's position
-      var stationaryWorldPos = new THREE__namespace.Vector3();
-      stationaryConnector.getWorldPosition(stationaryWorldPos);
-
-      // Recreate the segment with new length to reach the target connector
-      console.log("\uD83D\uDCCF Extending active segment to reach target connector at [".concat(targetWorldPos.x.toFixed(2), ", ").concat(targetWorldPos.y.toFixed(2), ", ").concat(targetWorldPos.z.toFixed(2), "]"));
-      this.recreateSegmentMeshWithNewLength(activeSegment, activeConnectors, targetWorldPos, stationaryWorldPos);
-
-      // Reposition both connectors after mesh recreation
-      var movingLocalPos = activeSegment.worldToLocal(targetWorldPos.clone());
-      movingConnector.position.copy(movingLocalPos);
-      movingConnector.updateMatrixWorld(true);
-      this.updateConnectorPositionInSceneData(movingConnector, targetWorldPos, activeSegment);
-      var stationaryLocalPos = activeSegment.worldToLocal(stationaryWorldPos.clone());
-      stationaryConnector.position.copy(stationaryLocalPos);
-      stationaryConnector.updateMatrixWorld(true);
-      this.updateConnectorPositionInSceneData(stationaryConnector, stationaryWorldPos, activeSegment);
-      console.log("\u2705 Active segment extended successfully to physically connect with target");
     }
   }]);
 }();
@@ -25107,6 +25228,7 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
         gatewayMesh.uuid = gateway.id;
 
         // Set userData to make gateways selectable
+        // Note: No 'direction' attribute - gateways don't need it
         gatewayMesh.userData = {
           objectType: 'gateway',
           isDeclared: false,
@@ -25234,6 +25356,11 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
           var fromIsComponentConnector = pathData.fromObjectType === 'component-connector';
           var toIsComponentConnector = pathData.toObjectType === 'component-connector';
 
+          // Check if endpoints have direction constraints (more accurate for immutability)
+          // Segments adjacent to connectors with direction should be immutable
+          var fromHasDirection = pathData.fromHasDirection !== undefined ? pathData.fromHasDirection : fromIsComponentConnector;
+          var toHasDirection = pathData.toHasDirection !== undefined ? pathData.toHasDirection : toIsComponentConnector;
+
           // Create one cylinder per segment (after colinear optimization, this should be minimal segments)
           for (var j = 0; j < pathPoints.length - 1; j++) {
             var start = pathPoints[j];
@@ -25262,10 +25389,12 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             // Make pipe segments selectable and add identifying data
             var segmentId = cylinder.uuid;
 
-            // Determine if this segment should be immutable (first or last 0.5-unit segment connected to component)
+            // Determine if this segment should be immutable (first or last segment connected to connector with direction)
+            // Segments adjacent to connectors with direction constraints are immutable (cannot be edited)
+            // Segments adjacent to gateways (no direction) can be edited
             var isFirstSegment = j === 0;
             var isLastSegment = j === pathPoints.length - 2;
-            var isImmutable = fromIsComponentConnector && isFirstSegment || toIsComponentConnector && isLastSegment;
+            var isImmutable = fromHasDirection && isFirstSegment || toHasDirection && isLastSegment;
 
             // Add userData to make pipe segments selectable and for tooltip display
             cylinder.userData = {
@@ -25287,7 +25416,6 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, sceneViewer.scene // Pass scene instead of polyline
             );
           }
-          console.log("\u2705 Created pipe path ".concat(pathData.from, "-").concat(pathData.to, " with ").concat(pathPoints.length - 1, " segments"));
         }
       });
     }
@@ -25439,6 +25567,7 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
   }]);
 }(BaseDisposable);
 
+var _excluded$1 = ["direction"];
 var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
   function ConnectorManager(sceneViewer) {
     var _this;
@@ -25493,6 +25622,7 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
         connectorType: 'start',
         manualSegmentUuid: segment.uuid,
         isDeclared: true
+        // Note: No 'direction' attribute - manual segment connectors don't need it
       };
 
       // Add start connector as child of segment
@@ -25513,6 +25643,7 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
         connectorType: 'end',
         manualSegmentUuid: segment.uuid,
         isDeclared: true
+        // Note: No 'direction' attribute - manual segment connectors don't need it
       };
 
       // Add end connector as child of segment
@@ -25555,6 +25686,7 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
     /**
      * Add connectors to the scene and scene data
      * Note: Connectors are already children of the segment in the Three.js scene.
+     * In scene data, they are added at the root level for faster pathfinder lookups.
      * @param {Array} connectors - Array of connector objects
      */
   }, {
@@ -25565,7 +25697,7 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
         // Connectors are already children of the segment in Three.js, no need to add to scene
         console.log("\uD83D\uDD0C Connector already added as child of segment: ".concat(connector.uuid));
 
-        // Add to scene data structure as children of the segment (not at top level)
+        // Add to scene data structure at root level for faster pathfinder lookups
         if (sceneViewer.currentSceneData && sceneViewer.currentSceneData.scene) {
           // Helper function to clean up floating-point precision errors
           var cleanPosition = function cleanPosition(value) {
@@ -25573,52 +25705,17 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
             return Math.abs(value) < 1e-10 ? 0 : value;
           };
 
-          // Get world position for scene data (since connectors are now in local space)
+          // Get world position for scene data (since connectors are in local space in Three.js)
           var worldPosition = new THREE__namespace.Vector3();
           connector.getWorldPosition(worldPosition);
 
-          // Get the segment UUID from connector's userData
-          var segmentUuid = connector.userData.manualSegmentUuid;
-          if (!segmentUuid) {
-            console.warn("\u26A0\uFE0F Connector ".concat(connector.uuid, " missing manualSegmentUuid, cannot add to scene data"));
-            return;
-          }
-
-          // Find the segment in scene data
-          var _findSegment = function findSegment(children) {
-            var _iterator = _createForOfIteratorHelper(children),
-              _step;
-            try {
-              for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                var child = _step.value;
-                if (child.uuid === segmentUuid) {
-                  return child;
-                }
-                if (child.children) {
-                  var found = _findSegment(child.children);
-                  if (found) return found;
-                }
-              }
-            } catch (err) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
-            }
-            return null;
-          };
-          var segmentInSceneData = _findSegment(sceneViewer.currentSceneData.scene.children);
-          if (!segmentInSceneData) {
-            console.warn("\u26A0\uFE0F Could not find segment ".concat(segmentUuid, " in scene data for connector ").concat(connector.uuid));
-            return;
-          }
-
-          // Ensure segment has a children array in scene data
-          if (!segmentInSceneData.children) {
-            segmentInSceneData.children = [];
-          }
+          // Filter out 'direction' attribute - manual segment connectors don't need it
+          var _ref = connector.userData || {};
+            _ref.direction;
+            var cleanedUserData = _objectWithoutProperties(_ref, _excluded$1);
           var sceneDataConnector = {
             uuid: connector.uuid,
-            userData: _objectSpread2(_objectSpread2({}, connector.userData), {}, {
+            userData: _objectSpread2(_objectSpread2({}, cleanedUserData), {}, {
               isDeclared: true,
               // Mark manual segment connectors as declared
               // Position MUST be an array [x, y, z] for pathfinder compatibility
@@ -25626,9 +25723,10 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
             })
           };
 
-          // Add connector as child of segment in scene data (not at top level)
-          segmentInSceneData.children.push(sceneDataConnector);
-          console.log("\uD83D\uDD0C Added connector to scene data as child of segment ".concat(segmentUuid, ": ").concat(connector.uuid));
+          // Add connector at root level in scene data (not nested under segment)
+          // This provides faster UUID lookups for the pathfinder
+          sceneViewer.currentSceneData.scene.children.push(sceneDataConnector);
+          console.log("\uD83D\uDD0C Added connector to scene data at root level: ".concat(connector.uuid));
         } else {
           console.warn('⚠️ Could not add connector to scene data - currentSceneData not available');
         }
@@ -25637,7 +25735,8 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
 
     /**
      * Restructure connections to use the new connectors
-     * @param {string} authoritativeConnectorUUID - The authoritative connector UUID
+     * Measures distance from point-a to both connectors and connects to the nearest one
+     * @param {string} authoritativeConnectorUUID - The authoritative connector UUID (point-a)
      * @param {Array} connectors - Array of connector objects (0: start, 1: end)
      * @param {Object} currentSceneData - Current scene data
      * @param {Array<string>} convertedGatewayUUIDs - Array of gateway UUIDs that were converted to manual (optional)
@@ -25652,6 +25751,66 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
 
       console.log("\uD83D\uDD27 [restructureConnections] connectors:", JSON.parse(JSON.stringify(connectors)));
       console.log("\uD83D\uDD27 [restructureConnections] convertedGatewayUUIDs:", convertedGatewayUUIDs);
+      console.log("\uD83D\uDD27 [restructureConnections] authoritativeConnectorUUID:", authoritativeConnectorUUID);
+
+      // Find the authoritative connector object (point-a) in the scene to measure distances
+      var authoritativeObject = null;
+      this.sceneViewer.scene.traverse(function (obj) {
+        if (obj.uuid === authoritativeConnectorUUID) {
+          authoritativeObject = obj;
+        }
+      });
+      if (!authoritativeObject) {
+        console.error("\u274C [restructureConnections] Could not find authoritative connector: ".concat(authoritativeConnectorUUID));
+        console.error("\u274C [restructureConnections] This may indicate:");
+        console.error("   1. The connector UUID changed during gateway manualization");
+        console.error("   2. The original connection was removed/modified before restructuring");
+        console.error("   3. The findOriginalConnection method returned a stale connection");
+        console.error("\u274C [restructureConnections] Current connections:", JSON.stringify(currentSceneData.connections, null, 2));
+
+        // FALLBACK: Try to find any connector that might be the authoritative one
+        // Look for objects with similar UUID patterns or check the original connection endpoints
+        console.warn("\u26A0\uFE0F [restructureConnections] Attempting fallback connector search...");
+
+        // Search for possible matches (component connectors, gateway connectors, etc.)
+        var possibleMatches = [];
+        this.sceneViewer.scene.traverse(function (obj) {
+          var _obj$userData, _obj$userData2, _obj$userData3;
+          if (((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'connector' || ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.objectType) === 'segment-connector' || ((_obj$userData3 = obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.objectType) === 'gateway-connector') {
+            possibleMatches.push({
+              uuid: obj.uuid,
+              objectType: obj.userData.objectType,
+              isDeclared: obj.userData.isDeclared
+            });
+          }
+        });
+        console.warn("\u26A0\uFE0F [restructureConnections] Found ".concat(possibleMatches.length, " possible connectors:"), possibleMatches);
+        console.error("\u274C [restructureConnections] Cannot proceed without authoritative connector");
+        return;
+      }
+
+      // Get world positions for distance calculation
+      var pointA = new THREE__namespace.Vector3();
+      authoritativeObject.getWorldPosition(pointA);
+      var connector1Position = new THREE__namespace.Vector3();
+      var connector2Position = new THREE__namespace.Vector3();
+      connectors[0].getWorldPosition(connector1Position);
+      connectors[1].getWorldPosition(connector2Position);
+
+      // Calculate distances from point-a to both segment connectors
+      var distanceToConnector1 = pointA.distanceTo(connector1Position);
+      var distanceToConnector2 = pointA.distanceTo(connector2Position);
+      console.log("\uD83D\uDCCF [restructureConnections] Distance from ".concat(authoritativeConnectorUUID, " to:"));
+      console.log("   - ".concat(startConnectorUUID, ": ").concat(distanceToConnector1.toFixed(4)));
+      console.log("   - ".concat(endConnectorUUID, ": ").concat(distanceToConnector2.toFixed(4)));
+
+      // Determine which connector is nearest to point-a
+      var nearestConnector = distanceToConnector1 <= distanceToConnector2 ? connectors[0] : connectors[1];
+      var farthestConnector = distanceToConnector1 > distanceToConnector2 ? connectors[0] : connectors[1];
+      var nearestConnectorUUID = nearestConnector.uuid;
+      var farthestConnectorUUID = farthestConnector.uuid;
+      console.log("\u2705 [restructureConnections] Nearest connector: ".concat(nearestConnectorUUID, " (distance: ").concat(Math.min(distanceToConnector1, distanceToConnector2).toFixed(4), ")"));
+      console.log("\uD83D\uDCCD [restructureConnections] Farthest connector: ".concat(farthestConnectorUUID, " (distance: ").concat(Math.max(distanceToConnector1, distanceToConnector2).toFixed(4), ")"));
 
       // Deep copy connections array to prevent unintended mutations during iteration
       // Then map to update references, creating new connection objects
@@ -25660,30 +25819,32 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
 
         // Create a shallow copy of the connection object
         var updatedConnection = _objectSpread2({}, connection);
+
+        // Update connections to point to the FARTHEST connector (opposite end from point-a)
         if (connection.from === authoritativeConnectorUUID) {
-          updatedConnection.from = endConnectorUUID;
-          console.log("\u2705 [restructureConnections] Updated connection.from to ".concat(endConnectorUUID));
+          updatedConnection.from = farthestConnectorUUID;
+          console.log("\u2705 [restructureConnections] Updated connection.from to ".concat(farthestConnectorUUID, " (farthest)"));
         }
         if (connection.to === authoritativeConnectorUUID) {
-          updatedConnection.to = endConnectorUUID;
-          console.log("\u2705 [restructureConnections] Updated connection.to to ".concat(endConnectorUUID));
+          updatedConnection.to = farthestConnectorUUID;
+          console.log("\u2705 [restructureConnections] Updated connection.to to ".concat(farthestConnectorUUID, " (farthest)"));
         }
         return updatedConnection;
       });
 
       // Check if the new connection already exists to prevent duplicates
       var newConnectionExists = currentSceneData.connections.some(function (conn) {
-        return conn.from === authoritativeConnectorUUID && conn.to === startConnectorUUID || conn.from === startConnectorUUID && conn.to === authoritativeConnectorUUID;
+        return conn.from === authoritativeConnectorUUID && conn.to === nearestConnectorUUID || conn.from === nearestConnectorUUID && conn.to === authoritativeConnectorUUID;
       });
       if (!newConnectionExists) {
-        // Add new connection from authoritative connector to the segment start
+        // Add new connection from authoritative connector (point-a) to the NEAREST segment connector
         currentSceneData.connections.push({
           from: authoritativeConnectorUUID,
-          to: startConnectorUUID
+          to: nearestConnectorUUID
         });
-        console.log("\u2705 [restructureConnections] Added new connection: ".concat(authoritativeConnectorUUID, " \u2192 ").concat(startConnectorUUID));
+        console.log("\u2705 [restructureConnections] Added new connection: ".concat(authoritativeConnectorUUID, " \u2192 ").concat(nearestConnectorUUID, " (nearest)"));
       } else {
-        console.log("\u26A0\uFE0F [restructureConnections] Connection already exists, skipping: ".concat(authoritativeConnectorUUID, " \u2192 ").concat(startConnectorUUID));
+        console.log("\u26A0\uFE0F [restructureConnections] Connection already exists, skipping: ".concat(authoritativeConnectorUUID, " \u2192 ").concat(nearestConnectorUUID));
       }
 
       // Log converted gateways for tracking
@@ -25730,11 +25891,11 @@ var ConnectorManager = /*#__PURE__*/function (_BaseDisposable) {
       var fromObject = null;
       var toObject = null;
       sceneViewer.scene.traverse(function (obj) {
-        var _obj$userData, _obj$userData2;
-        if (obj.uuid === pathFrom || ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.originalUuid) === pathFrom) {
+        var _obj$userData4, _obj$userData5;
+        if (obj.uuid === pathFrom || ((_obj$userData4 = obj.userData) === null || _obj$userData4 === void 0 ? void 0 : _obj$userData4.originalUuid) === pathFrom) {
           fromObject = obj;
         }
-        if (obj.uuid === pathTo || ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.originalUuid) === pathTo) {
+        if (obj.uuid === pathTo || ((_obj$userData5 = obj.userData) === null || _obj$userData5 === void 0 ? void 0 : _obj$userData5.originalUuid) === pathTo) {
           toObject = obj;
         }
       });
@@ -26562,12 +26723,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "_executePathfinding",
     value: function () {
       var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(sceneData, connections) {
-        var _simplifiedSceneData$;
         var options,
           _options$context,
           context,
           connectionsCopy,
-          simplifiedSceneData,
+          sceneDataCopy,
           pathfindingResult,
           _args = arguments;
         return _regenerator().w(function (_context) {
@@ -26584,20 +26744,28 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
 
               // Deep copy connections to prevent pathfinder from mutating the original
               connectionsCopy = JSON.parse(JSON.stringify(connections));
-              simplifiedSceneData = JSON.parse(JSON.stringify(this.getSimplifiedSceneData())); // Take snapshot before pathfinding execution (capture Three.js scene)
-              this.snapshotManager.takeSnapshot(this.sceneViewer.scene,
-              // Pass the actual Three.js scene
-              connectionsCopy, context);
-              console.log('[Pathfinder] simplifiedSceneData length at creation:', (_simplifiedSceneData$ = simplifiedSceneData.children) === null || _simplifiedSceneData$ === void 0 ? void 0 : _simplifiedSceneData$.length);
-              console.log('[Pathfinder] simplifiedSceneData (deep clone for inspection):', JSON.parse(JSON.stringify(simplifiedSceneData)));
+              sceneDataCopy = JSON.parse(JSON.stringify(sceneData));
+              console.log("[Pathfinder] sceneDataCopy:", sceneDataCopy);
+
+              // const simplifiedSceneData = JSON.parse(JSON.stringify( this.getSimplifiedSceneData() ));
 
-              // Add debugging for pathfinder input
-              console.log('🔍 PATHFINDER DEBUGGING:');
-              console.log('🔗 [Pathfinder] Connections:', JSON.parse(JSON.stringify(connectionsCopy)));
+              // // Take snapshot before pathfinding execution (capture Three.js scene)
+              // this.snapshotManager.takeSnapshot(
+              //   this.sceneViewer.scene,  // Pass the actual Three.js scene
+              //   connectionsCopy, 
+              //   context
+              // );
+
+              // console.log('[Pathfinder] simplifiedSceneData length at creation:', simplifiedSceneData.children?.length);
+              // console.log('[Pathfinder] simplifiedSceneData (deep clone for inspection):', JSON.parse(JSON.stringify(simplifiedSceneData)));   
+
+              // // Add debugging for pathfinder input
+              // console.log('🔍 PATHFINDER DEBUGGING:');
+              // console.log('🔗 [Pathfinder] Connections:', JSON.parse(JSON.stringify(connectionsCopy))); 
 
               // Find paths using v1.0.17 API (sceneData and connections separately)
               // Pass deep copy to ensure pathfinder cannot mutate original connections
-              pathfindingResult = this.pathfinder.findPaths(simplifiedSceneData, connectionsCopy);
+              pathfindingResult = this.pathfinder.findPaths(sceneDataCopy, connectionsCopy);
               console.log('[Pathfinder] Found paths:', JSON.parse(JSON.stringify(pathfindingResult.paths)));
               console.log('Generated gateways:', JSON.parse(JSON.stringify(pathfindingResult.gateways)));
               console.log('Rewired connections:', JSON.parse(JSON.stringify(pathfindingResult.rewiredConnections)));
@@ -28034,6 +28202,8 @@ var SceneClearingUtility = /*#__PURE__*/function () {
   }]);
 }();
 
+var _excluded = ["direction"],
+  _excluded2 = ["direction"];
 var SceneOperationsManager = /*#__PURE__*/function () {
   function SceneOperationsManager(sceneViewer) {
     _classCallCheck(this, SceneOperationsManager);
@@ -28586,7 +28756,12 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         if (connectorData.position) {
           _connectorMesh.position.set(connectorData.position.x || 0, connectorData.position.y || 0, connectorData.position.z || 0);
         }
-        _connectorMesh.userData = _objectSpread2(_objectSpread2({}, connectorData.userData), {}, {
+
+        // Initialize userData (filter out 'direction' - manual segment connectors don't need it)
+        var _ref = connectorData.userData || {};
+          _ref.direction;
+          var _cleanedUserData = _objectWithoutProperties(_ref, _excluded);
+        _connectorMesh.userData = _objectSpread2(_objectSpread2({}, _cleanedUserData), {}, {
           originalUuid: connectorData.uuid,
           objectType: 'segment-connector',
           isManualSegmentConnector: true,
@@ -28605,8 +28780,11 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         connectorMesh.position.set(connectorData.position.x || 0, connectorData.position.y || 0, connectorData.position.z || 0);
       }
 
-      // Initialize userData
-      connectorMesh.userData = _objectSpread2(_objectSpread2({}, connectorData.userData), {}, {
+      // Initialize userData (filter out 'direction' - manual segment connectors don't need it)
+      var _ref2 = connectorData.userData || {};
+        _ref2.direction;
+        var cleanedUserData = _objectWithoutProperties(_ref2, _excluded2);
+      connectorMesh.userData = _objectSpread2(_objectSpread2({}, cleanedUserData), {}, {
         originalUuid: connectorData.uuid,
         objectType: 'segment-connector',
         isManualSegmentConnector: true,
@@ -29444,20 +29622,29 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       // Now add connectors to the segment's children array in scene data
       connectorManager.addConnectorsToScene(connectors);
 
-      // Find the original connection that this segment belongs to (after gateways are converted)
+      // Check and convert connected gateways to manual (declared) FIRST
+      // CRITICAL: This must happen BEFORE finding the authoritative connector
+      // because gateway conversion may modify the connections array
+      // NOTE: This may trigger path regeneration via translateGateway, so segment must already be renamed
+      var convertedGatewayUUIDs = this._convertConnectedGatewaysToManual(connectors, currentSceneData);
+      console.log('🔍 Gateway conversion completed, now finding authoritative connector with updated connections');
+
+      // Find the original connection that this segment belongs to (AFTER gateways are converted)
+      // IMPORTANT: This must run after gateway conversion because connections may have changed
       var originalConnection = connectorManager.findOriginalConnection(segment, currentSceneData.connections);
       if (!originalConnection) {
         console.warn('⚠️ Could not find original connection for segment:', segment.uuid);
+        console.warn('⚠️ This may indicate the connection was modified during gateway conversion');
+        console.warn('⚠️ Available connections:', JSON.stringify(currentSceneData.connections, null, 2));
         return;
       }
-      console.log('🔍 Found original connection:', originalConnection);
+      console.log('🔍 Found original connection (after gateway conversion):', originalConnection);
+
+      // Determine the authoritative connector (the non-gateway endpoint)
+      // After gateway conversion, gateways should have connectors, so check for "Gateway" pattern
       var authoritativeConnectorUUID = originalConnection.from.includes("Gateway") === false ? originalConnection.from : originalConnection.to;
       console.log('[SceneOperations] authoritativeConnectorUUID:', authoritativeConnectorUUID);
 
-      // Check and convert connected gateways to manual (declared)
-      // NOTE: This may trigger path regeneration via translateGateway, so segment must already be renamed
-      var convertedGatewayUUIDs = this._convertConnectedGatewaysToManual(connectors, currentSceneData);
-
       // Restructure connections, passing any converted gateway UUIDs
       connectorManager.restructureConnections(authoritativeConnectorUUID, connectors, currentSceneData, convertedGatewayUUIDs);
 
@@ -33609,7 +33796,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.51
+   * @version 0.1.53
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.