@2112-lab/central-plant 0.3.16 → 0.3.18

package/dist/bundle/index.js

@@ -18160,19 +18160,700 @@ function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
 
 }
 
+const _taskCache = new WeakMap();
+
+/**
+ * A loader for the Draco format.
+ *
+ * [Draco]{@link https://google.github.io/draco/} is an open source library for compressing
+ * and decompressing 3D meshes and point clouds. Compressed geometry can be significantly smaller,
+ * at the cost of additional decoding time on the client device.
+ *
+ * Standalone Draco files have a `.drc` extension, and contain vertex positions, normals, colors,
+ * and other attributes. Draco files do not contain materials, textures, animation, or node hierarchies –
+ * to use these features, embed Draco geometry inside of a glTF file. A normal glTF file can be converted
+ * to a Draco-compressed glTF file using [glTF-Pipeline]{@link https://github.com/CesiumGS/gltf-pipeline}.
+ * When using Draco with glTF, an instance of `DRACOLoader` will be used internally by {@link GLTFLoader}.
+ *
+ * It is recommended to create one DRACOLoader instance and reuse it to avoid loading and creating
+ * multiple decoder instances.
+ *
+ * `DRACOLoader` will automatically use either the JS or the WASM decoding library, based on
+ * browser capabilities.
+ *
+ * ```js
+ * const loader = new DRACOLoader();
+ * loader.setDecoderPath( '/examples/jsm/libs/draco/' );
+ *
+ * const geometry = await dracoLoader.loadAsync( 'models/draco/bunny.drc' );
+ * geometry.computeVertexNormals(); // optional
+ *
+ * dracoLoader.dispose();
+ * ```
+ *
+ * @augments Loader
+ * @three_import import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
+ */
+class DRACOLoader extends THREE.Loader {
+
+	/**
+	 * Constructs a new Draco loader.
+	 *
+	 * @param {LoadingManager} [manager] - The loading manager.
+	 */
+	constructor( manager ) {
+
+		super( manager );
+
+		this.decoderPath = '';
+		this.decoderConfig = {};
+		this.decoderBinary = null;
+		this.decoderPending = null;
+
+		this.workerLimit = 4;
+		this.workerPool = [];
+		this.workerNextTaskID = 1;
+		this.workerSourceURL = '';
+
+		this.defaultAttributeIDs = {
+			position: 'POSITION',
+			normal: 'NORMAL',
+			color: 'COLOR',
+			uv: 'TEX_COORD'
+		};
+		this.defaultAttributeTypes = {
+			position: 'Float32Array',
+			normal: 'Float32Array',
+			color: 'Float32Array',
+			uv: 'Float32Array'
+		};
+
+	}
+
+	/**
+	 * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+	 *
+	 * @param {string} path - The decoder path.
+	 * @return {DRACOLoader} A reference to this loader.
+	 */
+	setDecoderPath( path ) {
+
+		this.decoderPath = path;
+
+		return this;
+
+	}
+
+	/**
+	 * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+	 *
+	 * @param {{type:('js'|'wasm')}} config - The decoder config.
+	 * @return {DRACOLoader} A reference to this loader.
+	 */
+	setDecoderConfig( config ) {
+
+		this.decoderConfig = config;
+
+		return this;
+
+	}
+
+	/**
+	 * Sets the maximum number of Web Workers to be used during decoding.
+	 * A lower limit may be preferable if workers are also for other tasks in the application.
+	 *
+	 * @param {number} workerLimit - The worker limit.
+	 * @return {DRACOLoader} A reference to this loader.
+	 */
+	setWorkerLimit( workerLimit ) {
+
+		this.workerLimit = workerLimit;
+
+		return this;
+
+	}
+
+	/**
+	 * Starts loading from the given URL and passes the loaded Draco asset
+	 * to the `onLoad()` callback.
+	 *
+	 * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+	 * @param {function(BufferGeometry)} onLoad - Executed when the loading process has been finished.
+	 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
+	load( url, onLoad, onProgress, onError ) {
+
+		const loader = new THREE.FileLoader( this.manager );
+
+		loader.setPath( this.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.setRequestHeader( this.requestHeader );
+		loader.setWithCredentials( this.withCredentials );
+
+		loader.load( url, ( buffer ) => {
+
+			this.parse( buffer, onLoad, onError );
+
+		}, onProgress, onError );
+
+	}
+
+	/**
+	 * Parses the given Draco data.
+	 *
+	 * @param {ArrayBuffer} buffer - The raw Draco data as an array buffer.
+	 * @param {function(BufferGeometry)} onLoad - Executed when the loading/parsing process has been finished.
+	 * @param {onErrorCallback} onError - Executed when errors occur.
+	 */
+	parse( buffer, onLoad, onError = ()=>{} ) {
+
+		this.decodeDracoFile( buffer, onLoad, null, null, THREE.SRGBColorSpace, onError ).catch( onError );
+
+	}
+
+	//
+
+	decodeDracoFile( buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = THREE.LinearSRGBColorSpace, onError = () => {} ) {
+
+		const taskConfig = {
+			attributeIDs: attributeIDs || this.defaultAttributeIDs,
+			attributeTypes: attributeTypes || this.defaultAttributeTypes,
+			useUniqueIDs: !! attributeIDs,
+			vertexColorSpace: vertexColorSpace,
+		};
+
+		return this.decodeGeometry( buffer, taskConfig ).then( callback ).catch( onError );
+
+	}
+
+	decodeGeometry( buffer, taskConfig ) {
+
+		const taskKey = JSON.stringify( taskConfig );
+
+		// Check for an existing task using this buffer. A transferred buffer cannot be transferred
+		// again from this thread.
+		if ( _taskCache.has( buffer ) ) {
+
+			const cachedTask = _taskCache.get( buffer );
+
+			if ( cachedTask.key === taskKey ) {
+
+				return cachedTask.promise;
+
+			} else if ( buffer.byteLength === 0 ) {
+
+				// Technically, it would be possible to wait for the previous task to complete,
+				// transfer the buffer back, and decode again with the second configuration. That
+				// is complex, and I don't know of any reason to decode a Draco buffer twice in
+				// different ways, so this is left unimplemented.
+				throw new Error(
+
+					'THREE.DRACOLoader: Unable to re-decode a buffer with different ' +
+					'settings. Buffer has already been transferred.'
+
+				);
+
+			}
+
+		}
+
+		//
+
+		let worker;
+		const taskID = this.workerNextTaskID ++;
+		const taskCost = buffer.byteLength;
+
+		// Obtain a worker and assign a task, and construct a geometry instance
+		// when the task completes.
+		const geometryPending = this._getWorker( taskID, taskCost )
+			.then( ( _worker ) => {
+
+				worker = _worker;
+
+				return new Promise( ( resolve, reject ) => {
+
+					worker._callbacks[ taskID ] = { resolve, reject };
+
+					worker.postMessage( { type: 'decode', id: taskID, taskConfig, buffer }, [ buffer ] );
+
+					// this.debug();
+
+				} );
+
+			} )
+			.then( ( message ) => this._createGeometry( message.geometry ) );
+
+		// Remove task from the task list.
+		// Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
+		geometryPending
+			.catch( () => true )
+			.then( () => {
+
+				if ( worker && taskID ) {
+
+					this._releaseTask( worker, taskID );
+
+					// this.debug();
+
+				}
+
+			} );
+
+		// Cache the task result.
+		_taskCache.set( buffer, {
+
+			key: taskKey,
+			promise: geometryPending
+
+		} );
+
+		return geometryPending;
+
+	}
+
+	_createGeometry( geometryData ) {
+
+		const geometry = new THREE.BufferGeometry();
+
+		if ( geometryData.index ) {
+
+			geometry.setIndex( new THREE.BufferAttribute( geometryData.index.array, 1 ) );
+
+		}
+
+		for ( let i = 0; i < geometryData.attributes.length; i ++ ) {
+
+			const result = geometryData.attributes[ i ];
+			const name = result.name;
+			const array = result.array;
+			const itemSize = result.itemSize;
+
+			const attribute = new THREE.BufferAttribute( array, itemSize );
+
+			if ( name === 'color' ) {
+
+				this._assignVertexColorSpace( attribute, result.vertexColorSpace );
+
+				attribute.normalized = ( array instanceof Float32Array ) === false;
+
+			}
+
+			geometry.setAttribute( name, attribute );
+
+		}
+
+		return geometry;
+
+	}
+
+	_assignVertexColorSpace( attribute, inputColorSpace ) {
+
+		// While .drc files do not specify colorspace, the only 'official' tooling
+		// is PLY and OBJ converters, which use sRGB. We'll assume sRGB when a .drc
+		// file is passed into .load() or .parse(). GLTFLoader uses internal APIs
+		// to decode geometry, and vertex colors are already Linear-sRGB in there.
+
+		if ( inputColorSpace !== THREE.SRGBColorSpace ) return;
+
+		const _color = new THREE.Color();
+
+		for ( let i = 0, il = attribute.count; i < il; i ++ ) {
+
+			_color.fromBufferAttribute( attribute, i );
+			THREE.ColorManagement.colorSpaceToWorking( _color, THREE.SRGBColorSpace );
+			attribute.setXYZ( i, _color.r, _color.g, _color.b );
+
+		}
+
+	}
+
+	_loadLibrary( url, responseType ) {
+
+		const loader = new THREE.FileLoader( this.manager );
+		loader.setPath( this.decoderPath );
+		loader.setResponseType( responseType );
+		loader.setWithCredentials( this.withCredentials );
+
+		return new Promise( ( resolve, reject ) => {
+
+			loader.load( url, resolve, undefined, reject );
+
+		} );
+
+	}
+
+	preload() {
+
+		this._initDecoder();
+
+		return this;
+
+	}
+
+	_initDecoder() {
+
+		if ( this.decoderPending ) return this.decoderPending;
+
+		const useJS = typeof WebAssembly !== 'object' || this.decoderConfig.type === 'js';
+		const librariesPending = [];
+
+		if ( useJS ) {
+
+			librariesPending.push( this._loadLibrary( 'draco_decoder.js', 'text' ) );
+
+		} else {
+
+			librariesPending.push( this._loadLibrary( 'draco_wasm_wrapper.js', 'text' ) );
+			librariesPending.push( this._loadLibrary( 'draco_decoder.wasm', 'arraybuffer' ) );
+
+		}
+
+		this.decoderPending = Promise.all( librariesPending )
+			.then( ( libraries ) => {
+
+				const jsContent = libraries[ 0 ];
+
+				if ( ! useJS ) {
+
+					this.decoderConfig.wasmBinary = libraries[ 1 ];
+
+				}
+
+				const fn = DRACOWorker.toString();
+
+				const body = [
+					'/* draco decoder */',
+					jsContent,
+					'',
+					'/* worker */',
+					fn.substring( fn.indexOf( '{' ) + 1, fn.lastIndexOf( '}' ) )
+				].join( '\n' );
+
+				this.workerSourceURL = URL.createObjectURL( new Blob( [ body ] ) );
+
+			} );
+
+		return this.decoderPending;
+
+	}
+
+	_getWorker( taskID, taskCost ) {
+
+		return this._initDecoder().then( () => {
+
+			if ( this.workerPool.length < this.workerLimit ) {
+
+				const worker = new Worker( this.workerSourceURL );
+
+				worker._callbacks = {};
+				worker._taskCosts = {};
+				worker._taskLoad = 0;
+
+				worker.postMessage( { type: 'init', decoderConfig: this.decoderConfig } );
+
+				worker.onmessage = function ( e ) {
+
+					const message = e.data;
+
+					switch ( message.type ) {
+
+						case 'decode':
+							worker._callbacks[ message.id ].resolve( message );
+							break;
+
+						case 'error':
+							worker._callbacks[ message.id ].reject( message );
+							break;
+
+						default:
+							console.error( 'THREE.DRACOLoader: Unexpected message, "' + message.type + '"' );
+
+					}
+
+				};
+
+				this.workerPool.push( worker );
+
+			} else {
+
+				this.workerPool.sort( function ( a, b ) {
+
+					return a._taskLoad > b._taskLoad ? - 1 : 1;
+
+				} );
+
+			}
+
+			const worker = this.workerPool[ this.workerPool.length - 1 ];
+			worker._taskCosts[ taskID ] = taskCost;
+			worker._taskLoad += taskCost;
+			return worker;
+
+		} );
+
+	}
+
+	_releaseTask( worker, taskID ) {
+
+		worker._taskLoad -= worker._taskCosts[ taskID ];
+		delete worker._callbacks[ taskID ];
+		delete worker._taskCosts[ taskID ];
+
+	}
+
+	debug() {
+
+		console.log( 'Task load: ', this.workerPool.map( ( worker ) => worker._taskLoad ) );
+
+	}
+
+	dispose() {
+
+		for ( let i = 0; i < this.workerPool.length; ++ i ) {
+
+			this.workerPool[ i ].terminate();
+
+		}
+
+		this.workerPool.length = 0;
+
+		if ( this.workerSourceURL !== '' ) {
+
+			URL.revokeObjectURL( this.workerSourceURL );
+
+		}
+
+		return this;
+
+	}
+
+}
+
+/* WEB WORKER */
+
+function DRACOWorker() {
+
+	let decoderConfig;
+	let decoderPending;
+
+	onmessage = function ( e ) {
+
+		const message = e.data;
+
+		switch ( message.type ) {
+
+			case 'init':
+				decoderConfig = message.decoderConfig;
+				decoderPending = new Promise( function ( resolve/*, reject*/ ) {
+
+					decoderConfig.onModuleLoaded = function ( draco ) {
+
+						// Module is Promise-like. Wrap before resolving to avoid loop.
+						resolve( { draco: draco } );
+
+					};
+
+					DracoDecoderModule( decoderConfig ); // eslint-disable-line no-undef
+
+				} );
+				break;
+
+			case 'decode':
+				const buffer = message.buffer;
+				const taskConfig = message.taskConfig;
+				decoderPending.then( ( module ) => {
+
+					const draco = module.draco;
+					const decoder = new draco.Decoder();
+
+					try {
+
+						const geometry = decodeGeometry( draco, decoder, new Int8Array( buffer ), taskConfig );
+
+						const buffers = geometry.attributes.map( ( attr ) => attr.array.buffer );
+
+						if ( geometry.index ) buffers.push( geometry.index.array.buffer );
+
+						self.postMessage( { type: 'decode', id: message.id, geometry }, buffers );
+
+					} catch ( error ) {
+
+						console.error( error );
+
+						self.postMessage( { type: 'error', id: message.id, error: error.message } );
+
+					} finally {
+
+						draco.destroy( decoder );
+
+					}
+
+				} );
+				break;
+
+		}
+
+	};
+
+	function decodeGeometry( draco, decoder, array, taskConfig ) {
+
+		const attributeIDs = taskConfig.attributeIDs;
+		const attributeTypes = taskConfig.attributeTypes;
+
+		let dracoGeometry;
+		let decodingStatus;
+
+		const geometryType = decoder.GetEncodedGeometryType( array );
+
+		if ( geometryType === draco.TRIANGULAR_MESH ) {
+
+			dracoGeometry = new draco.Mesh();
+			decodingStatus = decoder.DecodeArrayToMesh( array, array.byteLength, dracoGeometry );
+
+		} else if ( geometryType === draco.POINT_CLOUD ) {
+
+			dracoGeometry = new draco.PointCloud();
+			decodingStatus = decoder.DecodeArrayToPointCloud( array, array.byteLength, dracoGeometry );
+
+		} else {
+
+			throw new Error( 'THREE.DRACOLoader: Unexpected geometry type.' );
+
+		}
+
+		if ( ! decodingStatus.ok() || dracoGeometry.ptr === 0 ) {
+
+			throw new Error( 'THREE.DRACOLoader: Decoding failed: ' + decodingStatus.error_msg() );
+
+		}
+
+		const geometry = { index: null, attributes: [] };
+
+		// Gather all vertex attributes.
+		for ( const attributeName in attributeIDs ) {
+
+			const attributeType = self[ attributeTypes[ attributeName ] ];
+
+			let attribute;
+			let attributeID;
+
+			// A Draco file may be created with default vertex attributes, whose attribute IDs
+			// are mapped 1:1 from their semantic name (POSITION, NORMAL, ...). Alternatively,
+			// a Draco file may contain a custom set of attributes, identified by known unique
+			// IDs. glTF files always do the latter, and `.drc` files typically do the former.
+			if ( taskConfig.useUniqueIDs ) {
+
+				attributeID = attributeIDs[ attributeName ];
+				attribute = decoder.GetAttributeByUniqueId( dracoGeometry, attributeID );
+
+			} else {
+
+				attributeID = decoder.GetAttributeId( dracoGeometry, draco[ attributeIDs[ attributeName ] ] );
+
+				if ( attributeID === - 1 ) continue;
+
+				attribute = decoder.GetAttribute( dracoGeometry, attributeID );
+
+			}
+
+			const attributeResult = decodeAttribute( draco, decoder, dracoGeometry, attributeName, attributeType, attribute );
+
+			if ( attributeName === 'color' ) {
+
+				attributeResult.vertexColorSpace = taskConfig.vertexColorSpace;
+
+			}
+
+			geometry.attributes.push( attributeResult );
+
+		}
+
+		// Add index.
+		if ( geometryType === draco.TRIANGULAR_MESH ) {
+
+			geometry.index = decodeIndex( draco, decoder, dracoGeometry );
+
+		}
+
+		draco.destroy( dracoGeometry );
+
+		return geometry;
+
+	}
+
+	function decodeIndex( draco, decoder, dracoGeometry ) {
+
+		const numFaces = dracoGeometry.num_faces();
+		const numIndices = numFaces * 3;
+		const byteLength = numIndices * 4;
+
+		const ptr = draco._malloc( byteLength );
+		decoder.GetTrianglesUInt32Array( dracoGeometry, byteLength, ptr );
+		const index = new Uint32Array( draco.HEAPF32.buffer, ptr, numIndices ).slice();
+		draco._free( ptr );
+
+		return { array: index, itemSize: 1 };
+
+	}
+
+	function decodeAttribute( draco, decoder, dracoGeometry, attributeName, attributeType, attribute ) {
+
+		const numComponents = attribute.num_components();
+		const numPoints = dracoGeometry.num_points();
+		const numValues = numPoints * numComponents;
+		const byteLength = numValues * attributeType.BYTES_PER_ELEMENT;
+		const dataType = getDracoDataType( draco, attributeType );
+
+		const ptr = draco._malloc( byteLength );
+		decoder.GetAttributeDataArrayForAllPoints( dracoGeometry, attribute, dataType, byteLength, ptr );
+		const array = new attributeType( draco.HEAPF32.buffer, ptr, numValues ).slice();
+		draco._free( ptr );
+
+		return {
+			name: attributeName,
+			array: array,
+			itemSize: numComponents
+		};
+
+	}
+
+	function getDracoDataType( draco, attributeType ) {
+
+		switch ( attributeType ) {
+
+			case Float32Array: return draco.DT_FLOAT32;
+			case Int8Array: return draco.DT_INT8;
+			case Int16Array: return draco.DT_INT16;
+			case Int32Array: return draco.DT_INT32;
+			case Uint8Array: return draco.DT_UINT8;
+			case Uint16Array: return draco.DT_UINT16;
+			case Uint32Array: return draco.DT_UINT32;
+
+		}
+
+	}
+
+}
+
 var ModelPreloader = /*#__PURE__*/function () {
   function ModelPreloader() {
     _classCallCheck(this, ModelPreloader);
     this.modelCache = new Map(); // Cache for loaded models
     this.loadingPromises = new Map(); // Track ongoing loads to prevent duplicates
     this.gltfLoader = new GLTFLoader();
+
+    // Setup DRACO decoder for compressed GLB files
+    this.dracoLoader = new DRACOLoader();
+    this.dracoLoader.setDecoderPath('/draco/');
+    this.gltfLoader.setDRACOLoader(this.dracoLoader);
     this.isPreloading = false;
     this.preloadingPromise = null;
     this.componentDictionary = null;
     this.modelsBasePath = '/library/models/'; // Default local path
     this.urlResolver = null; // Optional function to resolve model URLs (for S3 authentication)
 
-    console.log('🚀 ModelPreloader initialized with GLB support');
+    console.log('🚀 ModelPreloader initialized with GLB + DRACO support');
   }
 
   /**
@@ -19873,6 +20554,114 @@ var ComponentDataManager = /*#__PURE__*/function (_BaseDisposable) {
   }]);
 }(BaseDisposable);
 
+/**
+ * Utility function to update userData.direction for components after 90-degree rotation
+ * This function handles the direction vector transformation for connectors when their parent component is rotated
+ * 
+ * @param {THREE.Object3D} component - The component that was rotated
+ * @param {string} axis - The axis of rotation ('x', 'y', or 'z')
+ * @param {number} degrees - The rotation angle in degrees (should be multiple of 90)
+ */
+function updateDirectionAfterRotation(component, axis, degrees) {
+  if (!component) {
+    console.warn('⚠️ updateDirectionAfterRotation: No component provided');
+    return;
+  }
+
+  // Only handle 90-degree increments
+  if (degrees % 90 !== 0) {
+    console.warn('⚠️ updateDirectionAfterRotation: Only 90-degree increments are supported');
+    return;
+  }
+
+  // Normalize degrees to 0-360 range
+  var normalizedDegrees = (degrees % 360 + 360) % 360;
+  console.log("\uD83D\uDD04 Updating direction vectors for ".concat(component.name || component.uuid, " after ").concat(degrees, "\xB0 rotation around ").concat(axis, " axis"));
+
+  // Traverse all children (connectors) and update their direction vectors
+  component.traverse(function (child) {
+    var _child$userData, _child$userData2;
+    var childType = ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) || ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.objectType);
+    if (child.userData && Array.isArray(child.userData.direction) && childType === 'connector') {
+      var originalDirection = _toConsumableArray(child.userData.direction);
+      var newDirection = rotateDirectionVector(originalDirection, axis, normalizedDegrees);
+
+      // Update the direction
+      child.userData.direction = newDirection;
+      console.log("\uD83D\uDCCD Updated connector ".concat(child.name || child.uuid, " direction:"), {
+        original: originalDirection,
+        new: newDirection,
+        rotationAxis: axis,
+        rotationDegrees: degrees
+      });
+    }
+  });
+}
+
+/**
+ * Rotate a direction vector by 90-degree increments around a specific axis
+ * 
+ * @param {Array<number>} direction - The original direction vector [x, y, z]
+ * @param {string} axis - The axis of rotation ('x', 'y', or 'z')
+ * @param {number} degrees - The rotation angle in degrees (must be multiple of 90)
+ * @returns {Array<number>} The new direction vector [x, y, z]
+ */
+function rotateDirectionVector(direction, axis, degrees) {
+  if (!Array.isArray(direction) || direction.length !== 3) {
+    console.warn('⚠️ rotateDirectionVector: Invalid direction vector');
+    return direction;
+  }
+  var _direction = _slicedToArray(direction, 3),
+    x = _direction[0],
+    y = _direction[1],
+    z = _direction[2];
+  var steps = degrees / 90; // Number of 90-degree steps
+
+  for (var i = 0; i < steps; i++) {
+    var newX = x,
+      newY = y,
+      newZ = z;
+    switch (axis) {
+      case 'x':
+        // Rotation around X-axis in Z-up system with flipped Y: Y becomes -Z, Z becomes Y
+        newY = -z;
+        newZ = y;
+        break;
+      case 'y':
+        // Rotation around Y-axis in Z-up system with flipped Y: X becomes Z, Z becomes -X
+        newX = z;
+        newZ = -x;
+        break;
+      case 'z':
+        // Rotation around Z-axis in Z-up system with flipped Y: X becomes -Y, Y becomes X
+        newX = -y;
+        newY = x;
+        break;
+      default:
+        console.warn("\u26A0\uFE0F rotateDirectionVector: Invalid axis '".concat(axis, "'"));
+        return direction;
+    }
+    x = newX;
+    y = newY;
+    z = newZ;
+  }
+  return [x, y, z];
+}
+
+/**
+ * Example usage in your rotate method:
+ * 
+ * // After applying rotation to the component
+ * component.rotation[axis] += radians
+ * 
+ * // Update direction vectors for connectors
+ * updateDirectionAfterRotation(component, axis, value)
+ * 
+ * // Update matrices
+ * component.updateMatrix()
+ * component.updateMatrixWorld(true)
+ */
+
 var TransformOperationsManager = /*#__PURE__*/function () {
   /**
    * @param {Object} sceneViewer - The scene viewer instance
@@ -20564,16 +21353,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       if (!component || degrees % 90 !== 0) {
         return;
       }
-      console.log("\uD83D\uDD04 Updating connector directions after ".concat(degrees, "\xB0 rotation around ").concat(axis, " axis"));
 
-      // Simple approach: just log that directions may need manual verification
-      // In most cases, Three.js world matrices handle the actual positioning correctly
-      component.traverse(function (child) {
-        var _child$userData5, _child$userData6;
-        if (((_child$userData5 = child.userData) === null || _child$userData5 === void 0 ? void 0 : _child$userData5.objectType) === 'connector' && (_child$userData6 = child.userData) !== null && _child$userData6 !== void 0 && _child$userData6.direction) {
-          console.log("\uD83D\uDCCD Connector ".concat(child.uuid, " direction may need verification after rotation"));
-        }
-      });
+      // Use the direction utility to update direction vectors on Three.js connector objects
+      updateDirectionAfterRotation(component, axis, degrees);
     }
 
     /**
@@ -20727,9 +21509,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all connectors
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData7;
+        var _child$userData5;
         // Check if this is a connector (component connector or manual segment connector)
-        if (((_child$userData7 = child.userData) === null || _child$userData7 === void 0 ? void 0 : _child$userData7.objectType) === 'connector') {
+        if (((_child$userData5 = child.userData) === null || _child$userData5 === void 0 ? void 0 : _child$userData5.objectType) === 'connector') {
           // Get world position of connector
           var connectorWorldPos = new THREE__namespace.Vector3();
           child.getWorldPosition(connectorWorldPos);
@@ -20780,8 +21562,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Find all child connectors of the segment in the Three.js scene
       var connectors = [];
       segment.traverse(function (child) {
-        var _child$userData8;
-        if (((_child$userData8 = child.userData) === null || _child$userData8 === void 0 ? void 0 : _child$userData8.objectType) === 'segment-connector') {
+        var _child$userData6;
+        if (((_child$userData6 = child.userData) === null || _child$userData6 === void 0 ? void 0 : _child$userData6.objectType) === 'segment-connector') {
           connectors.push(child);
         }
       });
@@ -20845,17 +21627,17 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Check all segments in the scene
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData9, _child$userData0;
+        var _child$userData7, _child$userData8;
         // Skip the segment itself
         if (child.uuid === segment.uuid) {
           return;
         }
 
         // Only check computed segments in the scene
-        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 && _child$userData0.isDeclared) {
-          var _segment$userData6, _child$userData1, _segment$userData7, _child$userData10;
+        if (((_child$userData7 = child.userData) === null || _child$userData7 === void 0 ? void 0 : _child$userData7.objectType) === 'segment' && (_child$userData8 = child.userData) !== null && _child$userData8 !== void 0 && _child$userData8.isDeclared) {
+          var _segment$userData6, _child$userData9, _segment$userData7, _child$userData0;
           // Check if segments are part of the same connection path
-          var sameConnection = ((_segment$userData6 = segment.userData) === null || _segment$userData6 === void 0 ? void 0 : _segment$userData6.pathFrom) === ((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.pathFrom) && ((_segment$userData7 = segment.userData) === null || _segment$userData7 === void 0 ? void 0 : _segment$userData7.pathTo) === ((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.pathTo);
+          var sameConnection = ((_segment$userData6 = segment.userData) === null || _segment$userData6 === void 0 ? void 0 : _segment$userData6.pathFrom) === ((_child$userData9 = child.userData) === null || _child$userData9 === void 0 ? void 0 : _child$userData9.pathFrom) && ((_segment$userData7 = segment.userData) === null || _segment$userData7 === void 0 ? void 0 : _segment$userData7.pathTo) === ((_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.pathTo);
 
           // Get endpoints of the other segment (use stored endpoints if available)
           var otherEndpoints = _this2.getSegmentEndpoints(child);
@@ -21076,11 +21858,11 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all component connectors
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData11;
+        var _child$userData1;
         if (collision) return; // Stop if collision already found
 
         // Check if this is a component connector (not a segment-connector)
-        if (((_child$userData11 = child.userData) === null || _child$userData11 === void 0 ? void 0 : _child$userData11.objectType) === 'connector') {
+        if (((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.objectType) === 'connector') {
           var _segment$userData10, _segment$userData11;
           // Skip connectors that are connected to this segment (pathFrom or pathTo)
           var segmentPathFrom = (_segment$userData10 = segment.userData) === null || _segment$userData10 === void 0 ? void 0 : _segment$userData10.pathFrom;
@@ -21194,9 +21976,9 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all component connectors
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData12;
+        var _child$userData10;
         // Check if this is a component connector (not a segment-connector)
-        if (((_child$userData12 = child.userData) === null || _child$userData12 === void 0 ? void 0 : _child$userData12.objectType) === 'connector') {
+        if (((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.objectType) === 'connector') {
           // Get world position of connector
           var connectorWorldPos = new THREE__namespace.Vector3();
           child.getWorldPosition(connectorWorldPos);
@@ -21253,11 +22035,11 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all components
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData13, _child$userData14;
+        var _child$userData11, _child$userData12;
         if (collision) return; // Stop if collision already found
 
         // Check if this is a component (equipment)
-        if (((_child$userData13 = child.userData) === null || _child$userData13 === void 0 ? void 0 : _child$userData13.objectType) === 'component' && (_child$userData14 = child.userData) !== null && _child$userData14 !== void 0 && _child$userData14.libraryId) {
+        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);
 
@@ -21296,11 +22078,11 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all manual segments (isDeclared === true)
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData15, _child$userData16;
+        var _child$userData13, _child$userData14;
         if (collision) return; // Stop if collision already found
 
         // Only check manual segments (isDeclared === true)
-        if (((_child$userData15 = child.userData) === null || _child$userData15 === void 0 ? void 0 : _child$userData15.objectType) === 'segment' && ((_child$userData16 = child.userData) === null || _child$userData16 === void 0 ? void 0 : _child$userData16.isDeclared) === true) {
+        if (((_child$userData13 = child.userData) === null || _child$userData13 === void 0 ? void 0 : _child$userData13.objectType) === 'segment' && ((_child$userData14 = child.userData) === null || _child$userData14 === void 0 ? void 0 : _child$userData14.isDeclared) === true) {
           // Get segment endpoints
           var segmentEndpoints = _this3.getSegmentEndpoints(child);
 
@@ -21389,11 +22171,11 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all manual segments (isDeclared === true)
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData17, _child$userData18;
+        var _child$userData15, _child$userData16;
         if (collision) return; // Stop if collision already found
 
         // Only check manual segments (isDeclared === true)
-        if (((_child$userData17 = child.userData) === null || _child$userData17 === void 0 ? void 0 : _child$userData17.objectType) === 'segment' && ((_child$userData18 = child.userData) === null || _child$userData18 === void 0 ? void 0 : _child$userData18.isDeclared) === true) {
+        if (((_child$userData15 = child.userData) === null || _child$userData15 === void 0 ? void 0 : _child$userData15.objectType) === 'segment' && ((_child$userData16 = child.userData) === null || _child$userData16 === void 0 ? void 0 : _child$userData16.isDeclared) === true) {
           // Get segment endpoints
           var segmentEndpoints = _this4.getSegmentEndpoints(child);
 
@@ -21450,11 +22232,11 @@ var TransformOperationsManager = /*#__PURE__*/function () {
 
       // Traverse scene to find all components
       this.sceneViewer.scene.traverse(function (child) {
-        var _child$userData19, _child$userData20;
+        var _child$userData17, _child$userData18;
         if (collision) return; // Stop if collision already found
 
         // Check if this is a component (equipment)
-        if (((_child$userData19 = child.userData) === null || _child$userData19 === void 0 ? void 0 : _child$userData19.objectType) === 'component' && (_child$userData20 = child.userData) !== null && _child$userData20 !== void 0 && _child$userData20.libraryId) {
+        if (((_child$userData17 = child.userData) === null || _child$userData17 === void 0 ? void 0 : _child$userData17.objectType) === 'component' && (_child$userData18 = child.userData) !== null && _child$userData18 !== void 0 && _child$userData18.libraryId) {
           // Try to get worldBoundingBox from userData first (most up-to-date)
           var bbox = null;
           if (child.userData.worldBoundingBox) {
@@ -21599,8 +22381,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
       // Get the moved segment's connectors
       var movedConnectors = [];
       movedSegment.traverse(function (child) {
-        var _child$userData21;
-        if (((_child$userData21 = child.userData) === null || _child$userData21 === void 0 ? void 0 : _child$userData21.objectType) === 'segment-connector') {
+        var _child$userData19;
+        if (((_child$userData19 = child.userData) === null || _child$userData19 === void 0 ? void 0 : _child$userData19.objectType) === 'segment-connector') {
           movedConnectors.push(child);
         }
       });
@@ -21670,8 +22452,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Get all connectors of the adjacent segment
         var adjacentConnectors = [];
         adjacentSegment.traverse(function (child) {
-          var _child$userData22;
-          if (((_child$userData22 = child.userData) === null || _child$userData22 === void 0 ? void 0 : _child$userData22.objectType) === 'segment-connector') {
+          var _child$userData20;
+          if (((_child$userData20 = child.userData) === null || _child$userData20 === void 0 ? void 0 : _child$userData20.objectType) === 'segment-connector') {
             adjacentConnectors.push(child);
           }
         });
@@ -21794,8 +22576,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Also update child connectors' positions if they exist
         if (sceneDataComponent.children) {
           sceneDataComponent.children.forEach(function (child) {
-            var _child$userData23;
-            if (((_child$userData23 = child.userData) === null || _child$userData23 === void 0 ? void 0 : _child$userData23.objectType) === 'connector') {
+            var _child$userData21;
+            if (((_child$userData21 = child.userData) === null || _child$userData21 === void 0 ? void 0 : _child$userData21.objectType) === 'connector') {
               // Find the actual connector object in the scene
               var connectorObj = component.children.find(function (c) {
                 var _c$userData;
@@ -21857,14 +22639,15 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Also update child connectors' positions if they exist (rotation moves them in world space)
         if (sceneDataComponent.children) {
           sceneDataComponent.children.forEach(function (child) {
-            var _child$userData24;
-            if (((_child$userData24 = child.userData) === null || _child$userData24 === void 0 ? void 0 : _child$userData24.objectType) === 'connector') {
+            var _child$userData22;
+            if (((_child$userData22 = child.userData) === null || _child$userData22 === void 0 ? void 0 : _child$userData22.objectType) === 'connector') {
               // Find the actual connector object in the scene
               var connectorObj = component.children.find(function (c) {
                 var _c$userData2;
                 return c.uuid === child.uuid || ((_c$userData2 = c.userData) === null || _c$userData2 === void 0 ? void 0 : _c$userData2.originalUuid) === child.uuid;
               });
               if (connectorObj) {
+                var _connectorObj$userDat;
                 // Get world position of connector
                 var worldPos = new THREE__namespace.Vector3();
                 connectorObj.getWorldPosition(worldPos);
@@ -21875,6 +22658,12 @@ var TransformOperationsManager = /*#__PURE__*/function () {
                 }
                 child.userData.position = [cleanValue(worldPos.x), cleanValue(worldPos.y), cleanValue(worldPos.z)];
                 console.log("  \u21B3 Updated child connector ".concat(child.uuid, " position to [").concat(child.userData.position.join(', '), "]"));
+
+                // Update connector's direction in scene data from the Three.js object
+                if ((_connectorObj$userDat = connectorObj.userData) !== null && _connectorObj$userDat !== void 0 && _connectorObj$userDat.direction && Array.isArray(connectorObj.userData.direction)) {
+                  child.userData.direction = _toConsumableArray(connectorObj.userData.direction);
+                  console.log("  \u21B3 Updated child connector ".concat(child.uuid, " direction to [").concat(child.userData.direction.join(', '), "]"));
+                }
               }
             }
           });
@@ -22187,8 +22976,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
         // Check if either external connector belongs to the active segment
         var activeSegmentConnectors = [];
         activeSegment.traverse(function (child) {
-          var _child$userData25;
-          if (((_child$userData25 = child.userData) === null || _child$userData25 === void 0 ? void 0 : _child$userData25.objectType) === 'segment-connector') {
+          var _child$userData23;
+          if (((_child$userData23 = child.userData) === null || _child$userData23 === void 0 ? void 0 : _child$userData23.objectType) === 'segment-connector') {
             activeSegmentConnectors.push(child.uuid);
           }
         });
@@ -22236,8 +23025,8 @@ var TransformOperationsManager = /*#__PURE__*/function () {
               // Get all connectors of the active segment
               var activeConnectors = [];
               activeSegment.traverse(function (child) {
-                var _child$userData26;
-                if (((_child$userData26 = child.userData) === null || _child$userData26 === void 0 ? void 0 : _child$userData26.objectType) === 'segment-connector') {
+                var _child$userData24;
+                if (((_child$userData24 = child.userData) === null || _child$userData24 === void 0 ? void 0 : _child$userData24.objectType) === 'segment-connector') {
                   activeConnectors.push(child);
                 }
               });
@@ -28065,6 +28854,22 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               this.pathfinder = new pathfinder.Pathfinder(this.pathfinderConfig);
               this.sceneViewer.pathfinder = this.pathfinder;
 
+              // ── Early exit if no connections ───────────────────────────────────
+              // Skip expensive bounding box computation when there's nothing to connect
+              if (!(!connections || connections.length === 0)) {
+                _context.n = 1;
+                break;
+              }
+              console.log("\u23ED\uFE0F Skipping pathfinding - no connections [".concat(context, "]"));
+              return _context.a(2, {
+                paths: [],
+                gateways: [],
+                rewiredConnections: [],
+                metrics: {
+                  total: 0
+                }
+              });
+            case 1:
               // ── Stage 1: Input Generation ──────────────────────────────────────
               inputGenStart = performance.now(); // Ensure all matrices are up to date before bounding box calculations (for all pathfinding executions)
               this.sceneViewer.scene.updateMatrixWorld(true);
@@ -30752,15 +31557,23 @@ var ModelManager = /*#__PURE__*/function () {
           if (child.userData) {
             clonedConnector.userData = _objectSpread2({}, child.userData);
 
-            // Deep copy critical data
+            // Deep copy critical data - handle both array [x,y,z] and object {x,y,z} formats
             if (child.userData.worldBoundingBox) {
+              var wbb = child.userData.worldBoundingBox;
               clonedConnector.userData.worldBoundingBox = {
-                min: _toConsumableArray(child.userData.worldBoundingBox.min),
-                max: _toConsumableArray(child.userData.worldBoundingBox.max)
+                min: Array.isArray(wbb.min) ? _toConsumableArray(wbb.min) : _objectSpread2({}, wbb.min),
+                max: Array.isArray(wbb.max) ? _toConsumableArray(wbb.max) : _objectSpread2({}, wbb.max)
               };
             }
             if (child.userData.direction) {
-              clonedConnector.userData.direction = _toConsumableArray(child.userData.direction);
+              // Handle both array [x,y,z] and object {x,y,z} formats
+              if (Array.isArray(child.userData.direction)) {
+                clonedConnector.userData.direction = _toConsumableArray(child.userData.direction);
+              } else if (_typeof(child.userData.direction) === 'object') {
+                clonedConnector.userData.direction = _objectSpread2({}, child.userData.direction);
+              } else {
+                clonedConnector.userData.direction = child.userData.direction;
+              }
             }
 
             // Set originalUuid to match the actual uuid (maintains consistency)
@@ -30791,6 +31604,7 @@ var ModelManager = /*#__PURE__*/function () {
                 _context2.n = 1;
                 break;
               }
+              console.log("\uD83C\uDFAF GLB cache HIT: ".concat(modelKey));
               return _context2.a(2, gltfScene);
             case 1:
               // Check if preloading is in progress
@@ -30799,6 +31613,7 @@ var ModelManager = /*#__PURE__*/function () {
                 _context2.n = 6;
                 break;
               }
+              console.log("\u23F3 Waiting for preloader: ".concat(modelKey));
               _context2.p = 2;
               _context2.n = 3;
               return modelPreloader.preloadingPromise;
@@ -30808,6 +31623,7 @@ var ModelManager = /*#__PURE__*/function () {
                 _context2.n = 4;
                 break;
               }
+              console.log("\uD83C\uDFAF GLB cache HIT (after preload): ".concat(modelKey));
               return _context2.a(2, gltfScene);
             case 4:
               _context2.n = 6;
@@ -31135,7 +31951,7 @@ var ModelManager = /*#__PURE__*/function () {
     value: (function () {
       var _replaceWithGLBModels = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(libraryObjectsToReplace) {
         var _this3 = this;
-        var glbLoadingPromises;
+        var startTime, glbLoadingPromises;
         return _regenerator().w(function (_context5) {
           while (1) switch (_context5.n) {
             case 0:
@@ -31145,23 +31961,29 @@ var ModelManager = /*#__PURE__*/function () {
               }
               return _context5.a(2);
             case 1:
+              startTime = performance.now();
               console.log("\uD83D\uDD04 Replacing ".concat(libraryObjectsToReplace.length, " objects with GLB models..."));
               glbLoadingPromises = libraryObjectsToReplace.map(function (_ref, index) {
                 var basicObject = _ref.basicObject,
                   jsonData = _ref.jsonData,
                   componentData = _ref.componentData;
+                var modelStart = performance.now();
                 return _this3.loadLibraryModel(basicObject, jsonData, componentData).then(function (libraryModel) {
+                  var _jsonData$userData;
+                  console.log("\u23F1\uFE0F GLB loaded: ".concat(((_jsonData$userData = jsonData.userData) === null || _jsonData$userData === void 0 ? void 0 : _jsonData$userData.libraryId) || jsonData.uuid, " in ").concat((performance.now() - modelStart).toFixed(0), "ms"));
                   libraryObjectsToReplace[index].glbModel = libraryModel;
                   return libraryModel;
                 }).catch(function (error) {
-                  var _jsonData$userData;
-                  console.error("Failed to load ".concat((_jsonData$userData = jsonData.userData) === null || _jsonData$userData === void 0 ? void 0 : _jsonData$userData.libraryId, " GLB model:"), error);
+                  var _jsonData$userData2;
+                  console.error("Failed to load ".concat((_jsonData$userData2 = jsonData.userData) === null || _jsonData$userData2 === void 0 ? void 0 : _jsonData$userData2.libraryId, " GLB model:"), error);
                   return basicObject;
                 });
               });
               _context5.n = 2;
               return Promise.all(glbLoadingPromises);
             case 2:
+              console.log("\u23F1\uFE0F All GLB models loaded in ".concat((performance.now() - startTime).toFixed(0), "ms"));
+
               // Update world bounding boxes for loaded models and propagate to the live Three.js objects
               libraryObjectsToReplace.forEach(function (_ref2) {
                 var jsonData = _ref2.jsonData,
@@ -32547,9 +33369,13 @@ var SceneOperationsManager = /*#__PURE__*/function () {
     value: (function () {
       var _loadSceneData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(data) {
         var isImported,
+          timers,
+          totalStart,
+          phaseStart,
           _yield$this$_createBa,
           crosscubeTextureSet,
           libraryObjectsToReplace,
+          totalTime,
           _args4 = arguments,
           _t3;
         return _regenerator().w(function (_context4) {
@@ -32557,13 +33383,20 @@ var SceneOperationsManager = /*#__PURE__*/function () {
             case 0:
               isImported = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : true;
               this.sceneViewer;
+              timers = {};
+              totalStart = performance.now();
               _context4.p = 1;
               console.log("Loading scene data (".concat(isImported ? 'imported' : 'default', ")..."));
 
               // Phase 1: Prepare scene
+              phaseStart = performance.now();
               _context4.n = 2;
               return this._prepareSceneForLoading(data, isImported);
             case 2:
+              timers.phase1_prepare = performance.now() - phaseStart;
+
+              // Phase 2: Load dependencies and create basic objects
+              phaseStart = performance.now();
               _context4.n = 3;
               return this._createBasicSceneObjects(data);
             case 3:
@@ -32573,17 +33406,33 @@ var SceneOperationsManager = /*#__PURE__*/function () {
               _yield$this$_createBa.materials;
               crosscubeTextureSet = _yield$this$_createBa.crosscubeTextureSet;
               libraryObjectsToReplace = _yield$this$_createBa.libraryObjectsToReplace;
+              timers.phase2_createObjects = performance.now() - phaseStart;
+
+              // Phase 3: Replace basic objects with GLB models (moved before pathfinding)
+              phaseStart = performance.now();
               _context4.n = 4;
               return this.modelManager.replaceWithGLBModels(libraryObjectsToReplace);
             case 4:
+              timers.phase3_glbModels = performance.now() - phaseStart;
+
+              // Phase 4: Setup pathfinding (moved after GLB loading for consistent bounding boxes)
+              phaseStart = performance.now();
               _context4.n = 5;
               return this._setupPathfinding(data, crosscubeTextureSet);
             case 5:
+              timers.phase4_pathfinding = performance.now() - phaseStart;
+
               // Phase 5: Finalize scene
+              phaseStart = performance.now();
               this._finalizeScene(data, crosscubeTextureSet, isImported);
+              timers.phase5_finalize = performance.now() - phaseStart;
 
               // Phase 6: Load behaviors (after GLB models are present so output objects can be resolved)
+              phaseStart = performance.now();
               this._processBehaviors(data);
+              timers.phase6_behaviors = performance.now() - phaseStart;
+              totalTime = performance.now() - totalStart;
+              console.log("\u23F1\uFE0F Scene Loading Performance:\n   Phase 1 (Prepare)      : ".concat(timers.phase1_prepare.toFixed(0), "ms\n   Phase 2 (Create Objects): ").concat(timers.phase2_createObjects.toFixed(0), "ms\n   Phase 3 (GLB Models)    : ").concat(timers.phase3_glbModels.toFixed(0), "ms\n   Phase 4 (Pathfinding)   : ").concat(timers.phase4_pathfinding.toFixed(0), "ms\n   Phase 5 (Finalize)      : ").concat(timers.phase5_finalize.toFixed(0), "ms\n   Phase 6 (Behaviors)     : ").concat(timers.phase6_behaviors.toFixed(0), "ms\n   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n   Total                   : ").concat(totalTime.toFixed(0), "ms"));
               console.log('✅ Scene loaded successfully');
 
               // Notify UI components (e.g. SceneHierarchy) that the scene is fully loaded
@@ -38089,7 +38938,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.3.16
+   * @version 0.3.18
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.