@2112-lab/central-plant 0.1.39 → 0.1.41

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

@@ -0,0 +1,374 @@
+import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import 'three';
+import { Pathfinder } from '@2112-lab/pathfinder';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+import { PathData } from '../../core/pathfindingData.js';
+import { PathIntersectionDetector } from './PathIntersectionDetector.js';
+import { SceneDataManager } from './sceneDataManager.js';
+import { PathRenderingManager } from './PathRenderingManager.js';
+import { ConnectorManager } from './ConnectorManager.js';
+
+var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
+  function PathfindingManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, PathfindingManager);
+    _this = _callSuper(this, PathfindingManager);
+    _this.sceneViewer = sceneViewer;
+    _this.pathfinder = null;
+    _this.crosscubeTextureSet = null;
+    _this.pathfinderVersionInfo = null;
+
+    // Initialize scene data manager
+    _this.sceneDataManager = new SceneDataManager(sceneViewer);
+
+    // Initialize intersection detector
+    _this.intersectionDetector = new PathIntersectionDetector(sceneViewer);
+
+    // Initialize rendering manager
+    _this.renderingManager = new PathRenderingManager(sceneViewer);
+    _this.registerDisposable(_this.renderingManager);
+
+    // Initialize connector manager
+    _this.connectorManager = new ConnectorManager(sceneViewer);
+    _this.registerDisposable(_this.connectorManager);
+
+    // NEW: PathData store for business logic layer
+    _this.pathDataStore = new Map(); // pathId -> PathData
+
+    // Configuration for pathfinder grid
+    _this.pathfinderConfig = {
+      grid: {
+        size: 0.5,
+        safetyMargin: 0,
+        minSegmentLength: 0.5,
+        timeout: 1000
+      },
+      connectorBBoxSize: 0.1 // Default size for position-based connectors (Phase 2 Refactoring)
+    };
+    return _this;
+  }
+
+  /**
+   * Export path data as JSON
+   * @returns {Array<Object>} Array of serialized PathData objects
+   */
+  _inherits(PathfindingManager, _BaseDisposable);
+  return _createClass(PathfindingManager, [{
+    key: "exportData",
+    value: function exportData() {
+      var exportData = Array.from(this.pathDataStore.values()).map(function (pathData) {
+        return pathData.toJSON();
+      });
+      console.log("\uD83D\uDCE4 Exported ".concat(exportData.length, " path data objects"));
+      return exportData;
+    }
+
+    /**
+     * Import path data from JSON
+     * @param {Array<Object>} jsonArray - Array of serialized PathData objects
+     */
+  }, {
+    key: "importData",
+    value: function importData(jsonArray) {
+      var _this2 = this;
+      if (!Array.isArray(jsonArray)) {
+        console.error('❌ importData expects an array');
+        return;
+      }
+      this.pathDataStore.clear();
+      jsonArray.forEach(function (json) {
+        try {
+          var pathData = PathData.fromJSON(json);
+          _this2.pathDataStore.set(pathData.pathId, pathData);
+          console.log("\uD83D\uDCE5 Imported PathData: ".concat(pathData.pathId));
+        } catch (error) {
+          console.error('❌ Error importing PathData:', error);
+        }
+      });
+      console.log("\u2705 Imported ".concat(this.pathDataStore.size, " path data objects"));
+    }
+
+    // ============================================================================
+    // END NEW ADAPTER METHODS
+    // ============================================================================
+
+    /**
+     * Core pathfinding logic shared across initialization and updates
+     */
+  }, {
+    key: "_executePathfinding",
+    value: function () {
+      var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(sceneData, connections) {
+        var _simplifiedSceneData$;
+        var options,
+          _options$context,
+          context,
+          connectionsCopy,
+          simplifiedSceneData,
+          pathfindingResult,
+          intersectionCheck,
+          _args = arguments;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+              options.createGateways, _options$context = options.context, context = _options$context === void 0 ? 'Pathfinding' : _options$context; // Create pathfinder instance with configuration only
+              this.pathfinder = new Pathfinder(this.pathfinderConfig);
+              this.sceneViewer.pathfinder = this.pathfinder;
+
+              // Ensure all matrices are up to date before bounding box calculations (for all pathfinding executions)
+              this.sceneViewer.scene.updateMatrixWorld(true);
+              console.log("\uD83D\uDD04 Updated matrix world for ".concat(context, " pathfinding execution"));
+
+              // Deep copy connections to prevent pathfinder from mutating the original
+              connectionsCopy = JSON.parse(JSON.stringify(connections));
+              simplifiedSceneData = JSON.parse(JSON.stringify(this.getSimplifiedSceneData()));
+              console.log('[Pathfinder] simplifiedSceneData length at creation:', (_simplifiedSceneData$ = simplifiedSceneData.children) === null || _simplifiedSceneData$ === void 0 ? void 0 : _simplifiedSceneData$.length);
+              console.log('[Pathfinder] simplifiedSceneData (deep clone for inspection):', JSON.parse(JSON.stringify(simplifiedSceneData)));
+
+              // Add debugging for pathfinder input
+              console.log('🔍 PATHFINDER DEBUGGING:');
+              console.log('🔗 [Pathfinder] Connections:', JSON.parse(JSON.stringify(connectionsCopy)));
+
+              // Find paths using v1.0.17 API (sceneData and connections separately)
+              // Pass deep copy to ensure pathfinder cannot mutate original connections
+              pathfindingResult = this.pathfinder.findPaths(simplifiedSceneData, connectionsCopy);
+              console.log('[Pathfinder] Found paths:', JSON.parse(JSON.stringify(pathfindingResult.paths)));
+              console.log('Generated gateways:', JSON.parse(JSON.stringify(pathfindingResult.gateways)));
+              console.log('Rewired connections:', JSON.parse(JSON.stringify(pathfindingResult.rewiredConnections)));
+              console.log("intersectionCheck input:", pathfindingResult.paths);
+
+              // Check for path intersections (including manual segments)
+              intersectionCheck = this.checkPathIntersections(pathfindingResult.paths, 0.2, true);
+              pathfindingResult.intersections = intersectionCheck;
+              console.log("intersectionCheck:", intersectionCheck);
+              console.log("intersectionCheck.hasIntersections:", intersectionCheck.hasIntersections);
+
+              // // Handle intersection detection - undo last operation if intersections found
+              // if (intersectionCheck.hasIntersections) {
+              //   console.warn('⚠️ Path intersections detected! Attempting to undo last operation...');
+
+              //   // Access operationHistoryManager through sceneViewer.managers.operationHistory
+              //   const operationHistoryManager = this.sceneViewer?.managers?.operationHistory;
+
+              //   if (operationHistoryManager) {
+              //     const lastOp = operationHistoryManager.getLastOperation();
+
+              //     if (lastOp) {
+              //       console.warn(`⚠️ Intersection caused by operation: ${lastOp.operationName}`, lastOp.params);
+
+              //       // Attempt to undo the operation
+              //       const undoSuccess = operationHistoryManager.undoLastOperation();
+
+              //       if (undoSuccess) {
+              //         console.log('✅ Successfully undid operation that caused intersection');
+
+              //         // Re-run pathfinding after undo to restore valid state
+              //         console.log('🔄 Re-running pathfinding after undo...');
+
+              //         // Note: We don't recursively call _executePathfinding here to avoid potential infinite loops
+              //         // Instead, the calling code (updatePathfindingAfterTransform) will handle re-execution
+              //         pathfindingResult.undoPerformed = true;
+              //         pathfindingResult.undoneOperation = lastOp;
+              //       } else {
+              //         console.error('❌ Failed to undo operation that caused intersection');
+              //         pathfindingResult.undoFailed = true;
+              //       }
+              //     } else {
+              //       console.warn('⚠️ No operation in history to undo');
+              //     }
+              //   } else {
+              //     console.error('❌ OperationHistoryManager not available for undo');
+              //     console.error('  Available managers:', Object.keys(this.sceneViewer?.managers || {}));
+              //   }
+              // }
+
+              // Create gateways in the scene if requested
+              if (options.createGateways && pathfindingResult.gateways) {
+                this.renderingManager.createGateways(pathfindingResult);
+              }
+              console.log("pathfindingResult.paths:", pathfindingResult.paths);
+
+              // Create pipe paths with materials using the paths from pathfinder
+              this.renderingManager.createPipePaths(pathfindingResult.paths, this.crosscubeTextureSet);
+              return _context.a(2, pathfindingResult);
+          }
+        }, _callee, this);
+      }));
+      function _executePathfinding(_x, _x2) {
+        return _executePathfinding2.apply(this, arguments);
+      }
+      return _executePathfinding;
+    }()
+  }, {
+    key: "getSimplifiedSceneData",
+    value: function getSimplifiedSceneData() {
+      return this.sceneDataManager.getSimplifiedSceneData();
+    }
+
+    /**
+     * Initialize pathfinder and create paths
+     */
+  }, {
+    key: "initializePathfinder",
+    value: (function () {
+      var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(data, crosscubeTextureSet) {
+        var pathfindingResult;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              this.crosscubeTextureSet = crosscubeTextureSet;
+
+              // Use shared pathfinding logic with gateway creation enabled
+              _context2.n = 1;
+              return this._executePathfinding(data.scene, data.connections, {
+                createGateways: true,
+                context: 'Scene Loading'
+              });
+            case 1:
+              pathfindingResult = _context2.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 _context2.a(2, pathfindingResult);
+          }
+        }, _callee2, this);
+      }));
+      function initializePathfinder(_x3, _x4) {
+        return _initializePathfinder.apply(this, arguments);
+      }
+      return initializePathfinder;
+    }()
+    /**
+     * Remove all computed objects from the scene (segments, elbows, and gateways)
+     */
+    )
+  }, {
+    key: "removeComputedObjects",
+    value: function removeComputedObjects() {
+      var sceneViewer = this.sceneViewer;
+      console.log("removeComputedObjects started");
+      var objectsToRemove = [];
+      sceneViewer.scene.traverse(function (obj) {
+        // Remove computed Segments (uppercase SEGMENT-)
+        if (obj.uuid && obj.uuid.startsWith("SEGMENT-")) {
+          console.log("[removeComputedObjects] to be removed: ".concat(obj.uuid, ")"));
+          objectsToRemove.push(obj);
+        }
+        // Remove computed Elbows
+        if (obj.userData && obj.userData.isPipeElbow && obj.userData.isDeclared !== true) {
+          console.log("[removeComputedObjects] to be removed: ".concat(obj.uuid, ")"));
+          objectsToRemove.push(obj);
+        }
+        // Also remove computed Gateways
+        if (obj.uuid && obj.uuid.includes("Gateway") && obj.userData && obj.userData.isDeclared !== true) {
+          console.log("[removeComputedObjects] to be removed: ".concat(obj.uuid));
+          objectsToRemove.push(obj);
+        }
+      });
+
+      // console.log(`[removeComputedObjects] objectsToRemove:`, objectsToRemove);
+
+      for (var _i = 0, _objectsToRemove = objectsToRemove; _i < _objectsToRemove.length; _i++) {
+        var obj = _objectsToRemove[_i];
+        sceneViewer.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, " computed objects from scene (segments, elbows, and gateways)"));
+    }
+
+    /**
+     * Check for intersections between paths
+     * Delegates to PathIntersectionDetector for the actual detection logic
+     * @param {Array} paths - Array of path objects from pathfinder
+     * @param {number} tolerance - Distance tolerance for considering pipes as intersecting (default: 0.2)
+     * @param {boolean} includeManualSegments - Whether to include manual segments in the check (default: true)
+     * @returns {Object} Intersection results
+     * @property {boolean} hasIntersections - Whether any intersections were found
+     * @property {Array<Object>} intersections - Array of intersection details
+     * @property {number} count - Total number of intersections found
+     */
+  }, {
+    key: "checkPathIntersections",
+    value: function checkPathIntersections(paths) {
+      var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.2;
+      var includeManualSegments = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      return this.intersectionDetector.checkPathIntersections(paths, tolerance, includeManualSegments);
+    }
+
+    /**
+     * Update pathfinding after object transforms
+     */
+  }, {
+    key: "updatePathfindingAfterTransform",
+    value: (function () {
+      var _updatePathfindingAfterTransform = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(currentSceneData) {
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              // Remove all existing paths from the scene
+              this.removeComputedObjects();
+              console.log('🔄 Starting pathfinding with updated scene data...');
+
+              // Note: Matrix updates and bounding box recomputation now handled in _executePathfinding
+              // Use shared pathfinding logic (no gateways needed for transform updates)
+              _context3.n = 1;
+              return this._executePathfinding(currentSceneData.scene, currentSceneData.connections, {
+                createGateways: true,
+                context: 'Transform Update'
+              });
+            case 1:
+              return _context3.a(2);
+          }
+        }, _callee3, this);
+      }));
+      function updatePathfindingAfterTransform(_x5) {
+        return _updatePathfindingAfterTransform.apply(this, arguments);
+      }
+      return updatePathfindingAfterTransform;
+    }()
+    /**
+     * Dispose of pathfinding resources
+     */
+    )
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      console.log('🗑️ Disposing PathfindingManager...');
+
+      // Clear path data store
+      if (this.pathDataStore) {
+        this.pathDataStore.clear();
+        console.log('✅ Cleared pathDataStore');
+      }
+
+      // Remove computed objects
+      this.removeComputedObjects();
+
+      // Call parent dispose to clean up registered resources
+      _superPropGet(PathfindingManager, "dispose", this, 3)([]);
+
+      // Nullify properties
+      this.pathfinder = null;
+      this.crosscubeTextureSet = null;
+      this.pathfinderVersionInfo = null;
+      this.sceneViewer = null;
+      console.log('✅ PathfindingManager disposed');
+    }
+  }]);
+}(BaseDisposable);
+
+export { PathfindingManager };

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

@@ -0,0 +1,232 @@
+import { createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+
+/**
+ * SceneDataManager
+ * Utility class for managing scene data transformations and queries
+ * Handles scene structure flattening, simplification, and object lookups
+ */
+var SceneDataManager = /*#__PURE__*/function () {
+  function SceneDataManager(sceneViewer) {
+    _classCallCheck(this, SceneDataManager);
+    this.sceneViewer = sceneViewer;
+  }
+
+  /**
+   * Get simplified scene data for pathfinding
+   * Collects all objects with objectType, filters out computed objects,
+   * and calculates world bounding boxes
+   * @returns {Object} Simplified scene data with children array
+   */
+  return _createClass(SceneDataManager, [{
+    key: "getSimplifiedSceneData",
+    value: function getSimplifiedSceneData() {
+      // Collect all objects with objectType (flattened list from scene traversal)
+      // Filter out ALL computed objects - only include declared/source objects
+      var sceneDataNew = [];
+      this.sceneViewer.scene.traverse(function (obj) {
+        if (obj.userData && obj.userData.objectType) {
+          // Skip computed gateways (only include declared/manual gateways)
+          if (obj.userData.objectType === 'gateway' && !obj.userData.isDeclared) {
+            return;
+          }
+          sceneDataNew.push(obj);
+        }
+      });
+      console.log('🔗 [SceneDataManager] sceneDataNew (flattened):', sceneDataNew);
+
+      // Calculate world bounding boxes for each object individually (after flattening)
+      // This way we don't need to worry about children - each object is standalone
+      var simplifiedSceneData = {};
+      simplifiedSceneData.children = sceneDataNew.map(function (obj) {
+        var _obj$children;
+        var uuid = obj.uuid;
+
+        // Calculate world bounding box for this individual object
+        var worldBoundingBox = null;
+
+        // For meshes, calculate bbox from geometry only (ignoring children)
+        if (obj.isMesh && obj.geometry) {
+          try {
+            // Compute bounding box from geometry in world space
+            var bbox = new THREE.Box3();
+            obj.geometry.computeBoundingBox();
+            if (obj.geometry.boundingBox) {
+              // Transform local bbox to world space
+              bbox.copy(obj.geometry.boundingBox);
+              bbox.applyMatrix4(obj.matrixWorld);
+
+              // Only include valid bounding boxes
+              // Check if all components of min and max are finite numbers
+              var isValidBBox = !bbox.isEmpty() && isFinite(bbox.min.x) && isFinite(bbox.min.y) && isFinite(bbox.min.z) && isFinite(bbox.max.x) && isFinite(bbox.max.y) && isFinite(bbox.max.z);
+              if (isValidBBox) {
+                worldBoundingBox = {
+                  min: bbox.min.toArray(),
+                  max: bbox.max.toArray()
+                };
+              } else {
+                console.warn("\u26A0\uFE0F Invalid bounding box for ".concat(uuid, ", skipping"));
+              }
+            }
+          } catch (error) {
+            console.warn("\u26A0\uFE0F Failed to calculate bounding box for ".concat(uuid, ":"), error);
+          }
+        }
+        // For groups or objects with children, use setFromObject but only on this object
+        else if (obj.isGroup || ((_obj$children = obj.children) === null || _obj$children === void 0 ? void 0 : _obj$children.length) > 0) {
+          try {
+            var _bbox = new THREE.Box3().setFromObject(obj);
+
+            // Check if all components of min and max are finite numbers
+            var _isValidBBox = !_bbox.isEmpty() && isFinite(_bbox.min.x) && isFinite(_bbox.min.y) && isFinite(_bbox.min.z) && isFinite(_bbox.max.x) && isFinite(_bbox.max.y) && isFinite(_bbox.max.z);
+            if (_isValidBBox) {
+              worldBoundingBox = {
+                min: _bbox.min.toArray(),
+                max: _bbox.max.toArray()
+              };
+            }
+          } catch (error) {
+            console.warn("\u26A0\uFE0F Failed to calculate bounding box for ".concat(uuid, ":"), error);
+          }
+        }
+        var results = {
+          uuid: uuid,
+          userData: _objectSpread2(_objectSpread2({}, obj.userData), worldBoundingBox && {
+            worldBoundingBox: worldBoundingBox
+          })
+        };
+        if (obj.userData.objectType.includes('connector') || obj.userData.objectType === 'gateway') {
+          var worldPosition = new THREE.Vector3();
+          obj.getWorldPosition(worldPosition);
+          results.userData.position = [worldPosition.x, worldPosition.y, worldPosition.z];
+        }
+        return results;
+      });
+      return simplifiedSceneData;
+    }
+
+    /**
+     * Helper method to find an object in scene data by UUID
+     * @param {Object} sceneData - Scene data to search
+     * @param {string} uuid - UUID to find
+     * @returns {Object|null} Found object or null
+     */
+  }, {
+    key: "findObjectInSceneData",
+    value: function findObjectInSceneData(sceneData, uuid) {
+      var _searchChildren = function searchChildren(children) {
+        var _iterator = _createForOfIteratorHelper(children),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var child = _step.value;
+            if (child.uuid === uuid) {
+              return child;
+            }
+            if (child.children) {
+              var found = _searchChildren(child.children);
+              if (found) return found;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        return null;
+      };
+      if (sceneData.children) {
+        return _searchChildren(sceneData.children);
+      }
+      return null;
+    }
+
+    /**
+     * Mark an object as declared (manual) in both the scene object and scene data
+     * @param {THREE.Object3D} object - The object to mark as declared
+     * @param {Object} currentSceneData - Current scene data
+     * @param {Object} additionalSceneDataProps - Additional properties to add to scene data (optional)
+     */
+  }, {
+    key: "markObjectAsDeclared",
+    value: function markObjectAsDeclared(object, currentSceneData) {
+      var additionalSceneDataProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      // Mark in the scene object
+      object.userData.isDeclared = true;
+
+      // Find and update in scene data
+      var foundInSceneData = false;
+      for (var i = 0; i < currentSceneData.scene.children.length; i++) {
+        var _object$userData, _child$userData;
+        var child = currentSceneData.scene.children[i];
+        if (child.uuid === object.uuid || child.uuid === ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.originalUuid) || object.uuid === ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid)) {
+          var _object$userData2, _object$userData3;
+          if (!child.userData) child.userData = {};
+          child.userData.isDeclared = true;
+
+          // Update position in scene data
+          if (!child.position) {
+            child.position = {};
+          }
+          child.position.x = object.position.x;
+          child.position.y = object.position.y;
+          child.position.z = object.position.z;
+
+          // For gateways and connectors, also update userData.position array for pathfinder compatibility
+          if (((_object$userData2 = object.userData) === null || _object$userData2 === void 0 ? void 0 : _object$userData2.objectType) === 'gateway' || ((_object$userData3 = object.userData) === null || _object$userData3 === void 0 ? void 0 : _object$userData3.objectType) === 'connector') {
+            child.userData.position = [object.position.x, object.position.y, object.position.z];
+          }
+          console.log("\u2705 Marked object as declared and updated position in scene data: ".concat(child.uuid));
+          foundInSceneData = true;
+          break;
+        }
+      }
+
+      // If not found in scene data, add it
+      if (!foundInSceneData) {
+        var _object$userData4, _object$userData5, _object$userData6;
+        console.log("\u26A0\uFE0F Object ".concat(object.uuid, " not found in scene data, adding it now"));
+        var sceneDataObject = _objectSpread2({
+          uuid: object.uuid,
+          userData: _objectSpread2({
+            objectType: object.userData.objectType,
+            isDeclared: true
+          }, object.userData),
+          position: {
+            x: object.position.x,
+            y: object.position.y,
+            z: object.position.z
+          }
+        }, additionalSceneDataProps);
+
+        // For gateways and connectors, also add position array to userData for pathfinder compatibility
+        if (((_object$userData4 = object.userData) === null || _object$userData4 === void 0 ? void 0 : _object$userData4.objectType) === 'gateway' || ((_object$userData5 = object.userData) === null || _object$userData5 === void 0 ? void 0 : _object$userData5.objectType) === 'connector') {
+          sceneDataObject.userData.position = [object.position.x, object.position.y, object.position.z];
+        }
+
+        // For segments, initialize children array to hold connectors
+        if (((_object$userData6 = object.userData) === null || _object$userData6 === void 0 ? void 0 : _object$userData6.objectType) === 'segment') {
+          sceneDataObject.children = [];
+          console.log("\uD83D\uDCE6 Initialized children array for segment: ".concat(object.uuid));
+        }
+        currentSceneData.scene.children.push(sceneDataObject);
+        console.log("\u2705 Added object to scene data as declared: ".concat(object.uuid));
+      } else {
+        var _object$userData8;
+        // If segment was found in scene data, ensure it has a children array
+        var _child = currentSceneData.scene.children.find(function (c) {
+          var _object$userData7, _c$userData;
+          return c.uuid === object.uuid || c.uuid === ((_object$userData7 = object.userData) === null || _object$userData7 === void 0 ? void 0 : _object$userData7.originalUuid) || object.uuid === ((_c$userData = c.userData) === null || _c$userData === void 0 ? void 0 : _c$userData.originalUuid);
+        });
+        if (_child && ((_object$userData8 = object.userData) === null || _object$userData8 === void 0 ? void 0 : _object$userData8.objectType) === 'segment') {
+          if (!_child.children) {
+            _child.children = [];
+            console.log("\uD83D\uDCE6 Initialized children array for existing segment: ".concat(_child.uuid));
+          }
+        }
+      }
+    }
+  }]);
+}();
+
+export { SceneDataManager };