@2112-lab/central-plant 0.1.4 → 0.1.6

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

@@ -1 +1,1417 @@
-import{createClass as n,objectSpread2 as e,construct as t,toConsumableArray as r,slicedToArray as i,classCallCheck as o,createForOfIteratorHelper as a,asyncToGenerator as u,regenerator as s}from"../../../_virtual/_rollupPluginBabelHelpers.js";import*as c from"three";import{Pathfinder as l}from"../../../node_modules/@2112-lab/pathfinder/dist/index.esm.js";import{logger as f,pathfinderLogger as v}from"../../core/debugLogger.js";import{generateUuidFromName as d}from"../../core/nameUtils.js";var h=function(){return n(function n(e){o(this,n),this.sceneViewer=e,this.pathfinder=null,this.crosscubeTextureSet=null,this.pathfinderVersionInfo=null,this.pathfinderConfig={grid:{size:.5,safetyMargin:0,minSegmentLength:.5,timeout:1e3}}},[{key:"getPathfinderVersionInfo",value:(w=u(s().m(function n(){var e;return s().w(function(n){for(;;)switch(n.n){case 0:if(!this.pathfinderVersionInfo){n.n=1;break}return n.a(2,this.pathfinderVersionInfo);case 1:return e={version:"1.0.17",detectionMethod:"hardcoded-fallback",timestamp:(new Date).toISOString()},this.pathfinderVersionInfo=e,n.a(2,e)}},n,this)})),function(){return w.apply(this,arguments)})},{key:"logPathfinderVersion",value:(g=u(s().m(function n(){var e,t,r,i=arguments;return s().w(function(n){for(;;)switch(n.n){case 0:return e=i.length>0&&void 0!==i[0]?i[0]:"Unknown Context",n.p=1,n.n=2,this.getPathfinderVersionInfo();case 2:t=n.v,v.info("[".concat(e,"] Pathfinder Module Information:"),{version:t.version,detectionMethod:t.detectionMethod,context:e,timestamp:t.timestamp,pathfinderInstance:!!this.pathfinder}),n.n=4;break;case 3:n.p=3,r=n.v,v.error("[".concat(e,"] Failed to get pathfinder version:"),r);case 4:return n.a(2)}},n,this,[[1,3]])})),function(){return g.apply(this,arguments)})},{key:"getPathColor",value:function(n){var e=["#468e49","#245e29","#2e80d2","#1d51a1"];return e[n%e.length]}},{key:"_executePathfinding",value:(p=u(s().m(function n(e,t){var r,i,o,a,u,f,v,d=this,h=arguments;return s().w(function(n){for(;;)switch(n.n){case 0:return i=(r=h.length>2&&void 0!==h[2]?h[2]:{}).createGateways,o=void 0!==i&&i,a=r.context,u=void 0===a?"Pathfinding":a,n.n=1,this.logPathfinderVersion(u);case 1:return this.pathfinder=new l(this.pathfinderConfig),this.sceneViewer.pathfinder=this.pathfinder,e.object.children=e.object.children.filter(function(n){return"computed"!==n.userData.origin}),f=this.pathfinder.findPaths(e,t),o&&f.gateways&&f.gateways.forEach(function(n){if(n.position){var e=new c.Mesh(new c.SphereGeometry(.15,16,16),new c.MeshStandardMaterial({color:16777215,roughness:.7,metalness:.3,emissive:0}));e.position.copy(n.position),e.name=n.id,e.uuid=n.id,e.userData={componentType:"gateway",forExport:!0,gatewayId:n.id,originalUuid:n.id,origin:"computed",connections:n.connections},d.sceneViewer.scene.add(e)}}),v=this.mergeColinearPaths(f.paths),this.createPipePaths(v,this.crosscubeTextureSet),n.a(2,f)}},n,this)})),function(n,e){return p.apply(this,arguments)})},{key:"initializePathfinder",value:(y=u(s().m(function n(e,t){var r;return s().w(function(n){for(;;)switch(n.n){case 0:return this.crosscubeTextureSet=t,n.n=1,this.t(e.scene,e.connections,{createGateways:!0,context:"Scene Loading"});case 1:return(r=n.v).rewiredConnections,n.a(2,r)}},n,this)})),function(n,e){return y.apply(this,arguments)})},{key:"removeComputedObjects",value:function(){var n=this.sceneViewer,e=[];n.scene.traverse(function(n){if(n.name&&n.name.includes("Polyline")){var t=!1,r=[];if(n.traverse(function(n){n.userData&&n.userData.isPipeSegment&&n.userData.isManuallyPositioned&&(t=!0,r.push(n))}),t){var i=[];n.traverse(function(n){(n.userData&&n.userData.isPipeSegment&&!n.userData.isManuallyPositioned||n.userData&&n.userData.isPipeElbow)&&i.push(n)}),i.forEach(function(e){n.remove(e),e.geometry&&e.geometry.dispose(),e.material&&(Array.isArray(e.material)?e.material.forEach(function(n){return n.dispose()}):e.material.dispose())}),0===n.children.length&&e.push(n)}else e.push(n)}n.userData&&"computed"===n.userData.origin&&e.push(n)});for(var t=0,r=e;t<r.length;t++){var i=r[t];n.scene.remove(i),i.geometry&&i.geometry.dispose(),i.material&&(Array.isArray(i.material)?i.material.forEach(function(n){return n.dispose()}):i.material.dispose())}}},{key:"createPipeMaterial",value:function(n,i){if(n){var o=e(e({},n.config.materialProps),{},{color:this.getPathColor(i),map:n.textures.diffuse,normalMap:n.textures.normal,roughnessMap:n.textures.roughness,metalness:.2,roughness:.9,clearcoat:.2,clearcoatRoughness:.2,envMapIntensity:.6,reflectivity:.4});o.normalScale&&Array.isArray(o.normalScale)&&(o.normalScale=t(c.Vector2,r(o.normalScale)));var a=new c.MeshPhysicalMaterial(o);return[a.map,a.normalMap,a.roughnessMap].filter(Boolean).forEach(function(e){e.wrapS=e.wrapT=c.RepeatWrapping,e.repeat.set(2*n.config.repeat.x,2*n.config.repeat.y)}),a}return new c.MeshPhysicalMaterial({color:this.getPathColor(i),metalness:.9,roughness:.7,clearcoat:.1,clearcoatRoughness:.3,envMapIntensity:1.5,reflectivity:.3})}},{key:"createPipePaths",value:function(n,e){var t=this,r=this.sceneViewer;n.forEach(function(n,i){if(n.path&&n.path.length>=2){var o=new c.Object3D;o.name="Polyline ".concat(n.from,"-").concat(n.to);for(var a=t.createPipeMaterial(e,i),u=n.path.map(function(n){return n instanceof c.Vector3?n.clone():Array.isArray(n)?(new c.Vector3).fromArray(n):void 0!==n.x&&void 0!==n.y&&void 0!==n.z?new c.Vector3(n.x,n.y,n.z):new c.Vector3(0,0,0)}),s=function(e){var s=u[e],l=u[e+1],f=(new c.Vector3).subVectors(l,s),v=f.length();if(v<1e-6)return 0;var d=!1;if(r.scene.traverse(function(t){t.userData&&t.userData.isPipeSegment&&t.userData.isManuallyPositioned&&t.userData.segmentId==="pipe-segment-".concat(n.from,"-").concat(n.to,"-").concat(e)&&(d=!0)}),d)return 0;var h=new c.CylinderGeometry(.1,.1,v,8,1,!1),m=new c.Mesh(h,a);m.position.copy(s).add(l).multiplyScalar(.5);var y=new c.Quaternion,p=new c.Vector3(0,1,0);y.setFromUnitVectors(p,f.clone().normalize()),m.quaternion.copy(y),m.castShadow=!0,m.receiveShadow=!0;var g="pipe-segment-".concat(n.from,"-").concat(n.to,"-").concat(e);if(m.name="Pipe Segment ".concat(e+1,": ").concat(n.from,"-").concat(n.to),m.userData={isPipeSegment:!0,segmentId:g,segmentIndex:e,pathFrom:n.from,pathTo:n.to,pathIndex:i,length:v.toFixed(2),component:{type:"PipeSegment",attributes:{length:{key:"Length",value:v.toFixed(2),unit:"m"}}}},o.add(m),e<u.length-2){var w=u[e+1].clone().sub(u[e]).normalize(),k=u[e+2].clone().sub(u[e+1]).normalize(),x=w.angleTo(k);if(x>Math.PI/36){var P=t.createElbowGeometry(u[e],u[e+1],u[e+2],.1);if(P){var S=new c.Mesh(P,a);S.castShadow=!0,S.receiveShadow=!0;var b="pipe-elbow-".concat(n.from,"-").concat(n.to,"-").concat(e);S.name="Pipe Elbow ".concat(e+1,": ").concat(n.from,"-").concat(n.to),S.userData={isPipeElbow:!0,elbowId:b,elbowIndex:e,pathFrom:n.from,pathTo:n.to,pathIndex:i,angle:(180*x/Math.PI).toFixed(1),component:{type:"PipeElbow",attributes:{angle:{key:"Bend Angle",value:(180*x/Math.PI).toFixed(1),unit:"°"}}}},o.add(S)}}}},l=0;l<u.length-1;l++)s(l);o.name="Polyline",r.scene.add(o)}})}},{key:"handleManualSegmentTransformation",value:function(n,e){if(n&&n.userData&&n.userData.isPipeSegment){var t=this.calculateSegmentEndpoints(n),r=this.createSegmentConnectors(n,t);this.addConnectorsToScene(r),this.convertConnectedGatewaysToManual(r,e);var i=this.findOriginalConnection(n,e.connections);i&&(this.restructureConnections(i,r,e),n.userData.isManuallyPositioned=!0,n.userData.manualConnectors=r.map(function(n){return n.uuid}),this.addManualSegmentToSceneData(n))}}},{key:"convertConnectedGatewaysToManual",value:function(n,e){var t,r,i=this,o=this.sceneViewer,a=[],u=null!==(t=n[0])&&void 0!==t&&null!==(t=t.userData)&&void 0!==t&&t.manualSegmentUuid?o.scene.getObjectByProperty("uuid",n[0].userData.manualSegmentUuid):null;u&&null!==(r=u.userData)&&void 0!==r&&r.isPipeSegment&&([u.userData.pathFrom,u.userData.pathTo].forEach(function(n){var t,r,u=null;(o.scene.traverse(function(e){var t;e.uuid!==n&&(null===(t=e.userData)||void 0===t?void 0:t.originalUuid)!==n||(u=e)}),u)&&("gateway"===(null===(t=u.userData)||void 0===t?void 0:t.componentType)&&"computed"===(null===(r=u.userData)||void 0===r?void 0:r.origin)&&(i.convertGatewayToManual(u,e),a.push(u)))}),a.length)}},{key:"convertGatewayToManual",value:function(n,e){var t;n.userData.origin="declared";for(var r=0;r<e.scene.object.children.length;r++){var i,o,a=e.scene.object.children[r];if(a.uuid===n.uuid||a.uuid===(null===(i=n.userData)||void 0===i?void 0:i.originalUuid)||n.uuid===(null===(o=a.userData)||void 0===o?void 0:o.originalUuid)){a.userData||(a.userData={}),a.userData.origin="declared";break}}if(null!==(t=n.userData)&&void 0!==t&&t.connections&&e.connections){var u=n.userData.connections,s=e.connections;u.removed&&Array.isArray(u.removed)&&(e.connections=s.filter(function(n){var e=u.removed.some(function(e){return e.from===n.from&&e.to===n.to||e.from===n.to&&e.to===n.from});return!e})),u.added&&Array.isArray(u.added)&&u.added.forEach(function(n){e.connections.some(function(e){return e.from===n.from&&e.to===n.to||e.from===n.to&&e.to===n.from})||e.connections.push(n)})}}},{key:"findOriginalConnection",value:function(n,e){var t=n.userData,r=t.pathFrom,i=t.pathTo,o=e.find(function(n){return n.from===r&&n.to===i||n.from===i&&n.to===r});if(o)return o;var a=this.sceneViewer,u=null,s=null;if(a.scene.traverse(function(n){var e,t;n.uuid!==r&&(null===(e=n.userData)||void 0===e?void 0:e.originalUuid)!==r||(u=n),n.uuid!==i&&(null===(t=n.userData)||void 0===t?void 0:t.originalUuid)!==i||(s=n)}),u&&s&&(o=e.find(function(n){return n.from===u.uuid&&n.to===s.uuid||n.from===s.uuid&&n.to===u.uuid})))return o;var c=e.filter(function(n){var e,t,o=n.from===r||n.from===i,u=n.to===r||n.to===i,s="gateway"===(null===(e=a.scene.getObjectByProperty("uuid",n.from))||void 0===e||null===(e=e.userData)||void 0===e?void 0:e.componentType),c="gateway"===(null===(t=a.scene.getObjectByProperty("uuid",n.to))||void 0===t||null===(t=t.userData)||void 0===t?void 0:t.componentType);return o||u||s||c});return c.length>0?c[0]:null}},{key:"calculateSegmentEndpoints",value:function(n){var e=n.geometry.parameters.height||1,t=new c.Vector3,r=new c.Vector3,i=new c.Vector3(0,1,0);return i.applyQuaternion(n.quaternion),t.copy(n.position).sub(i.clone().multiplyScalar(e/2)),r.copy(n.position).add(i.clone().multiplyScalar(e/2)),{start:t,end:r}}},{key:"createSegmentConnectors",value:function(n,e){var t=n.userData.segmentId,r=[],i=new c.Mesh(new c.SphereGeometry(.2,16,16),new c.MeshStandardMaterial({color:65280,roughness:.7,metalness:.3,emissive:13056}));i.position.copy(e.start),i.uuid="".concat(t,"-connector-start"),i.name="Manual Segment Start Connector: ".concat(n.name),i.userData={componentType:"connector",forExport:!0,isManualSegmentConnector:!0,segmentId:t,connectorType:"start",manualSegmentUuid:n.uuid};var o=new c.Mesh(new c.SphereGeometry(.2,16,16),new c.MeshStandardMaterial({color:16711680,roughness:.7,metalness:.3,emissive:3342336}));return o.position.copy(e.end),o.uuid="".concat(t,"-connector-end"),o.name="Manual Segment End Connector: ".concat(n.name),o.userData={componentType:"connector",forExport:!0,isManualSegmentConnector:!0,segmentId:t,connectorType:"end",manualSegmentUuid:n.uuid},r.push(i,o),r}},{key:"addConnectorsToScene",value:function(n){var t=this.sceneViewer;n.forEach(function(n){if(t.scene.add(n),t.currentSceneData&&t.currentSceneData.scene&&t.currentSceneData.scene.object){var r={uuid:n.uuid,name:n.name,type:n.type,userData:e({},n.userData),position:{x:n.position.x,y:n.position.y,z:n.position.z},rotation:{x:n.rotation.x,y:n.rotation.y,z:n.rotation.z},scale:{x:n.scale.x,y:n.scale.y,z:n.scale.z},geometry:"CONNECTOR-GEO"};t.currentSceneData.scene.object.children.push(r)}})}},{key:"addManualSegmentToSceneData",value:function(n){var t=this.sceneViewer;if(t.currentSceneData&&t.currentSceneData.scene&&t.currentSceneData.scene.object){var r={uuid:n.uuid,name:n.name,type:n.type,userData:e({},n.userData),position:{x:n.position.x,y:n.position.y,z:n.position.z},rotation:{x:n.rotation.x,y:n.rotation.y,z:n.rotation.z},scale:{x:n.scale.x,y:n.scale.y,z:n.scale.z}};t.currentSceneData.scene.object.children.push(r)}}},{key:"restructureConnections",value:function(n,e,t){var o=i(e,2),a=o[0],u=o[1],s=t.connections.findIndex(function(e){return e.from===n.from&&e.to===n.to||e.from===n.to&&e.to===n.from});if(-1!==s){t.connections.splice(s,1);var c={from:n.from,to:a.uuid},l={from:u.uuid,to:n.to};t.connections.push(c,l),this.sceneViewer.currentSceneData&&(this.sceneViewer.currentSceneData.connections=r(t.connections))}}},{key:"createElbowGeometry",value:function(n,e,t,r){try{var i=3*r,o=this.createElbowCurve(n,e,t,i);return new c.TubeGeometry(o,12,r,8,!1)}catch(n){return null}}},{key:"createElbowCurve",value:function(n,e,t,r){var i=e.clone().sub(n).normalize(),o=t.clone().sub(e).normalize(),a=.001*r,u=e.clone().sub(i.clone().multiplyScalar(a)),s=e.clone().add(o.clone().multiplyScalar(a)),l=e.clone();return new c.QuadraticBezierCurve3(u,l,s)}},{key:"recomputeWorldBoundingBoxes",value:function(n){this.sceneViewer.scene.traverse(function(e){if(e.isMesh){var t=null,r=function(n){var t,i=a(n);try{for(i.s();!(t=i.n()).done;){var o,u,s=t.value;if(s.uuid===e.uuid||s.uuid===(null===(o=e.userData)||void 0===o?void 0:o.originalUuid)||e.uuid===(null===(u=s.userData)||void 0===u?void 0:u.originalUuid))return s;if(e.name&&s.name){var c=d(e.name),l=d(s.name);if(c===l||c===s.uuid||l===e.uuid)return s}if(e.name&&s.name&&e.name===s.name)return s;if(s.children){var f=r(s.children);if(f)return f}}}catch(n){i.e(n)}finally{i.f()}return null};if(t=r(n.scene.object.children)){var i=(new c.Box3).setFromObject(e);t.userData||(t.userData={}),t.userData.worldBoundingBox={min:i.min.toArray(),max:i.max.toArray()},t.userData.origin||(t.userData.origin=e.userData.origin),t.userData.direction||(t.userData.direction=e.userData.direction),t.userData.group||(t.userData.group=e.userData.group),t.userData.connections||(t.userData.connections=e.userData.connections),e.userData.associatedJsonObject=t}}})}},{key:"updatePathfindingWithConnections",value:(m=u(s().m(function n(e){var t,i;return s().w(function(n){for(;;)switch(n.n){case 0:if((t=this.sceneViewer).currentSceneData){n.n=1;break}return n.a(2,!1);case 1:return this.removeComputedObjects(),(i=JSON.parse(JSON.stringify(t.currentSceneData))).connections=r(e),n.n=2,this.t(i.scene,i.connections,{createGateways:!1,context:"Connections Update"});case 2:return t.currentSceneData=i,n.a(2,!0)}},n,this)})),function(n){return m.apply(this,arguments)})},{key:"updatePathfindingAfterTransform",value:(h=u(s().m(function n(e){return s().w(function(n){for(;;)switch(n.n){case 0:return this.removeComputedObjects(),n.n=1,this.t(e.scene,e.connections,{createGateways:!0,context:"Transform Update"});case 1:return n.a(2)}},n,this)})),function(n){return h.apply(this,arguments)})},{key:"dispose",value:function(){this.removeComputedObjects(),this.pathfinder=null,this.crosscubeTextureSet=null,this.pathfinderVersionInfo=null,f.info("PathfindingManager disposed")}},{key:"mergeColinearPaths",value:function(n){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:.001,t=JSON.parse(JSON.stringify(n));return t.forEach(function(n){if(n.path&&!(n.path.length<=2)){var t=n.path.map(function(n){return n instanceof c.Vector3?n.clone():Array.isArray(n)?(new c.Vector3).fromArray(n):void 0!==n.x&&void 0!==n.y&&void 0!==n.z?new c.Vector3(n.x,n.y,n.z):new c.Vector3(0,0,0)});if(!(t.length<=2)){for(var r=[t[0]],i=0,o=function(){var n=t[i],o=t[i+1],a=(new c.Vector3).subVectors(o,n);if(a.length()<1e-6)return i++,1;a.normalize();for(var u=i+2;u<t.length;){var s=t[u],l=(new c.Vector3).subVectors(s,n);if(l.length()<1e-6)u++;else{l.normalize();var f=a.dot(l);if(!(Math.abs(f-1)<e))break;o=s,u++}}o.equals(n)||r.push(o);var v=t.findIndex(function(n,e){return e>i&&n.equals(o)});-1===v?i++:i=v};i<t.length-1;)o();var a=r.map(function(e){return Array.isArray(n.path[0])?[e.x,e.y,e.z]:void 0!==n.path[0].x?{x:e.x,y:e.y,z:e.z}:e});n.path=a;t.length,r.length}}}),t}}]);var h,m,y,p,g,w}();export{h as PathfindingManager};
+import { createClass as _createClass, objectSpread2 as _objectSpread2, construct as _construct, toConsumableArray as _toConsumableArray, slicedToArray as _slicedToArray, classCallCheck as _classCallCheck, createForOfIteratorHelper as _createForOfIteratorHelper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { Pathfinder } from '../../../node_modules/@2112-lab/pathfinder/dist/index.esm.js';
+import { logger, pathfinderLogger } from '../../core/debugLogger.js';
+import { generateUuidFromName } from '../../core/nameUtils.js';
+
+var PathfindingManager = /*#__PURE__*/function () {
+  function PathfindingManager(sceneViewer) {
+    _classCallCheck(this, PathfindingManager);
+    this.sceneViewer = sceneViewer;
+    this.pathfinder = null;
+    this.crosscubeTextureSet = null;
+    this.pathfinderVersionInfo = null;
+    // Configuration for pathfinder grid
+    this.pathfinderConfig = {
+      grid: {
+        size: 0.5,
+        safetyMargin: 0,
+        minSegmentLength: 0.5,
+        timeout: 1000
+      }
+    };
+  }
+
+  /**
+   * Get pathfinder version information
+   */
+  return _createClass(PathfindingManager, [{
+    key: "getPathfinderVersionInfo",
+    value: (function () {
+      var _getPathfinderVersionInfo = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var versionInfo;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (!this.pathfinderVersionInfo) {
+                _context.n = 1;
+                break;
+              }
+              return _context.a(2, this.pathfinderVersionInfo);
+            case 1:
+              versionInfo = {
+                version: '1.0.17',
+                detectionMethod: 'hardcoded-fallback',
+                timestamp: new Date().toISOString()
+              };
+              this.pathfinderVersionInfo = versionInfo;
+              return _context.a(2, versionInfo);
+          }
+        }, _callee, this);
+      }));
+      function getPathfinderVersionInfo() {
+        return _getPathfinderVersionInfo.apply(this, arguments);
+      }
+      return getPathfinderVersionInfo;
+    }()
+    /**
+     * Log pathfinder version information
+     */
+    )
+  }, {
+    key: "logPathfinderVersion",
+    value: (function () {
+      var _logPathfinderVersion = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var context,
+          versionInfo,
+          _args2 = arguments,
+          _t;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              context = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : 'Unknown Context';
+              _context2.p = 1;
+              _context2.n = 2;
+              return this.getPathfinderVersionInfo();
+            case 2:
+              versionInfo = _context2.v;
+              pathfinderLogger.info("[".concat(context, "] Pathfinder Module Information:"), {
+                version: versionInfo.version,
+                detectionMethod: versionInfo.detectionMethod,
+                context: context,
+                timestamp: versionInfo.timestamp,
+                pathfinderInstance: !!this.pathfinder
+              });
+              _context2.n = 4;
+              break;
+            case 3:
+              _context2.p = 3;
+              _t = _context2.v;
+              pathfinderLogger.error("[".concat(context, "] Failed to get pathfinder version:"), _t);
+            case 4:
+              return _context2.a(2);
+          }
+        }, _callee2, this, [[1, 3]]);
+      }));
+      function logPathfinderVersion() {
+        return _logPathfinderVersion.apply(this, arguments);
+      }
+      return logPathfinderVersion;
+    }()
+    /**
+     * Get path colors for visual distinction
+     */
+    )
+  }, {
+    key: "getPathColor",
+    value: function getPathColor(index) {
+      var colors = ['#468e49', '#245e29', '#2e80d2', '#1d51a1'];
+      return colors[index % colors.length];
+    }
+
+    /**
+     * Core pathfinding logic shared across initialization and updates
+     */
+  }, {
+    key: "_executePathfinding",
+    value: (function () {
+      var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(sceneData, connections) {
+        var _this = this;
+        var options,
+          _options$createGatewa,
+          createGateways,
+          _options$context,
+          context,
+          pathfindingResult,
+          optimizedPaths,
+          _args3 = arguments;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              options = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {};
+              _options$createGatewa = options.createGateways, createGateways = _options$createGatewa === void 0 ? false : _options$createGatewa, _options$context = options.context, context = _options$context === void 0 ? 'Pathfinding' : _options$context; // Log pathfinder version information
+              _context3.n = 1;
+              return this.logPathfinderVersion(context);
+            case 1:
+              // Create pathfinder instance with configuration only
+              this.pathfinder = new Pathfinder(this.pathfinderConfig);
+              this.sceneViewer.pathfinder = this.pathfinder;
+
+              // Add debugging for pathfinder input
+              if (context === 'Scene Loading') {
+                console.log('🔍 PATHFINDER DEBUGGING:');
+                console.log('🔗 Connections:', connections);
+                console.log('🏗️ Scene structure:', JSON.parse(JSON.stringify(sceneData.object)));
+              }
+
+              // Remove from sceneData objects that are origin: computed
+              sceneData.object.children = sceneData.object.children.filter(function (child) {
+                return child.userData.origin !== 'computed';
+              });
+
+              // Add debugging for pathfinder input
+              console.log('🔍 PATHFINDER DEBUGGING:');
+              console.log('🔗 Connections:', JSON.parse(JSON.stringify(connections)));
+              console.log('🏗️ Scene structure:', JSON.parse(JSON.stringify(sceneData.object)));
+
+              // Find paths using v1.0.17 API (scene and connections separately)
+              pathfindingResult = this.pathfinder.findPaths(sceneData, connections);
+              console.log('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)));
+
+              // Create gateways in the scene if requested
+              if (createGateways && pathfindingResult.gateways) {
+                pathfindingResult.gateways.forEach(function (gateway) {
+                  if (gateway.position) {
+                    // Create gateway mesh using shared geometry and material
+                    var gatewayMesh = new THREE.Mesh(new THREE.SphereGeometry(0.15, 16, 16), new THREE.MeshStandardMaterial({
+                      color: 0xFFFFFF,
+                      roughness: 0.7,
+                      metalness: 0.3,
+                      emissive: 0
+                    }));
+                    gatewayMesh.position.copy(gateway.position);
+                    gatewayMesh.name = gateway.id;
+                    gatewayMesh.uuid = gateway.id;
+
+                    // Set userData to make gateways selectable
+                    gatewayMesh.userData = {
+                      componentType: 'gateway',
+                      forExport: true,
+                      gatewayId: gateway.id,
+                      originalUuid: gateway.id,
+                      origin: 'computed',
+                      connections: gateway.connections
+                    };
+
+                    // Add to scene using editor command
+                    _this.sceneViewer.scene.add(gatewayMesh);
+                    console.log("\uD83D\uDD27 Created selectable gateway: ".concat(gateway.id, " with componentType='gateway'"));
+                  }
+                });
+              }
+              console.log("pathfindingResult.paths:", pathfindingResult.paths);
+
+              // Preprocess paths to merge colinear segments
+              optimizedPaths = this.mergeColinearPaths(pathfindingResult.paths);
+              console.log('Path optimization complete. Creating pipe paths...');
+
+              // Create pipe paths with materials using the optimized paths
+              this.createPipePaths(optimizedPaths, this.crosscubeTextureSet);
+              return _context3.a(2, pathfindingResult);
+          }
+        }, _callee3, this);
+      }));
+      function _executePathfinding(_x, _x2) {
+        return _executePathfinding2.apply(this, arguments);
+      }
+      return _executePathfinding;
+    }()
+    /**
+     * Initialize pathfinder and create paths
+     */
+    )
+  }, {
+    key: "initializePathfinder",
+    value: (function () {
+      var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(data, crosscubeTextureSet) {
+        var pathfindingResult;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              this.crosscubeTextureSet = crosscubeTextureSet;
+
+              // Use shared pathfinding logic with gateway creation enabled
+              _context4.n = 1;
+              return this._executePathfinding(data.scene, data.connections, {
+                createGateways: true,
+                context: 'Scene Loading'
+              });
+            case 1:
+              pathfindingResult = _context4.v;
+              // Update connections with rewired connections
+              if (pathfindingResult.rewiredConnections) {
+                // data.connections = pathfindingResult.rewiredConnections;
+                console.log('🔄 Updated connections with rewired connections:', data.connections);
+              }
+
+              // Return full result for potential additional processing
+              return _context4.a(2, pathfindingResult);
+          }
+        }, _callee4, this);
+      }));
+      function initializePathfinder(_x3, _x4) {
+        return _initializePathfinder.apply(this, arguments);
+      }
+      return initializePathfinder;
+    }()
+    /**
+     * Remove all computed objects from the scene (polyline paths and gateways)
+     */
+    )
+  }, {
+    key: "removeComputedObjects",
+    value: function removeComputedObjects() {
+      var component = this.sceneViewer;
+      console.log("removeComputedObjects started");
+      var objectsToRemove = [];
+      component.scene.traverse(function (obj) {
+        // Check the name property instead of uuid, as UUIDs are auto-generated
+        if (obj.name && obj.name.includes("Polyline")) {
+          console.log("removeComputedObjects ".concat(obj.name, " (uuid: ").concat(obj.uuid, ") found"));
+
+          // Check if this polyline contains manually transformed segments
+          var hasManualSegments = false;
+          var manualSegments = [];
+          obj.traverse(function (child) {
+            if (child.userData && child.userData.isPipeSegment && child.userData.isManuallyPositioned) {
+              hasManualSegments = true;
+              manualSegments.push(child);
+              console.log("\uD83D\uDD12 Found manually positioned pipe segment: ".concat(child.name));
+            }
+          });
+          if (!hasManualSegments) {
+            // No manual segments, remove the entire polyline
+            objectsToRemove.push(obj);
+          } else {
+            // Has manual segments, preserve only the manual ones and remove the rest
+            console.log("\uD83D\uDD12 Processing polyline with ".concat(manualSegments.length, " manual segments: ").concat(obj.name));
+
+            // Remove non-manual segments and elbows from the polyline
+            var segmentsToRemove = [];
+            obj.traverse(function (child) {
+              if (child.userData && child.userData.isPipeSegment && !child.userData.isManuallyPositioned) {
+                segmentsToRemove.push(child);
+                console.log("\uD83D\uDDD1\uFE0F Marking non-manual segment for removal: ".concat(child.name));
+              } else if (child.userData && child.userData.isPipeElbow) {
+                segmentsToRemove.push(child);
+                console.log("\uD83D\uDDD1\uFE0F Marking pipe elbow for removal: ".concat(child.name));
+              }
+            });
+
+            // Remove the non-manual segments
+            segmentsToRemove.forEach(function (segment) {
+              obj.remove(segment);
+              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();
+                }
+              }
+              console.log("\uD83D\uDDD1\uFE0F Removed non-manual segment: ".concat(segment.name));
+            });
+
+            // If the polyline is now empty, remove it too
+            if (obj.children.length === 0) {
+              objectsToRemove.push(obj);
+              console.log("\uD83D\uDDD1\uFE0F Polyline is now empty, marking for removal: ".concat(obj.name));
+            } else {
+              console.log("\uD83D\uDD12 Preserved polyline with ".concat(obj.children.length, " manual segments: ").concat(obj.name));
+            }
+          }
+        }
+        // Also remove objects with computed origin (like gateways)
+        if (obj.userData && obj.userData.origin === 'computed') {
+          console.log("removeComputedObjects computed object ".concat(obj.name || obj.type, " (uuid: ").concat(obj.uuid, ") found"));
+          objectsToRemove.push(obj);
+        }
+      });
+      for (var _i = 0, _objectsToRemove = objectsToRemove; _i < _objectsToRemove.length; _i++) {
+        var obj = _objectsToRemove[_i];
+        component.scene.remove(obj);
+        if (obj.geometry) obj.geometry.dispose();
+        if (obj.material) {
+          if (Array.isArray(obj.material)) {
+            obj.material.forEach(function (mat) {
+              return mat.dispose();
+            });
+          } else {
+            obj.material.dispose();
+          }
+        }
+      }
+      console.log("\u2705 Removed ".concat(objectsToRemove.length, " objects from scene (polylines and computed objects)"));
+    }
+
+    /**
+     * Material factory function to reduce duplication
+     */
+  }, {
+    key: "createPipeMaterial",
+    value: function createPipeMaterial(crosscubeTextureSet, pathIndex) {
+      if (crosscubeTextureSet) {
+        var materialProps = _objectSpread2(_objectSpread2({}, crosscubeTextureSet.config.materialProps), {}, {
+          color: this.getPathColor(pathIndex),
+          map: crosscubeTextureSet.textures.diffuse,
+          normalMap: crosscubeTextureSet.textures.normal,
+          roughnessMap: crosscubeTextureSet.textures.roughness,
+          metalness: 0.2,
+          roughness: 0.9,
+          clearcoat: 0.2,
+          clearcoatRoughness: 0.2,
+          envMapIntensity: 0.6,
+          reflectivity: 0.4
+        });
+
+        // Handle normalScale conversion to Vector2
+        if (materialProps.normalScale && Array.isArray(materialProps.normalScale)) {
+          materialProps.normalScale = _construct(THREE.Vector2, _toConsumableArray(materialProps.normalScale));
+        }
+        var material = new THREE.MeshPhysicalMaterial(materialProps);
+
+        // Configure texture wrapping and repeat
+        var pipeTextures = [material.map, material.normalMap, material.roughnessMap].filter(Boolean);
+        pipeTextures.forEach(function (texture) {
+          texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+          texture.repeat.set(crosscubeTextureSet.config.repeat.x * 2, crosscubeTextureSet.config.repeat.y * 2);
+        });
+        return material;
+      } else {
+        return new THREE.MeshPhysicalMaterial({
+          color: this.getPathColor(pathIndex),
+          metalness: 0.9,
+          roughness: 0.7,
+          clearcoat: 0.1,
+          clearcoatRoughness: 0.3,
+          envMapIntensity: 1.5,
+          reflectivity: 0.3
+        });
+      }
+    }
+
+    /**
+     * Helper function to create pipe paths
+     */
+  }, {
+    key: "createPipePaths",
+    value: function createPipePaths(paths, crosscubeTextureSet) {
+      var _this2 = this;
+      var component = this.sceneViewer;
+      paths.forEach(function (pathData, index) {
+        if (pathData.path && pathData.path.length >= 2) {
+          var polyline = new THREE.Object3D();
+          polyline.name = "Polyline ".concat(pathData.from, "-").concat(pathData.to);
+          var pipeRadius = 0.1;
+          var pipeMaterial = _this2.createPipeMaterial(crosscubeTextureSet, index);
+
+          // Convert path points to Vector3 objects for consistent handling
+          var pathPoints = pathData.path.map(function (point) {
+            if (point instanceof THREE.Vector3) {
+              return point.clone();
+            } else if (Array.isArray(point)) {
+              return new THREE.Vector3().fromArray(point);
+            } else if (point.x !== undefined && point.y !== undefined && point.z !== undefined) {
+              return new THREE.Vector3(point.x, point.y, point.z);
+            } else {
+              console.warn('Unknown point format in createPipePaths:', point);
+              return new THREE.Vector3(0, 0, 0);
+            }
+          });
+
+          // Create one cylinder per segment (after colinear optimization, this should be minimal segments)
+          var _loop = function _loop(j) {
+              var start = pathPoints[j];
+              var end = pathPoints[j + 1];
+              var direction = new THREE.Vector3().subVectors(end, start);
+              var length = direction.length();
+
+              // Skip zero-length segments
+              if (length < 1e-6) {
+                console.warn("Skipping zero-length segment in path ".concat(pathData.from, "-").concat(pathData.to));
+                return 0; // continue
+              }
+
+              // Check if this segment has been manually positioned
+              var isManuallyPositioned = false;
+              component.scene.traverse(function (sceneObj) {
+                if (sceneObj.userData && sceneObj.userData.isPipeSegment && sceneObj.userData.isManuallyPositioned) {
+                  if (sceneObj.userData.segmentId === "pipe-segment-".concat(pathData.from, "-").concat(pathData.to, "-").concat(j)) {
+                    isManuallyPositioned = true;
+                  }
+                }
+              });
+              if (isManuallyPositioned) {
+                console.log("\uD83D\uDD12 Skipping segment creation for manually positioned segment: ".concat(pathData.from, "-").concat(pathData.to, " segment ").concat(j));
+                return 0; // continue
+              }
+              var cylinderGeometry = new THREE.CylinderGeometry(pipeRadius, pipeRadius, length, 8, 1, false);
+              var cylinder = new THREE.Mesh(cylinderGeometry, pipeMaterial);
+              cylinder.position.copy(start).add(end).multiplyScalar(0.5);
+              var quaternion = new THREE.Quaternion();
+              var up = new THREE.Vector3(0, 1, 0);
+              quaternion.setFromUnitVectors(up, direction.clone().normalize());
+              cylinder.quaternion.copy(quaternion);
+              cylinder.castShadow = true;
+              cylinder.receiveShadow = true;
+
+              // Make pipe segments selectable and add identifying data
+              var segmentId = "pipe-segment-".concat(pathData.from, "-").concat(pathData.to, "-").concat(j);
+              cylinder.name = "Pipe Segment ".concat(j + 1, ": ").concat(pathData.from, "-").concat(pathData.to);
+
+              // Add userData to make pipe segments selectable and for tooltip display
+              cylinder.userData = {
+                isPipeSegment: true,
+                segmentId: segmentId,
+                segmentIndex: j,
+                pathFrom: pathData.from,
+                pathTo: pathData.to,
+                pathIndex: index,
+                length: length.toFixed(2),
+                // Add component data structure for tooltips
+                component: {
+                  type: 'PipeSegment',
+                  attributes: {
+                    length: {
+                      key: 'Length',
+                      value: length.toFixed(2),
+                      unit: 'm'
+                    }
+                    // connection: {
+                    //   key: 'Connection',
+                    //   value: `${pathData.from} → ${pathData.to}`
+                    // }
+                  }
+                }
+              };
+              polyline.add(cylinder);
+
+              // Add smooth elbow joints only at actual direction changes (not at every point)
+              if (j < pathPoints.length - 2) {
+                var currentSegment = pathPoints[j + 1].clone().sub(pathPoints[j]).normalize();
+                var nextSegment = pathPoints[j + 2].clone().sub(pathPoints[j + 1]).normalize();
+
+                // Check if there's actually a direction change (not just continuing straight)
+                var angle = currentSegment.angleTo(nextSegment);
+                var minAngle = Math.PI / 36; // 5 degrees minimum for creating an elbow
+
+                if (angle > minAngle) {
+                  var elbowGeometry = _this2.createElbowGeometry(pathPoints[j], pathPoints[j + 1], pathPoints[j + 2], pipeRadius);
+                  if (elbowGeometry) {
+                    var elbow = new THREE.Mesh(elbowGeometry, pipeMaterial);
+                    elbow.castShadow = true;
+                    elbow.receiveShadow = true;
+
+                    // Make elbows selectable as well
+                    var elbowId = "pipe-elbow-".concat(pathData.from, "-").concat(pathData.to, "-").concat(j);
+                    elbow.name = "Pipe Elbow ".concat(j + 1, ": ").concat(pathData.from, "-").concat(pathData.to);
+
+                    // Add userData for elbows too
+                    elbow.userData = {
+                      isPipeElbow: true,
+                      elbowId: elbowId,
+                      elbowIndex: j,
+                      pathFrom: pathData.from,
+                      pathTo: pathData.to,
+                      pathIndex: index,
+                      angle: (angle * 180 / Math.PI).toFixed(1),
+                      // Add component data for tooltips
+                      component: {
+                        type: 'PipeElbow',
+                        attributes: {
+                          angle: {
+                            key: 'Bend Angle',
+                            value: (angle * 180 / Math.PI).toFixed(1),
+                            unit: '°'
+                          }
+                        }
+                      }
+                    };
+                    polyline.add(elbow);
+                  }
+                }
+              }
+            },
+            _ret;
+          for (var j = 0; j < pathPoints.length - 1; j++) {
+            _ret = _loop(j);
+            if (_ret === 0) continue;
+          }
+          polyline.name = "Polyline";
+          component.scene.add(polyline);
+          console.log("\u2705 Created pipe path ".concat(pathData.from, "-").concat(pathData.to, " with ").concat(pathPoints.length - 1, " segments"));
+        }
+      });
+    }
+
+    /**
+     * Handle manual segment transformation by creating connectors and restructuring connections
+     * @param {THREE.Object3D} segment - The transformed pipe segment
+     * @param {Object} currentSceneData - Current scene data with connections
+     */
+  }, {
+    key: "handleManualSegmentTransformation",
+    value: function handleManualSegmentTransformation(segment, currentSceneData) {
+      if (!segment || !segment.userData || !segment.userData.isPipeSegment) {
+        console.log('❌ Object is not a pipe segment:', {
+          isObject: !!segment,
+          hasUserData: !!(segment && segment.userData),
+          isPipeSegment: !!(segment && segment.userData && segment.userData.isPipeSegment)
+        });
+        return;
+      }
+      console.log('🔧 Handling manual segment transformation:', segment.name);
+
+      // Calculate segment endpoints in world coordinates
+      var segmentEndpoints = this.calculateSegmentEndpoints(segment);
+      console.log('📍 Segment endpoints:', segmentEndpoints);
+
+      // Create connectors at the segment endpoints
+      var connectors = this.createSegmentConnectors(segment, segmentEndpoints);
+      console.log('🔌 Created connectors:', connectors);
+
+      // Add connectors to the scene
+      this.addConnectorsToScene(connectors);
+
+      // Check and convert connected gateways to manual (declared) BEFORE finding original connection
+      this.convertConnectedGatewaysToManual(connectors, currentSceneData);
+
+      // Find the original connection that this segment belongs to (after gateways are converted)
+      var originalConnection = this.findOriginalConnection(segment, currentSceneData.connections);
+      if (!originalConnection) {
+        console.warn('⚠️ Could not find original connection for segment:', segment.name);
+        return;
+      }
+      console.log('🔍 Found original connection:', originalConnection);
+
+      // Restructure connections
+      this.restructureConnections(originalConnection, connectors, currentSceneData);
+
+      // Mark segment as manually positioned
+      segment.userData.isManuallyPositioned = true;
+      segment.userData.manualConnectors = connectors.map(function (c) {
+        return c.uuid;
+      });
+
+      // Add the manually positioned segment to scene data
+      this.addManualSegmentToSceneData(segment);
+      console.log('✅ Manual segment transformation completed');
+    }
+
+    /**
+     * Check and convert gateways at the original path endpoints to manual (declared)
+     * @param {Array} connectors - Array of connector objects (used to get segment reference)
+     * @param {Object} currentSceneData - Current scene data
+     */
+  }, {
+    key: "convertConnectedGatewaysToManual",
+    value: function convertConnectedGatewaysToManual(connectors, currentSceneData) {
+      var _connectors$,
+        _segment$userData,
+        _this3 = this;
+      console.log('🔍 Checking for connected gateways to convert to manual...');
+      var component = this.sceneViewer;
+      var convertedGateways = [];
+
+      // Get the segment from the first connector's userData
+      var segment = (_connectors$ = connectors[0]) !== null && _connectors$ !== void 0 && (_connectors$ = _connectors$.userData) !== null && _connectors$ !== void 0 && _connectors$.manualSegmentUuid ? component.scene.getObjectByProperty('uuid', connectors[0].userData.manualSegmentUuid) : null;
+      if (!segment || !((_segment$userData = segment.userData) !== null && _segment$userData !== void 0 && _segment$userData.isPipeSegment)) {
+        console.log('❌ Could not find segment for gateway conversion');
+        return;
+      }
+      var pathFrom = segment.userData.pathFrom;
+      var pathTo = segment.userData.pathTo;
+      console.log("\uD83D\uDD0D Checking original path endpoints for gateways: ".concat(pathFrom, " \u2192 ").concat(pathTo));
+
+      // Check the original path endpoints for gateways
+      [pathFrom, pathTo].forEach(function (endpointUuid) {
+        console.log("\uD83D\uDD0D Checking endpoint: ".concat(endpointUuid));
+
+        // Find the object in the scene that corresponds to this endpoint
+        var endpointObject = null;
+        component.scene.traverse(function (obj) {
+          var _obj$userData;
+          if (obj.uuid === endpointUuid || ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.originalUuid) === endpointUuid) {
+            endpointObject = obj;
+          }
+        });
+        if (endpointObject) {
+          var _endpointObject$userD, _endpointObject$userD2, _endpointObject$userD3, _endpointObject$userD4;
+          console.log("\uD83D\uDD0D Found endpoint object: ".concat(endpointObject.name, " (").concat(endpointObject.uuid, ") - componentType: ").concat((_endpointObject$userD = endpointObject.userData) === null || _endpointObject$userD === void 0 ? void 0 : _endpointObject$userD.componentType, ", origin: ").concat((_endpointObject$userD2 = endpointObject.userData) === null || _endpointObject$userD2 === void 0 ? void 0 : _endpointObject$userD2.origin));
+
+          // Check if this endpoint is a gateway that needs to be converted to manual
+          if (((_endpointObject$userD3 = endpointObject.userData) === null || _endpointObject$userD3 === void 0 ? void 0 : _endpointObject$userD3.componentType) === 'gateway' && ((_endpointObject$userD4 = endpointObject.userData) === null || _endpointObject$userD4 === void 0 ? void 0 : _endpointObject$userD4.origin) === 'computed') {
+            console.log("\uD83D\uDD27 Found computed gateway at endpoint: ".concat(endpointObject.name, " (").concat(endpointObject.uuid, ")"));
+
+            // Convert gateway to manual (declared)
+            _this3.convertGatewayToManual(endpointObject, currentSceneData);
+            convertedGateways.push(endpointObject);
+          }
+        } else {
+          console.log("\u26A0\uFE0F Could not find object for endpoint: ".concat(endpointUuid));
+        }
+      });
+      if (convertedGateways.length > 0) {
+        console.log("\u2705 Converted ".concat(convertedGateways.length, " gateways to manual:"), convertedGateways.map(function (g) {
+          return g.name;
+        }));
+      } else {
+        console.log('ℹ️ No connected gateways found to convert');
+      }
+    }
+
+    /**
+     * Convert a gateway from computed to manual (declared) - reusing logic from sceneOperationsManager
+     * @param {THREE.Object3D} gateway - The gateway object to convert
+     * @param {Object} currentSceneData - Current scene data
+     */
+  }, {
+    key: "convertGatewayToManual",
+    value: function convertGatewayToManual(gateway, currentSceneData) {
+      var _gateway$userData2;
+      console.log("\uD83D\uDD27 Converting gateway from computed to declared: ".concat(gateway.name, " (").concat(gateway.uuid, ")"));
+
+      // Change origin from computed to declared
+      gateway.userData.origin = 'declared';
+
+      // Update the corresponding scene data object
+      for (var i = 0; i < currentSceneData.scene.object.children.length; i++) {
+        var _gateway$userData, _child$userData;
+        var child = currentSceneData.scene.object.children[i];
+        if (child.uuid === gateway.uuid || child.uuid === ((_gateway$userData = gateway.userData) === null || _gateway$userData === void 0 ? void 0 : _gateway$userData.originalUuid) || gateway.uuid === ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid)) {
+          if (!child.userData) child.userData = {};
+          child.userData.origin = 'declared';
+          console.log("\u2705 Updated scene data gateway origin to declared: ".concat(child.uuid));
+          break;
+        }
+      }
+
+      // Process gateway connections (same logic as in sceneOperationsManager)
+      if ((_gateway$userData2 = gateway.userData) !== null && _gateway$userData2 !== void 0 && _gateway$userData2.connections && currentSceneData.connections) {
+        console.log('🔗 Processing gateway connections for filtering:', gateway.userData.connections);
+        var gatewayConnections = gateway.userData.connections;
+        var currentConnections = currentSceneData.connections;
+
+        // Filter out removed connections
+        if (gatewayConnections.removed && Array.isArray(gatewayConnections.removed)) {
+          console.log('🗑️ Filtering out removed connections:', gatewayConnections.removed);
+          currentSceneData.connections = currentConnections.filter(function (connection) {
+            var isRemoved = gatewayConnections.removed.some(function (removedConn) {
+              return removedConn.from === connection.from && removedConn.to === connection.to || removedConn.from === connection.to && removedConn.to === connection.from;
+            });
+            if (isRemoved) {
+              console.log("\uD83D\uDDD1\uFE0F Removed connection: ".concat(connection.from, " \u2192 ").concat(connection.to));
+            }
+            return !isRemoved;
+          });
+        }
+
+        // Add new connections
+        if (gatewayConnections.added && Array.isArray(gatewayConnections.added)) {
+          console.log('➕ Adding new connections:', gatewayConnections.added);
+          gatewayConnections.added.forEach(function (newConnection) {
+            // Check if connection already exists to avoid duplicates
+            var alreadyExists = currentSceneData.connections.some(function (conn) {
+              return conn.from === newConnection.from && conn.to === newConnection.to || conn.from === newConnection.to && conn.to === newConnection.from;
+            });
+            if (!alreadyExists) {
+              currentSceneData.connections.push(newConnection);
+              console.log("\u2795 Added new connection: ".concat(newConnection.from, " \u2192 ").concat(newConnection.to));
+            } else {
+              console.log("\u26A0\uFE0F Connection already exists, skipping: ".concat(newConnection.from, " \u2192 ").concat(newConnection.to));
+            }
+          });
+        }
+        console.log('✅ Gateway connections processing completed. Total connections:', currentSceneData.connections.length);
+      }
+      console.log("\u2705 Gateway ".concat(gateway.name, " successfully converted to manual (declared)"));
+    }
+
+    /**
+     * Find the original connection that a segment belongs to
+     * @param {THREE.Object3D} segment - The pipe segment
+     * @param {Array} connections - Array of connections
+     * @returns {Object|null} The original connection or null
+     */
+  }, {
+    key: "findOriginalConnection",
+    value: function findOriginalConnection(segment, connections) {
+      var _fromObject$userData, _toObject$userData;
+      var segmentData = segment.userData;
+      var pathFrom = segmentData.pathFrom;
+      var pathTo = segmentData.pathTo;
+      console.log('🔍 Looking for connection:', {
+        pathFrom: pathFrom,
+        pathTo: pathTo
+      });
+      console.log('🔍 Available connections:', connections);
+
+      // First try: direct connection match
+      var foundConnection = connections.find(function (conn) {
+        return conn.from === pathFrom && conn.to === pathTo || conn.from === pathTo && conn.to === pathFrom;
+      });
+      if (foundConnection) {
+        console.log('🔍 Found direct connection match:', foundConnection);
+        return foundConnection;
+      }
+
+      // Second try: look for connections that might involve gateways
+      // This can happen when the original connection involves a gateway that was computed
+      console.log('🔍 No direct match found, checking for gateway-involved connections...');
+      var component = this.sceneViewer;
+
+      // Look for objects in the scene that might be the pathFrom or pathTo
+      var fromObject = null;
+      var toObject = null;
+      component.scene.traverse(function (obj) {
+        var _obj$userData2, _obj$userData3;
+        if (obj.uuid === pathFrom || ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.originalUuid) === pathFrom) {
+          fromObject = obj;
+        }
+        if (obj.uuid === pathTo || ((_obj$userData3 = obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.originalUuid) === pathTo) {
+          toObject = obj;
+        }
+      });
+      console.log('🔍 Scene objects found:', {
+        fromObject: fromObject ? {
+          uuid: fromObject.uuid,
+          name: fromObject.name,
+          componentType: (_fromObject$userData = fromObject.userData) === null || _fromObject$userData === void 0 ? void 0 : _fromObject$userData.componentType
+        } : null,
+        toObject: toObject ? {
+          uuid: toObject.uuid,
+          name: toObject.name,
+          componentType: (_toObject$userData = toObject.userData) === null || _toObject$userData === void 0 ? void 0 : _toObject$userData.componentType
+        } : null
+      });
+
+      // If we found the objects, look for connections involving their UUIDs
+      if (fromObject && toObject) {
+        foundConnection = connections.find(function (conn) {
+          return conn.from === fromObject.uuid && conn.to === toObject.uuid || conn.from === toObject.uuid && conn.to === fromObject.uuid;
+        });
+        if (foundConnection) {
+          console.log('🔍 Found connection via object UUIDs:', foundConnection);
+          return foundConnection;
+        }
+      }
+
+      // Third try: look for any connection that might be related to this segment
+      // This is a fallback for cases where the connection structure is complex
+      console.log('🔍 Trying fallback: looking for any connection that might be related...');
+
+      // Look for connections that might involve the segment's path information
+      var possibleConnections = connections.filter(function (conn) {
+        var _component$scene$getO, _component$scene$getO2;
+        // Check if either end of the connection might be related to our segment
+        var fromMatches = conn.from === pathFrom || conn.from === pathTo;
+        var toMatches = conn.to === pathFrom || conn.to === pathTo;
+
+        // Also check if the connection involves any gateway or component that might be related
+        var fromIsGateway = ((_component$scene$getO = component.scene.getObjectByProperty('uuid', conn.from)) === null || _component$scene$getO === void 0 || (_component$scene$getO = _component$scene$getO.userData) === null || _component$scene$getO === void 0 ? void 0 : _component$scene$getO.componentType) === 'gateway';
+        var toIsGateway = ((_component$scene$getO2 = component.scene.getObjectByProperty('uuid', conn.to)) === null || _component$scene$getO2 === void 0 || (_component$scene$getO2 = _component$scene$getO2.userData) === null || _component$scene$getO2 === void 0 ? void 0 : _component$scene$getO2.componentType) === 'gateway';
+        return fromMatches || toMatches || fromIsGateway || toIsGateway;
+      });
+      if (possibleConnections.length > 0) {
+        console.log('🔍 Found possible related connections:', possibleConnections);
+        // Return the first one as a best guess
+        return possibleConnections[0];
+      }
+      console.log('❌ No connection found for segment');
+      return null;
+    }
+
+    /**
+     * Calculate the start and end points of a pipe segment in world coordinates
+     * @param {THREE.Object3D} segment - The pipe segment
+     * @returns {Object} Object with start and end points
+     */
+  }, {
+    key: "calculateSegmentEndpoints",
+    value: function calculateSegmentEndpoints(segment) {
+      // Get the segment's geometry to determine its length and orientation
+      var geometry = segment.geometry;
+      var length = geometry.parameters.height || 1;
+
+      // Calculate start and end points based on segment position and orientation
+      var startPoint = new THREE.Vector3();
+      var endPoint = new THREE.Vector3();
+
+      // Get the segment's direction vector
+      var direction = new THREE.Vector3(0, 1, 0);
+      direction.applyQuaternion(segment.quaternion);
+
+      // Calculate start point (half length back from center)
+      startPoint.copy(segment.position).sub(direction.clone().multiplyScalar(length / 2));
+
+      // Calculate end point (half length forward from center)
+      endPoint.copy(segment.position).add(direction.clone().multiplyScalar(length / 2));
+      return {
+        start: startPoint,
+        end: endPoint
+      };
+    }
+
+    /**
+     * Create connector objects at segment endpoints
+     * @param {THREE.Object3D} segment - The pipe segment
+     * @param {Object} endpoints - Object with start and end points
+     * @returns {Array} Array of connector objects
+     */
+  }, {
+    key: "createSegmentConnectors",
+    value: function createSegmentConnectors(segment, endpoints) {
+      var segmentData = segment.userData;
+      var segmentId = segmentData.segmentId;
+      var connectors = [];
+
+      // Create start connector
+      var startConnector = new THREE.Mesh(new THREE.SphereGeometry(0.2, 16, 16), new THREE.MeshStandardMaterial({
+        color: 0x00FF00,
+        roughness: 0.7,
+        metalness: 0.3,
+        emissive: 0x003300
+      }));
+      startConnector.position.copy(endpoints.start);
+      startConnector.uuid = "".concat(segmentId, "-connector-start");
+      startConnector.name = "Manual Segment Start Connector: ".concat(segment.name);
+      startConnector.userData = {
+        componentType: 'connector',
+        forExport: true,
+        isManualSegmentConnector: true,
+        segmentId: segmentId,
+        connectorType: 'start',
+        manualSegmentUuid: segment.uuid
+      };
+
+      // Create end connector
+      var endConnector = new THREE.Mesh(new THREE.SphereGeometry(0.2, 16, 16), new THREE.MeshStandardMaterial({
+        color: 0xFF0000,
+        roughness: 0.7,
+        metalness: 0.3,
+        emissive: 0x330000
+      }));
+      endConnector.position.copy(endpoints.end);
+      endConnector.uuid = "".concat(segmentId, "-connector-end");
+      endConnector.name = "Manual Segment End Connector: ".concat(segment.name);
+      endConnector.userData = {
+        componentType: 'connector',
+        forExport: true,
+        isManualSegmentConnector: true,
+        segmentId: segmentId,
+        connectorType: 'end',
+        manualSegmentUuid: segment.uuid
+      };
+      connectors.push(startConnector, endConnector);
+      return connectors;
+    }
+
+    /**
+     * Add connectors to the scene and scene data
+     * @param {Array} connectors - Array of connector objects
+     */
+  }, {
+    key: "addConnectorsToScene",
+    value: function addConnectorsToScene(connectors) {
+      var component = this.sceneViewer;
+      connectors.forEach(function (connector) {
+        // Add to Three.js scene
+        component.scene.add(connector);
+        console.log("\uD83D\uDD0C Added connector to Three.js scene: ".concat(connector.name));
+
+        // Add to scene data structure
+        if (component.currentSceneData && component.currentSceneData.scene && component.currentSceneData.scene.object) {
+          var sceneDataConnector = {
+            uuid: connector.uuid,
+            name: connector.name,
+            type: connector.type,
+            userData: _objectSpread2({}, connector.userData),
+            position: {
+              x: connector.position.x,
+              y: connector.position.y,
+              z: connector.position.z
+            },
+            rotation: {
+              x: connector.rotation.x,
+              y: connector.rotation.y,
+              z: connector.rotation.z
+            },
+            scale: {
+              x: connector.scale.x,
+              y: connector.scale.y,
+              z: connector.scale.z
+            },
+            geometry: 'CONNECTOR-GEO'
+          };
+          component.currentSceneData.scene.object.children.push(sceneDataConnector);
+          console.log("\uD83D\uDD0C Added connector to scene data: ".concat(connector.name));
+        } else {
+          console.warn('⚠️ Could not add connector to scene data - currentSceneData not available');
+        }
+      });
+    }
+
+    /**
+     * Add manually positioned segment to scene data
+     * @param {THREE.Object3D} segment - The manually positioned pipe segment
+     */
+  }, {
+    key: "addManualSegmentToSceneData",
+    value: function addManualSegmentToSceneData(segment) {
+      var component = this.sceneViewer;
+      if (!component.currentSceneData || !component.currentSceneData.scene || !component.currentSceneData.scene.object) {
+        console.warn('⚠️ Could not add manual segment to scene data - currentSceneData not available');
+        return;
+      }
+
+      // Create scene data representation of the segment
+      var sceneDataSegment = {
+        uuid: segment.uuid,
+        name: segment.name,
+        type: segment.type,
+        userData: _objectSpread2({}, segment.userData),
+        position: {
+          x: segment.position.x,
+          y: segment.position.y,
+          z: segment.position.z
+        },
+        rotation: {
+          x: segment.rotation.x,
+          y: segment.rotation.y,
+          z: segment.rotation.z
+        },
+        scale: {
+          x: segment.scale.x,
+          y: segment.scale.y,
+          z: segment.scale.z
+        }
+      };
+
+      // Add to scene data children
+      component.currentSceneData.scene.object.children.push(sceneDataSegment);
+      console.log("\uD83D\uDD27 Added manual segment to scene data: ".concat(segment.name));
+    }
+
+    /**
+     * Restructure connections to use the new connectors
+     * @param {Object} originalConnection - The original connection
+     * @param {Array} connectors - Array of connector objects
+     * @param {Object} currentSceneData - Current scene data
+     */
+  }, {
+    key: "restructureConnections",
+    value: function restructureConnections(originalConnection, connectors, currentSceneData) {
+      var _connectors = _slicedToArray(connectors, 2),
+        startConnector = _connectors[0],
+        endConnector = _connectors[1];
+      console.log('🔗 Restructuring connections...');
+      console.log('🔗 Original connection:', originalConnection);
+      console.log('🔗 Start connector:', startConnector.uuid);
+      console.log('🔗 End connector:', endConnector.uuid);
+
+      // Find the original connection in the connections array
+      var connectionIndex = currentSceneData.connections.findIndex(function (conn) {
+        return conn.from === originalConnection.from && conn.to === originalConnection.to || conn.from === originalConnection.to && conn.to === originalConnection.from;
+      });
+      if (connectionIndex === -1) {
+        console.warn('⚠️ Could not find original connection in connections array');
+        return;
+      }
+      console.log("\uD83D\uDD17 Found original connection at index: ".concat(connectionIndex));
+
+      // Remove the original connection
+      currentSceneData.connections.splice(connectionIndex, 1);
+      console.log("\uD83D\uDDD1\uFE0F Removed original connection: ".concat(originalConnection.from, " \u2192 ").concat(originalConnection.to));
+
+      // Add two new connections
+      var newConnection1 = {
+        from: originalConnection.from,
+        to: startConnector.uuid
+      };
+      var newConnection2 = {
+        from: endConnector.uuid,
+        to: originalConnection.to
+      };
+      currentSceneData.connections.push(newConnection1, newConnection2);
+      console.log("\u2795 Added new connections:");
+      console.log("   ".concat(newConnection1.from, " \u2192 ").concat(newConnection1.to));
+      console.log("   ".concat(newConnection2.from, " \u2192 ").concat(newConnection2.to));
+
+      // Update the component's current scene data
+      if (this.sceneViewer.currentSceneData) {
+        this.sceneViewer.currentSceneData.connections = _toConsumableArray(currentSceneData.connections);
+        console.log('✅ Updated component currentSceneData connections');
+      }
+      console.log('🔗 Connection restructuring completed');
+    }
+
+    /**
+     * Create smooth elbow geometry to connect two pipe segments (optimized for 90-degree angles)
+     * @param {THREE.Vector3} point1 - First point (before the joint)
+     * @param {THREE.Vector3} point2 - Joint point (center of the elbow)
+     * @param {THREE.Vector3} point3 - Third point (after the joint)
+     * @param {number} radius - Pipe radius
+     * @returns {THREE.BufferGeometry} Elbow geometry
+     */
+  }, {
+    key: "createElbowGeometry",
+    value: function createElbowGeometry(point1, point2, point3, radius) {
+      try {
+        // Fixed elbow radius for 90-degree bends (simplified)
+        var elbowRadius = radius * 3;
+
+        // Create a curve for the 90-degree elbow
+        var curve = this.createElbowCurve(point1, point2, point3, elbowRadius);
+
+        // Fixed tubular segments for 90-degree bends (quarter circle)
+        var tubularSegments = 12; // Good balance for smooth 90° curves
+        var radialSegments = 8;
+        var closed = false;
+        var elbowGeometry = new THREE.TubeGeometry(curve, tubularSegments, radius, radialSegments, closed);
+        return elbowGeometry;
+      } catch (error) {
+        console.warn('Failed to create elbow geometry:', error);
+        return null;
+      }
+    }
+
+    /**
+     * Create a smooth curve for the 90-degree elbow joint (simplified)
+     * @param {THREE.Vector3} point1 - First point
+     * @param {THREE.Vector3} point2 - Joint point
+     * @param {THREE.Vector3} point3 - Third point
+     * @param {number} elbowRadius - Radius of the elbow curve
+     * @returns {THREE.Curve} Curve for the elbow
+     */
+  }, {
+    key: "createElbowCurve",
+    value: function createElbowCurve(point1, point2, point3, elbowRadius) {
+      // Calculate direction vectors
+      var dir1 = point2.clone().sub(point1).normalize();
+      var dir2 = point3.clone().sub(point2).normalize();
+
+      // For 90-degree bends, we can use a simpler approach with a quarter circle
+      // The curve radius is proportional to the elbow radius
+      var curveRadius = elbowRadius * 0.001;
+
+      // Calculate the offset distance from the joint point
+      var offset = curveRadius;
+
+      // Calculate start and end points of the curve (offset from the joint)
+      var curveStart = point2.clone().sub(dir1.clone().multiplyScalar(offset));
+      var curveEnd = point2.clone().add(dir2.clone().multiplyScalar(offset));
+
+      // For a 90-degree bend, the control point is at the corner
+      // We can use a quadratic bezier curve for simplicity
+      var controlPoint = point2.clone();
+
+      // Create a quadratic bezier curve (simpler than cubic for 90° bends)
+      var curve = new THREE.QuadraticBezierCurve3(curveStart, controlPoint, curveEnd);
+      return curve;
+    }
+
+    /**
+     * Recompute world bounding boxes after transforms
+     */
+  }, {
+    key: "recomputeWorldBoundingBoxes",
+    value: function recomputeWorldBoundingBoxes(currentSceneData) {
+      var component = this.sceneViewer;
+      component.scene.traverse(function (object) {
+        if (object.isMesh) {
+          // Find the corresponding JSON object
+          var jsonObject = null;
+          var _findJsonObject = function findJsonObject(children) {
+            var _iterator = _createForOfIteratorHelper(children),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var _object$userData, _child$userData2;
+                var child = _step.value;
+                // Enhanced matching logic with hardcoded UUID priority
+
+                // Strategy 1: Direct hardcoded UUID match (HIGHEST PRIORITY)
+                if (child.uuid === object.uuid || child.uuid === ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.originalUuid) || object.uuid === ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.originalUuid)) {
+                  return child;
+                }
+
+                // Strategy 2: Name-based UUID match (FALLBACK)
+                if (object.name && child.name) {
+                  var objectGeneratedUuid = generateUuidFromName(object.name);
+                  var childGeneratedUuid = generateUuidFromName(child.name);
+                  if (objectGeneratedUuid === childGeneratedUuid || objectGeneratedUuid === child.uuid || childGeneratedUuid === object.uuid) {
+                    return child;
+                  }
+                }
+
+                // Strategy 3: Name match
+                if (object.name && child.name && object.name === child.name) {
+                  return child;
+                }
+
+                // Recursively search children
+                if (child.children) {
+                  var found = _findJsonObject(child.children);
+                  if (found) return found;
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+            return null;
+          };
+          jsonObject = _findJsonObject(currentSceneData.scene.object.children);
+          if (jsonObject) {
+            // Compute world bounding box
+            var boundingBox = new THREE.Box3().setFromObject(object);
+
+            // Store in JSON userData for pathfinder
+            if (!jsonObject.userData) jsonObject.userData = {};
+            jsonObject.userData.worldBoundingBox = {
+              min: boundingBox.min.toArray(),
+              max: boundingBox.max.toArray()
+            };
+            if (!jsonObject.userData.origin) jsonObject.userData.origin = object.userData.origin;
+            if (!jsonObject.userData.direction) jsonObject.userData.direction = object.userData.direction;
+            if (!jsonObject.userData.group) jsonObject.userData.group = object.userData.group;
+            if (!jsonObject.userData.connections) jsonObject.userData.connections = object.userData.connections;
+            object.userData.associatedJsonObject = jsonObject;
+            console.log("Added world bounding box for ".concat(jsonObject.name, ":"), jsonObject.userData.worldBoundingBox);
+          }
+        }
+      });
+    } /**
+      * Update pathfinding with new connections data
+      */
+  }, {
+    key: "updatePathfindingWithConnections",
+    value: (function () {
+      var _updatePathfindingWithConnections = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(newConnections) {
+        var _component$currentSce, _component$currentSce2, _component$currentSce3, _updatedSceneData$sce;
+        var component, updatedSceneData;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              console.log('[A] updatePathfindingWithConnections');
+              component = this.sceneViewer; // Check if we have current scene data to work with
+              if (component.currentSceneData) {
+                _context5.n = 1;
+                break;
+              }
+              console.warn('⚠️ No current scene data available for pathfinder update');
+              return _context5.a(2, false);
+            case 1:
+              // Remove all existing paths from the scene
+              this.removeComputedObjects();
+              console.log('🔄 Updating pathfinder with new connections:', newConnections);
+              console.log('🔍 Current scene data structure:', {
+                hasConnections: !!component.currentSceneData.connections,
+                connectionsCount: ((_component$currentSce = component.currentSceneData.connections) === null || _component$currentSce === void 0 ? void 0 : _component$currentSce.length) || 0,
+                hasScene: !!component.currentSceneData.scene,
+                hasSceneObject: !!((_component$currentSce2 = component.currentSceneData.scene) !== null && _component$currentSce2 !== void 0 && _component$currentSce2.object),
+                childrenCount: ((_component$currentSce3 = component.currentSceneData.scene) === null || _component$currentSce3 === void 0 || (_component$currentSce3 = _component$currentSce3.object) === null || _component$currentSce3 === void 0 || (_component$currentSce3 = _component$currentSce3.children) === null || _component$currentSce3 === void 0 ? void 0 : _component$currentSce3.length) || 0
+              });
+
+              // Create a deep copy of the current scene data to avoid mutations
+              updatedSceneData = JSON.parse(JSON.stringify(component.currentSceneData)); // Update the connections in the copied scene data
+              updatedSceneData.connections = _toConsumableArray(newConnections);
+              console.log('🔍 Updated scene data for pathfinder:', {
+                connectionsCount: updatedSceneData.connections.length,
+                connections: updatedSceneData.connections,
+                hasScene: !!updatedSceneData.scene,
+                childrenCount: ((_updatedSceneData$sce = updatedSceneData.scene) === null || _updatedSceneData$sce === void 0 || (_updatedSceneData$sce = _updatedSceneData$sce.object) === null || _updatedSceneData$sce === void 0 || (_updatedSceneData$sce = _updatedSceneData$sce.children) === null || _updatedSceneData$sce === void 0 ? void 0 : _updatedSceneData$sce.length) || 0
+              });
+
+              // Use shared pathfinding logic (no gateways needed for updates)
+              _context5.n = 2;
+              return this._executePathfinding(updatedSceneData.scene, updatedSceneData.connections, {
+                createGateways: false,
+                context: 'Connections Update'
+              });
+            case 2:
+              // Update the component's current scene data to reflect the changes
+              component.currentSceneData = updatedSceneData;
+              console.log('✅ Pathfinding updated successfully with new connections');
+              return _context5.a(2, true);
+          }
+        }, _callee5, this);
+      }));
+      function updatePathfindingWithConnections(_x5) {
+        return _updatePathfindingWithConnections.apply(this, arguments);
+      }
+      return updatePathfindingWithConnections;
+    }()
+    /**
+     * Update pathfinding after object transforms
+     */
+    )
+  }, {
+    key: "updatePathfindingAfterTransform",
+    value: (function () {
+      var _updatePathfindingAfterTransform = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(currentSceneData) {
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              // Remove all existing paths from the scene
+              this.removeComputedObjects();
+              console.log('🔄 Starting pathfinding with updated scene data...');
+
+              // Use shared pathfinding logic (no gateways needed for transform updates)
+              _context6.n = 1;
+              return this._executePathfinding(currentSceneData.scene, currentSceneData.connections, {
+                createGateways: true,
+                context: 'Transform Update'
+              });
+            case 1:
+              return _context6.a(2);
+          }
+        }, _callee6, this);
+      }));
+      function updatePathfindingAfterTransform(_x6) {
+        return _updatePathfindingAfterTransform.apply(this, arguments);
+      }
+      return updatePathfindingAfterTransform;
+    }()
+    /**
+     * Dispose of pathfinding resources
+     */
+    )
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.removeComputedObjects();
+      this.pathfinder = null;
+      this.crosscubeTextureSet = null;
+      this.pathfinderVersionInfo = null;
+      logger.info('PathfindingManager disposed');
+    }
+
+    /**
+     * Merges colinear segments in path data to optimize pipe creation
+     * @param {Array} paths - Array of path objects from pathfinder
+     * @param {Number} tolerance - Angular tolerance for considering segments colinear (default: ~0.57 degrees)
+     * @returns {Array} Optimized paths with merged colinear segments
+     */
+  }, {
+    key: "mergeColinearPaths",
+    value: function mergeColinearPaths(paths) {
+      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.001;
+      // Create a deep copy of paths to avoid modifying the original
+      var optimizedPaths = JSON.parse(JSON.stringify(paths));
+      optimizedPaths.forEach(function (pathData) {
+        if (!pathData.path || pathData.path.length <= 2) {
+          return; // Skip paths with 0-2 points (no optimization needed)
+        }
+
+        // Convert path points to THREE.Vector3 objects for easier processing
+        var originalPath = pathData.path.map(function (point) {
+          if (point instanceof THREE.Vector3) {
+            return point.clone();
+          } else if (Array.isArray(point)) {
+            return new THREE.Vector3().fromArray(point);
+          } else if (point.x !== undefined && point.y !== undefined && point.z !== undefined) {
+            return new THREE.Vector3(point.x, point.y, point.z);
+          } else {
+            console.warn('Unknown point format:', point);
+            return new THREE.Vector3(0, 0, 0);
+          }
+        });
+        if (originalPath.length <= 2) {
+          return; // Skip after conversion if still too few points
+        }
+        var newPath = [originalPath[0]]; // Start with the first point
+
+        // Iterate through segments starting from the first segment
+        var i = 0;
+        var _loop2 = function _loop2() {
+          var segmentStart = originalPath[i];
+          var segmentEnd = originalPath[i + 1];
+
+          // Calculate initial direction vector
+          var currentDir = new THREE.Vector3().subVectors(segmentEnd, segmentStart);
+          var initialLength = currentDir.length();
+
+          // Skip zero-length segments
+          if (initialLength < 1e-6) {
+            i++;
+            return 1; // continue
+          }
+          currentDir.normalize();
+
+          // Look ahead to find all colinear points
+          var j = i + 2;
+          while (j < originalPath.length) {
+            var nextPoint = originalPath[j];
+
+            // Check if the line from segmentStart to nextPoint is colinear with currentDir
+            var testDir = new THREE.Vector3().subVectors(nextPoint, segmentStart);
+            var testLength = testDir.length();
+            if (testLength < 1e-6) {
+              // Skip zero-length vectors
+              j++;
+              continue;
+            }
+            testDir.normalize();
+
+            // Check colinearity using dot product (should be very close to 1 for same direction)
+            var dot = currentDir.dot(testDir);
+            var isColinear = Math.abs(dot - 1) < tolerance;
+            if (isColinear) {
+              // Extend the segment to this point
+              segmentEnd = nextPoint;
+              j++;
+            } else {
+              // Not colinear, stop extending this segment
+              break;
+            }
+          }
+
+          // Add the final point of this merged segment (unless it's the start point)
+          if (!segmentEnd.equals(segmentStart)) {
+            newPath.push(segmentEnd);
+          }
+
+          // Move to the next unprocessed point
+          // Find the index of segmentEnd in the original path
+          var nextIndex = originalPath.findIndex(function (point, idx) {
+            return idx > i && point.equals(segmentEnd);
+          });
+          if (nextIndex === -1) {
+            // If we can't find it, just increment by 1 (fallback)
+            i++;
+          } else {
+            i = nextIndex;
+          }
+        };
+        while (i < originalPath.length - 1) {
+          if (_loop2()) continue;
+        }
+
+        // Convert back to the original format (arrays if input was arrays)
+        var outputPath = newPath.map(function (point) {
+          if (Array.isArray(pathData.path[0])) {
+            return [point.x, point.y, point.z];
+          } else if (pathData.path[0].x !== undefined) {
+            return {
+              x: point.x,
+              y: point.y,
+              z: point.z
+            };
+          } else {
+            return point;
+          }
+        });
+
+        // Replace the original path with the optimized one
+        pathData.path = outputPath;
+
+        // Log the optimization results
+        var reduction = originalPath.length - newPath.length;
+        if (reduction > 0) {
+          console.log("\u2705 Optimized path ".concat(pathData.from, "-").concat(pathData.to, ": ") + "Reduced ".concat(originalPath.length, " points to ").concat(newPath.length, " ") + "(".concat(Math.round(reduction / originalPath.length * 100), "% reduction)"));
+        } else {
+          console.log("\u27A1\uFE0F Path ".concat(pathData.from, "-").concat(pathData.to, ": No optimization possible ") + "(".concat(originalPath.length, " points)"));
+        }
+      });
+      return optimizedPaths;
+    }
+  }]);
+}();
+
+export { PathfindingManager };