@2112-lab/central-plant 0.1.91 → 0.1.93

package/dist/bundle/index.js

@@ -11518,10 +11518,23 @@ var SceneExportManager = /*#__PURE__*/function () {
       // Helper function to extract behaviors from current scene data
       var extractBehaviors = function extractBehaviors() {
         var _this$sceneViewer, _this$sceneViewer2;
+        // Only export behaviors that are NOT re-derivable from a component's
+        // defaultBehaviors[].  All component/device default behaviors are
+        // reconstructed at load time by Step B of _processBehaviors() using the
+        // component dictionary, so writing compact behaviorRef entries for them
+        // would be redundant.  The scene JSON behaviors[] array is reserved for
+        // any future scene-level overrides that cannot be derived from the asset.
         if ((_this$sceneViewer = _this.sceneViewer) !== null && _this$sceneViewer !== void 0 && (_this$sceneViewer = _this$sceneViewer.managers) !== null && _this$sceneViewer !== void 0 && _this$sceneViewer.behaviorManager) {
-          return _this.sceneViewer.managers.behaviorManager.getBehaviors();
+          return _this.sceneViewer.managers.behaviorManager.getBehaviors().filter(function (b) {
+            return !b._isDefaultBehavior;
+          });
         }
-        return ((_this$sceneViewer2 = _this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.currentSceneData) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.behaviors) || [];
+        // Fallback when BehaviorManager is not available: exclude any entry that
+        // was already a behaviorRef (it was derivable from the component asset)
+        // and exclude the legacy _isDefaultBehavior marker if present.
+        return (((_this$sceneViewer2 = _this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.currentSceneData) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.behaviors) || []).filter(function (b) {
+          return !b.behaviorRef && !b._isDefaultBehavior;
+        });
       };
 
       // Build the complete export data structure (matching central-plant-input.json format)
@@ -19510,62 +19523,43 @@ var ComponentDataManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "_loadComponentDictionary",
     value: (function () {
       var _loadComponentDictionary2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
-        var _yield$import, getCachedLocalJson, response, _t4, _t5;
+        var response, _t4;
         return _regenerator().w(function (_context6) {
           while (1) switch (_context6.n) {
             case 0:
               _context6.p = 0;
-              if (!(typeof window !== 'undefined' && 'caches' in window)) {
-                _context6.n = 5;
-                break;
-              }
-              _context6.p = 1;
-              _context6.n = 2;
-              return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('~/utils/s3Cache')); });
-            case 2:
-              _yield$import = _context6.v;
-              getCachedLocalJson = _yield$import.getCachedLocalJson;
-              _context6.n = 3;
-              return getCachedLocalJson('/library/component-dictionary.json');
-            case 3:
-              this.componentDictionary = _context6.v;
-              console.log('📚 ComponentDataManager: Component dictionary loaded from cache');
-              return _context6.a(2);
-            case 4:
-              _context6.p = 4;
-              _t4 = _context6.v;
-              console.warn('⚠️ ComponentDataManager: Cache load failed, falling back to direct fetch:', _t4);
-            case 5:
-              _context6.n = 6;
-              return fetch('/library/component-dictionary.json');
-            case 6:
+              _context6.n = 1;
+              return fetch('/library/component-dictionary.json', {
+                cache: 'no-cache'
+              });
+            case 1:
               response = _context6.v;
               if (!response.ok) {
-                _context6.n = 8;
+                _context6.n = 3;
                 break;
               }
-              _context6.n = 7;
+              _context6.n = 2;
               return response.json();
-            case 7:
+            case 2:
               this.componentDictionary = _context6.v;
               console.log('📚 ComponentDataManager: Component dictionary loaded successfully');
-              _context6.n = 9;
+              _context6.n = 4;
               break;
-            case 8:
+            case 3:
               console.warn('⚠️ ComponentDataManager: Could not load component dictionary');
               this.componentDictionary = null;
-            case 9:
-              _context6.n = 11;
+            case 4:
+              _context6.n = 6;
               break;
-            case 10:
-              _context6.p = 10;
-              _t5 = _context6.v;
-              console.warn('⚠️ ComponentDataManager: Error loading component dictionary:', _t5);
+            case 5:
+              _context6.p = 5;
+              _t4 = _context6.v;
+              console.warn('⚠️ ComponentDataManager: Error loading component dictionary:', _t4);
               this.componentDictionary = null;
-            case 11:
+            case 6:
               return _context6.a(2);
           }
-        }, _callee6, this, [[1, 4], [0, 10]]);
+        }, _callee6, this, [[0, 5]]);
       }));
       function _loadComponentDictionary() {
         return _loadComponentDictionary2.apply(this, arguments);
@@ -19814,6 +19808,8 @@ var ComponentDataManager = /*#__PURE__*/function (_BaseDisposable) {
         boundingBox: component.boundingBox || null,
         adaptedBoundingBox: component.adaptedBoundingBox || null,
         children: component.children || [],
+        meshChildren: component.meshChildren || [],
+        defaultBehaviors: component.defaultBehaviors || [],
         specifications: ((_component$metadata2 = component.metadata) === null || _component$metadata2 === void 0 ? void 0 : _component$metadata2.specifications) || {},
         description: ((_component$metadata3 = component.metadata) === null || _component$metadata3 === void 0 ? void 0 : _component$metadata3.description) || ''
       });
@@ -28675,9 +28671,7 @@ function _attachIODevicesToComponent() {
             // ioConfig can use either 'states' (preferred) or legacy 'dataPoints' as the array key
             dataPoints: ((_deviceData$ioConfig = deviceData.ioConfig) === null || _deviceData$ioConfig === void 0 ? void 0 : _deviceData$ioConfig.states) || ((_deviceData$ioConfig2 = deviceData.ioConfig) === null || _deviceData$ioConfig2 === void 0 ? void 0 : _deviceData$ioConfig2.dataPoints) || [],
             // Device-level I/O direction: 'input' means the user can write state via the tooltip
-            ioDirection: ((_deviceData$ioConfig3 = deviceData.ioConfig) === null || _deviceData$ioConfig3 === void 0 ? void 0 : _deviceData$ioConfig3.direction) || 'output',
-            // Signal wiring sourced from this attachment (for state propagation reference)
-            signalOutputs: attachment.signalOutputs || []
+            ioDirection: ((_deviceData$ioConfig3 = deviceData.ioConfig) === null || _deviceData$ioConfig3 === void 0 ? void 0 : _deviceData$ioConfig3.direction) || 'output'
           };
 
           // Position at the attachment point
@@ -31064,20 +31058,252 @@ var SceneOperationsManager = /*#__PURE__*/function () {
     }
 
     /**
-     * Process behaviors from the scene data and pass them to the BehaviorManager.
+     * Process behaviors from the scene data, expand any defaultBehaviors defined
+     * on component dictionary entries, resolve behaviorRef entries against device
+     * assets, inject per-instance component UUIDs, and hand the flat resolved
+     * array to BehaviorManager.
+     *
+     * Resolution cascade:
+     *   1. Explicit behaviors in data.behaviors — passed through as-is (behaviorRef
+     *      entries are resolved against the component/device dictionaries).
+     *   2. defaultBehaviors[] on each placed smart component's dictionary entry —
+     *      expanded per instance with the instance UUID injected.  Compact
+     *      behaviorRef-derived entries are tagged _isDefaultBehavior:true (the
+     *      exporter can re-derive them); full L2 behavior objects are tagged false
+     *      so they are exported verbatim and survive round-trips.
+     *
      * @param {Object} data - Scene JSON data
      */
   }, {
     key: "_processBehaviors",
     value: function _processBehaviors(data) {
-      var _this$sceneViewer2;
-      if (!(data !== null && data !== void 0 && data.behaviors) || !Array.isArray(data.behaviors)) return;
+      var _this$sceneViewer2,
+        _this$sceneViewer$cen2,
+        _this5 = this,
+        _data$scene3;
       var behaviorManager = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.managers) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.behaviorManager;
       if (!behaviorManager) {
         console.warn('⚠️ _processBehaviors: BehaviorManager not available');
         return;
       }
-      behaviorManager.loadBehaviors(data.behaviors);
+
+      // Obtain the component dictionary (extended = includes S3/smart components)
+      var componentDictionary = ((_this$sceneViewer$cen2 = this.sceneViewer.centralPlant) === null || _this$sceneViewer$cen2 === void 0 || (_this$sceneViewer$cen2 = _this$sceneViewer$cen2.managers) === null || _this$sceneViewer$cen2 === void 0 || (_this$sceneViewer$cen2 = _this$sceneViewer$cen2.componentDataManager) === null || _this$sceneViewer$cen2 === void 0 ? void 0 : _this$sceneViewer$cen2.componentDictionary) || {};
+
+      // ── Step A: Resolve any behaviorRef entries from data.behaviors ─────────
+      var explicitBehaviors = [];
+      if (Array.isArray(data === null || data === void 0 ? void 0 : data.behaviors)) {
+        data.behaviors.forEach(function (entry) {
+          if (entry.behaviorRef) {
+            var resolved = _this5._resolveBehaviorRef(entry, componentDictionary);
+            if (resolved) explicitBehaviors.push(resolved);
+          } else {
+            explicitBehaviors.push(entry);
+          }
+        });
+      }
+
+      // Build a set of explicit behavior ids for deduplication
+      var explicitIds = new Set(explicitBehaviors.map(function (b) {
+        return b.id;
+      }));
+
+      // Build a set of instanceUuids already covered by behaviorRef entries in
+      // data.behaviors (written by the exporter for smart component defaults).
+      // Step B skips these instances to avoid loading the same behaviors twice —
+      // once via Step A (resolved from data.behaviors refs) and once via Step B
+      // (auto-expanded from the component dictionary).
+      var coveredInstances = new Set();
+      if (Array.isArray(data === null || data === void 0 ? void 0 : data.behaviors)) {
+        data.behaviors.forEach(function (entry) {
+          if (entry.behaviorRef && entry.component) {
+            coveredInstances.add(entry.component);
+          }
+        });
+      }
+
+      // ── Step B: Walk placed components and expand their defaultBehaviors ─────
+      var instanceBehaviors = [];
+      if (Array.isArray(data === null || data === void 0 || (_data$scene3 = data.scene) === null || _data$scene3 === void 0 ? void 0 : _data$scene3.children)) {
+        data.scene.children.forEach(function (child) {
+          var _child$userData0, _compData$defaultBeha;
+          var libraryId = (_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.libraryId;
+          if (!libraryId) return;
+          var instanceUuid = child.uuid;
+          // Skip instances whose defaults were already resolved by Step A
+          // (they have explicit behaviorRef entries in data.behaviors).
+          if (coveredInstances.has(instanceUuid)) return;
+          var compData = componentDictionary[libraryId];
+          if (!(compData !== null && compData !== void 0 && (_compData$defaultBeha = compData.defaultBehaviors) !== null && _compData$defaultBeha !== void 0 && _compData$defaultBeha.length)) return;
+          compData.defaultBehaviors.forEach(function (template) {
+            var expanded = _this5._expandDefaultBehavior(template, instanceUuid, componentDictionary);
+            if (!expanded) return;
+            // Skip if an explicit scene behavior already covers this id
+            if (explicitIds.has(expanded.id)) return;
+            // All component defaultBehaviors are re-derivable from the component
+            // asset at export time (via compact behaviorRef), so mark them all.
+            expanded._isDefaultBehavior = true;
+            instanceBehaviors.push(expanded);
+          });
+        });
+      }
+      var allBehaviors = [].concat(explicitBehaviors, instanceBehaviors);
+      if (allBehaviors.length === 0) return;
+      behaviorManager.loadBehaviors(allBehaviors);
+      console.log("\u2705 _processBehaviors: loaded ".concat(explicitBehaviors.length, " explicit + ").concat(instanceBehaviors.length, " default-expanded behavior(s)"));
+    }
+
+    /**
+     * Register the defaultBehaviors of a single newly placed component instance
+     * into the BehaviorManager.  Called from addComponent() (drag-drop), where
+     * _processBehaviors() (scene-load path) is not invoked.
+     *
+     * @param {Object} componentData - Entry from the component dictionary
+     * @param {string} instanceUuid  - UUID of the placed component (componentModel.uuid)
+     */
+  }, {
+    key: "registerBehaviorsForComponentInstance",
+    value: function registerBehaviorsForComponentInstance(componentData, instanceUuid) {
+      var _this$sceneViewer3,
+        _componentData$defaul,
+        _this$sceneViewer$cen3,
+        _this6 = this;
+      var behaviorManager = (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.managers) === null || _this$sceneViewer3 === void 0 ? void 0 : _this$sceneViewer3.behaviorManager;
+      if (!behaviorManager) return;
+      if (!(componentData !== null && componentData !== void 0 && (_componentData$defaul = componentData.defaultBehaviors) !== null && _componentData$defaul !== void 0 && _componentData$defaul.length)) return;
+      var componentDictionary = ((_this$sceneViewer$cen3 = this.sceneViewer.centralPlant) === null || _this$sceneViewer$cen3 === void 0 || (_this$sceneViewer$cen3 = _this$sceneViewer$cen3.managers) === null || _this$sceneViewer$cen3 === void 0 || (_this$sceneViewer$cen3 = _this$sceneViewer$cen3.componentDataManager) === null || _this$sceneViewer$cen3 === void 0 ? void 0 : _this$sceneViewer$cen3.componentDictionary) || {};
+      var registered = 0;
+      componentData.defaultBehaviors.forEach(function (template) {
+        var expanded = _this6._expandDefaultBehavior(template, instanceUuid, componentDictionary);
+        if (!expanded) return;
+        expanded._isDefaultBehavior = true;
+        behaviorManager.addBehavior(expanded);
+        registered++;
+      });
+      if (registered > 0) {
+        console.log("\u2705 registerBehaviorsForComponentInstance: registered ".concat(registered, " behavior(s) for instance ").concat(instanceUuid));
+      }
+    }
+
+    /**
+     * Resolve a scene-level or component-level behaviorRef entry into a full
+     * behavior definition by looking up the referenced template in the device
+     * asset's defaultBehaviors[] and substituting 'self' with the real
+     * attachmentId.
+     *
+     * Ref shape: { behaviorRef, deviceId, attachment, component? }
+     *
+     * @param {Object} ref
+     * @param {Object} componentDictionary
+     * @returns {Object|null} Resolved behavior or null if not found
+     */
+  }, {
+    key: "_resolveBehaviorRef",
+    value: function _resolveBehaviorRef(ref, componentDictionary) {
+      var _resolved$input, _resolved$output;
+      if (!ref.behaviorRef) {
+        console.warn('⚠️ _resolveBehaviorRef: missing behaviorRef', ref);
+        return null;
+      }
+
+      // ── Component-level L2 ref: { behaviorRef, libraryId, component } ──────
+      // The full behavior template lives on the smart component's defaultBehaviors[].
+      // No 'self' substitution needed — attachment IDs are already real.
+      if (ref.libraryId) {
+        var compData = componentDictionary[ref.libraryId];
+        if (!compData) {
+          console.warn("\u26A0\uFE0F _resolveBehaviorRef: component \"".concat(ref.libraryId, "\" not in dictionary"));
+          return null;
+        }
+        var _template = (compData.defaultBehaviors || []).find(function (b) {
+          return b.id === ref.behaviorRef;
+        });
+        if (!_template) {
+          console.warn("\u26A0\uFE0F _resolveBehaviorRef: behavior \"".concat(ref.behaviorRef, "\" not found on component \"").concat(ref.libraryId, "\""));
+          return null;
+        }
+        var _resolved = JSON.parse(JSON.stringify(_template));
+        _resolved.id = "".concat(_resolved.id, "::").concat(ref.component);
+        if (ref.component) {
+          _resolved.input = _objectSpread2(_objectSpread2({}, _resolved.input), {}, {
+            component: ref.component
+          });
+          _resolved.output = _objectSpread2(_objectSpread2({}, _resolved.output), {}, {
+            component: ref.component
+          });
+        }
+        return _resolved;
+      }
+
+      // ── Device-level L1 ref: { behaviorRef, deviceId, attachment, component } ─
+      if (!ref.deviceId || !ref.attachment) {
+        console.warn('⚠️ _resolveBehaviorRef: incomplete ref', ref);
+        return null;
+      }
+      var deviceData = componentDictionary[ref.deviceId];
+      if (!deviceData) {
+        console.warn("\u26A0\uFE0F _resolveBehaviorRef: device \"".concat(ref.deviceId, "\" not in dictionary"));
+        return null;
+      }
+      var template = (deviceData.defaultBehaviors || []).find(function (b) {
+        return b.id === ref.behaviorRef;
+      });
+      if (!template) {
+        console.warn("\u26A0\uFE0F _resolveBehaviorRef: behavior \"".concat(ref.behaviorRef, "\" not found on device \"").concat(ref.deviceId, "\""));
+        return null;
+      }
+      // Deep clone and substitute 'self' -> real attachmentId
+      var resolved = JSON.parse(JSON.stringify(template));
+      resolved.id = "".concat(resolved.id, "::").concat(ref.attachment);
+      if (((_resolved$input = resolved.input) === null || _resolved$input === void 0 ? void 0 : _resolved$input.attachment) === 'self') resolved.input.attachment = ref.attachment;
+      if (((_resolved$output = resolved.output) === null || _resolved$output === void 0 ? void 0 : _resolved$output.attachment) === 'self') resolved.output.attachment = ref.attachment;
+      // Inject component UUID guard if the ref carries one
+      if (ref.component) {
+        resolved.input = _objectSpread2(_objectSpread2({}, resolved.input), {}, {
+          component: ref.component
+        });
+        resolved.output = _objectSpread2(_objectSpread2({}, resolved.output), {}, {
+          component: ref.component
+        });
+      }
+      return resolved;
+    }
+
+    /**
+     * Expand a single defaultBehaviors[] template entry for a specific component
+     * instance placed in the scene.
+     *
+     * If the entry is a behaviorRef, it is first resolved against the device
+     * library; otherwise it is treated as a full behavior definition.
+     * In both cases the instanceUuid is injected as input.component and
+     * output.component, and the behavior id is suffixed with ::instanceUuid.
+     *
+     * @param {Object} template - Entry from compData.defaultBehaviors[]
+     * @param {string} instanceUuid - UUID of the placed component instance
+     * @param {Object} componentDictionary
+     * @returns {Object|null}
+     */
+  }, {
+    key: "_expandDefaultBehavior",
+    value: function _expandDefaultBehavior(template, instanceUuid, componentDictionary) {
+      var base;
+      if (template.behaviorRef) {
+        // Resolve the device ref first (substitutes 'self' -> attachment)
+        base = this._resolveBehaviorRef(template, componentDictionary);
+        if (!base) return null;
+      } else {
+        base = JSON.parse(JSON.stringify(template));
+      }
+      // Suffix the id so each instance gets a unique behavior id
+      base.id = "".concat(base.id, "::").concat(instanceUuid);
+      // Inject the instance UUID as the component scope guard
+      base.input = _objectSpread2(_objectSpread2({}, base.input), {}, {
+        component: instanceUuid
+      });
+      base.output = _objectSpread2(_objectSpread2({}, base.output), {}, {
+        component: instanceUuid
+      });
+      return base;
     }
 
     /**
@@ -31148,7 +31374,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
     key: "loadSceneFromData",
     value: (function () {
       var _loadSceneFromData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(data) {
-        var _data$scene3, _data$scene4, _data$scene5, _data$scene6;
+        var _data$scene4, _data$scene5, _data$scene6, _data$scene7;
         return _regenerator().w(function (_context9) {
           while (1) switch (_context9.n) {
             case 0:
@@ -31158,10 +31384,10 @@ var SceneOperationsManager = /*#__PURE__*/function () {
                 dataType: _typeof(data),
                 hasScene: !!(data !== null && data !== void 0 && data.scene),
                 sceneType: _typeof(data === null || data === void 0 ? void 0 : data.scene),
-                hasChildren: !!(data !== null && data !== void 0 && (_data$scene3 = data.scene) !== null && _data$scene3 !== void 0 && _data$scene3.children),
-                childrenType: data !== null && data !== void 0 && (_data$scene4 = data.scene) !== null && _data$scene4 !== void 0 && _data$scene4.children ? _typeof(data.scene.children) : 'undefined',
-                isArray: Array.isArray(data === null || data === void 0 || (_data$scene5 = data.scene) === null || _data$scene5 === void 0 ? void 0 : _data$scene5.children),
-                childrenLength: data === null || data === void 0 || (_data$scene6 = data.scene) === null || _data$scene6 === void 0 || (_data$scene6 = _data$scene6.children) === null || _data$scene6 === void 0 ? void 0 : _data$scene6.length,
+                hasChildren: !!(data !== null && data !== void 0 && (_data$scene4 = data.scene) !== null && _data$scene4 !== void 0 && _data$scene4.children),
+                childrenType: data !== null && data !== void 0 && (_data$scene5 = data.scene) !== null && _data$scene5 !== void 0 && _data$scene5.children ? _typeof(data.scene.children) : 'undefined',
+                isArray: Array.isArray(data === null || data === void 0 || (_data$scene6 = data.scene) === null || _data$scene6 === void 0 ? void 0 : _data$scene6.children),
+                childrenLength: data === null || data === void 0 || (_data$scene7 = data.scene) === null || _data$scene7 === void 0 || (_data$scene7 = _data$scene7.children) === null || _data$scene7 === void 0 ? void 0 : _data$scene7.length,
                 dataKeys: data ? Object.keys(data) : [],
                 sceneKeys: data !== null && data !== void 0 && data.scene ? Object.keys(data.scene) : []
               });
@@ -31292,8 +31518,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         // Process children (connectors, etc.) if they exist
         if (componentModel.children && componentModel.children.length > 0) {
           componentModel.children.forEach(function (child) {
-            var _child$userData0, _child$userData1;
-            var childType = ((_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.objectType) || ((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.objectType);
+            var _child$userData1, _child$userData10;
+            var childType = ((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.objectType) || ((_child$userData10 = child.userData) === null || _child$userData10 === void 0 ? void 0 : _child$userData10.objectType);
             if (childType === 'connector') {
               var _child$geometry;
               var childBoundingBox = new THREE__namespace.Box3().setFromObject(child);
@@ -31378,8 +31604,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       if (segment.children && segment.children.length > 0) {
         var childrenToRemove = _toConsumableArray(segment.children);
         childrenToRemove.forEach(function (child) {
-          var _child$userData10;
-          if ((_child$userData10 = child.userData) !== null && _child$userData10 !== void 0 && _child$userData10.isPipeElbow) {
+          var _child$userData11;
+          if ((_child$userData11 = child.userData) !== null && _child$userData11 !== void 0 && _child$userData11.isPipeElbow) {
             console.log("\uD83D\uDDD1\uFE0F Removing elbow child from segment before manualization: ".concat(child.uuid));
             segment.remove(child);
             if (child.geometry) child.geometry.dispose();
@@ -31530,7 +31756,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
     value: function _convertConnectedGatewaysToManual(connectors, currentSceneData) {
       var _connectors$,
         _segment$userData2,
-        _this5 = this;
+        _this7 = this;
       console.log('🔍 Checking for connected gateways to convert to manual...');
       var sceneViewer = this.sceneViewer;
       var convertedGateways = [];
@@ -31567,7 +31793,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
             console.log("\uD83D\uDD27 Found computed gateway at endpoint: ".concat(endpointObject.uuid, " - converting to manual"));
 
             // Convert gateway to manual (declared) using manualizeGateway for consistency
-            _this5.manualizeGateway(endpointObject, currentSceneData);
+            _this7.manualizeGateway(endpointObject, currentSceneData);
             convertedGateways.push(endpointObject);
           } else if (((_endpointObject$userD5 = endpointObject.userData) === null || _endpointObject$userD5 === void 0 ? void 0 : _endpointObject$userD5.objectType) === 'gateway' && ((_endpointObject$userD6 = endpointObject.userData) === null || _endpointObject$userD6 === void 0 ? void 0 : _endpointObject$userD6.isDeclared) === true) {
             console.log("\u2139\uFE0F Gateway ".concat(endpointObject.uuid, " is already declared (manual), skipping conversion"));
@@ -32313,8 +32539,7 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
                 // ioConfig can use either 'states' (preferred) or legacy 'dataPoints' as the array key
                 dataPoints: ((_deviceData$ioConfig = deviceData.ioConfig) === null || _deviceData$ioConfig === void 0 ? void 0 : _deviceData$ioConfig.states) || ((_deviceData$ioConfig2 = deviceData.ioConfig) === null || _deviceData$ioConfig2 === void 0 ? void 0 : _deviceData$ioConfig2.dataPoints) || [],
                 // Device-level I/O direction: 'input' means the user can write state via the tooltip
-                ioDirection: ((_deviceData$ioConfig3 = deviceData.ioConfig) === null || _deviceData$ioConfig3 === void 0 ? void 0 : _deviceData$ioConfig3.direction) || 'output',
-                signalOutputs: attachment.signalOutputs || []
+                ioDirection: ((_deviceData$ioConfig3 = deviceData.ioConfig) === null || _deviceData$ioConfig3 === void 0 ? void 0 : _deviceData$ioConfig3.direction) || 'output'
               };
               if ((_attachment$attachmen = attachment.attachmentPoint) !== null && _attachment$attachmen !== void 0 && _attachment$attachmen.position) {
                 pos = attachment.attachmentPoint.position;
@@ -36515,7 +36740,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         return false;
       }
       try {
-        var _componentData$childr, _componentData$childr2, _this$centralPlant$sc6, _componentData$childr3;
+        var _componentData$childr, _componentData$childr2, _this$centralPlant$sc6, _componentData$childr3, _componentData$defaul;
         // Generate a unique component ID if not provided
         var componentId = options.customId || this.generateUniqueComponentId(libraryId);
 
@@ -36721,6 +36946,15 @@ var CentralPlantInternals = /*#__PURE__*/function () {
           attachIODevicesToComponent(componentModel, componentData, modelPreloader, componentId);
         }
 
+        // Register default behaviors for smart components so the BehaviorManager
+        // responds to tooltip-driven state changes immediately after drop.
+        // (The scene-load path uses _processBehaviors instead, which runs on loadSceneData.)
+        if ((_componentData$defaul = componentData.defaultBehaviors) !== null && _componentData$defaul !== void 0 && _componentData$defaul.length) {
+          var _this$centralPlant$sc7, _som$registerBehavior;
+          var som = (_this$centralPlant$sc7 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc7 === void 0 ? void 0 : _this$centralPlant$sc7.sceneOperationsManager;
+          som === null || som === void 0 || (_som$registerBehavior = som.registerBehaviorsForComponentInstance) === null || _som$registerBehavior === void 0 || _som$registerBehavior.call(som, componentData, componentId);
+        }
+
         // Notify the component manager about the new component
         if (componentManager.registerComponent) {
           componentManager.registerComponent(componentModel);
@@ -36779,9 +37013,9 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "deleteComponent",
     value: function deleteComponent(componentId) {
-      var _this$centralPlant$sc7;
+      var _this$centralPlant$sc8;
       // Check if component manager is available
-      var componentManager = (_this$centralPlant$sc7 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc7 === void 0 ? void 0 : _this$centralPlant$sc7.componentManager;
+      var componentManager = (_this$centralPlant$sc8 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc8 === void 0 ? void 0 : _this$centralPlant$sc8.componentManager;
       if (!componentManager) {
         console.error('❌ deleteComponent(): Component manager not available');
         return false;
@@ -36876,7 +37110,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.91
+   * @version 0.1.93
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -37952,6 +38186,337 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       return results;
     }
 
+    // ===== I/O DEVICE ASSET API =====
+
+    /**
+     * Set the asset service for I/O device attachment operations.
+     * The service handles S3 storage and Vuex state updates so that
+     * the central-plant package stays free of sandbox-specific dependencies.
+     * @param {Object} service - Object with createSmartComponent, addComponentAttachment, removeComponentAttachment methods
+     * @example
+     * import { createAssetService } from '~/services/AssetService'
+     * centralPlant.setAssetService(createAssetService(store))
+     */
+  }, {
+    key: "setAssetService",
+    value: function setAssetService(service) {
+      if (!service || _typeof(service) !== 'object') {
+        console.warn('⚠️ setAssetService(): service must be an object');
+        return;
+      }
+      this.assetService = service;
+      console.log('✅ Asset service set');
+    }
+
+    /**
+     * List all available I/O Device assets from the component dictionary.
+     * @param {Object} [options={}]
+     * @param {'all'|'bundled'|'user'} [options.source='all'] - Filter by asset origin
+     * @returns {Array<{uuid: string, name: string, assetType: string, ioConfig: Object}>}
+     * @example
+     * const devices = centralPlant.getIoDevices({ source: 'all' })
+     * const bundledOnly = centralPlant.getIoDevices({ source: 'bundled' })
+     */
+  }, {
+    key: "getIoDevices",
+    value: function getIoDevices() {
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$source = _ref.source,
+        source = _ref$source === void 0 ? 'all' : _ref$source;
+      var mp = this.getUtility('modelPreloader');
+      var dict = mp === null || mp === void 0 ? void 0 : mp.componentDictionary;
+      if (!dict) {
+        console.warn('⚠️ getIoDevices(): component dictionary not loaded');
+        return [];
+      }
+      return Object.values(dict).filter(function (entry) {
+        return entry.assetType === 'I/O Device';
+      }).filter(function (entry) {
+        if (source === 'bundled') return !entry.isS3Component;
+        if (source === 'user') return entry.isS3Component === true;
+        return true; // 'all'
+      }).map(function (entry) {
+        return {
+          uuid: entry.uuid || entry.id,
+          name: entry.name,
+          assetType: entry.assetType,
+          ioConfig: entry.ioConfig || {}
+        };
+      });
+    }
+
+    /**
+     * Return a list of smart components that reference a given I/O Device.
+     * Useful for enforcing deletion guards.
+     * @param {Object} options
+     * @param {string} options.deviceUuid - UUID of the I/O Device asset to check
+     * @returns {Array<{componentId: string, componentName: string}>}
+     * @example
+     * const usage = centralPlant.getIoDeviceUsage({ deviceUuid: 'io-def-push-button' })
+     * // [{ componentId: 'comp-smart-pump-01', componentName: 'Smart Pump' }]
+     */
+  }, {
+    key: "getIoDeviceUsage",
+    value: function getIoDeviceUsage() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        deviceUuid = _ref2.deviceUuid;
+      if (!deviceUuid) {
+        console.warn('⚠️ getIoDeviceUsage(): deviceUuid is required');
+        return [];
+      }
+      var mp = this.getUtility('modelPreloader');
+      var dict = mp === null || mp === void 0 ? void 0 : mp.componentDictionary;
+      if (!dict) {
+        console.warn('⚠️ getIoDeviceUsage(): component dictionary not loaded');
+        return [];
+      }
+      var results = [];
+      Object.values(dict).forEach(function (entry) {
+        if (!entry.isSmart || !entry.attachedDevices) return;
+        var uses = Object.values(entry.attachedDevices).some(function (att) {
+          return att.deviceId === deviceUuid;
+        });
+        if (uses) {
+          results.push({
+            componentId: entry.uuid || entry.id,
+            componentName: entry.name || ''
+          });
+        }
+      });
+      return results;
+    }
+
+    /**
+     * Create a new smart component asset by attaching I/O devices to an existing component.
+     * Requires setAssetService() to have been called first.
+     * @param {Object} options
+     * @param {string} options.componentUuid - UUID of the base component to promote
+     * @param {string} [options.name] - Display name for the new smart component (auto-deduped)
+     * @param {Array}  options.attachments - Attachment descriptors (attachmentId, deviceId, attachmentLabel, attachmentPoint)
+     * @param {Blob}   [options.thumbnailBlob] - Optional thumbnail image blob
+     * @returns {Promise<Object>} The new smart component asset object
+     * @example
+     * const newAsset = await centralPlant.createSmartComponent({
+     *   componentUuid: 'comp-base-pump-01',
+     *   name: 'Smart Pump A',
+     *   attachments: [{
+     *     attachmentId: 'attch-button-01',
+     *     deviceId: 'io-def-push-button',
+     *     attachmentLabel: 'Power Button',
+     *     attachmentPoint: { position: { x: -0.1, y: 0.3, z: 0.0 }, direction: { x: 0.0, y: 1.0, z: 0.0 } }
+     *   }]
+     * })
+     */
+  }, {
+    key: "createSmartComponent",
+    value: (function () {
+      var _createSmartComponent = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var _ref3,
+          componentUuid,
+          name,
+          attachments,
+          thumbnailBlob,
+          newAsset,
+          mp,
+          _args3 = arguments;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              _ref3 = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {}, componentUuid = _ref3.componentUuid, name = _ref3.name, attachments = _ref3.attachments, thumbnailBlob = _ref3.thumbnailBlob;
+              if (this.assetService) {
+                _context3.n = 1;
+                break;
+              }
+              throw new Error('createSmartComponent(): no asset service set — call setAssetService() first');
+            case 1:
+              if (componentUuid) {
+                _context3.n = 2;
+                break;
+              }
+              throw new Error('createSmartComponent(): componentUuid is required');
+            case 2:
+              if (!(!Array.isArray(attachments) || attachments.length === 0)) {
+                _context3.n = 3;
+                break;
+              }
+              throw new Error('createSmartComponent(): at least one attachment is required');
+            case 3:
+              _context3.n = 4;
+              return this.assetService.createSmartComponent({
+                componentUuid: componentUuid,
+                name: name,
+                attachments: attachments,
+                thumbnailBlob: thumbnailBlob
+              });
+            case 4:
+              newAsset = _context3.v;
+              // Register in model preloader dictionary so addComponent() can use it immediately
+              mp = this.getUtility('modelPreloader');
+              if (mp !== null && mp !== void 0 && mp.componentDictionary && newAsset !== null && newAsset !== void 0 && newAsset.uuid) {
+                mp.componentDictionary[newAsset.uuid] = _objectSpread2(_objectSpread2({}, newAsset), {}, {
+                  id: newAsset.uuid
+                });
+                console.log("\u2705 createSmartComponent(): registered \"".concat(newAsset.name, "\" in component dictionary"));
+              }
+              return _context3.a(2, newAsset);
+          }
+        }, _callee3, this);
+      }));
+      function createSmartComponent() {
+        return _createSmartComponent.apply(this, arguments);
+      }
+      return createSmartComponent;
+    }()
+    /**
+     * Add or update a single I/O device attachment on an existing smart component.
+     * Requires setAssetService() to have been called first.
+     * Updates S3 data and Vuex store only — does NOT update live scene objects.
+     * @param {Object} options
+     * @param {string} options.componentUuid - UUID of the smart component to update
+     * @param {Object} options.attachment - Attachment descriptor
+     * @param {string} options.attachment.attachmentId - Globally unique attachment key
+     * @param {string} options.attachment.deviceId - UUID of the I/O Device asset
+     * @param {string} options.attachment.attachmentLabel - Human-readable label
+     * @param {Object} [options.attachment.attachmentPoint] - Position/direction on the model
+     * @returns {Promise<Object>} The updated smart component asset object
+     * @example
+     * await centralPlant.addComponentAttachment({
+     *   componentUuid: 'comp-smart-pump-01',
+     *   attachment: {
+     *     attachmentId: 'attch-led-01',
+     *     deviceId: 'io-def-signal-light',
+     *     attachmentLabel: 'Status LED',
+     *     attachmentPoint: { position: { x: 0.1, y: 0.3, z: 0.0 }, direction: { x: 0.0, y: 1.0, z: 0.0 } }
+     *   }
+     * })
+     */
+    )
+  }, {
+    key: "addComponentAttachment",
+    value: (function () {
+      var _addComponentAttachment = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+        var _ref4,
+          componentUuid,
+          attachment,
+          updatedAsset,
+          mp,
+          _args4 = arguments;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              _ref4 = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : {}, componentUuid = _ref4.componentUuid, attachment = _ref4.attachment;
+              if (this.assetService) {
+                _context4.n = 1;
+                break;
+              }
+              throw new Error('addComponentAttachment(): no asset service set — call setAssetService() first');
+            case 1:
+              if (componentUuid) {
+                _context4.n = 2;
+                break;
+              }
+              throw new Error('addComponentAttachment(): componentUuid is required');
+            case 2:
+              if (!(!(attachment !== null && attachment !== void 0 && attachment.attachmentId) || !(attachment !== null && attachment !== void 0 && attachment.deviceId))) {
+                _context4.n = 3;
+                break;
+              }
+              throw new Error('addComponentAttachment(): attachment must have attachmentId and deviceId');
+            case 3:
+              _context4.n = 4;
+              return this.assetService.addComponentAttachment({
+                componentUuid: componentUuid,
+                attachment: attachment
+              });
+            case 4:
+              updatedAsset = _context4.v;
+              // Sync component dictionary
+              mp = this.getUtility('modelPreloader');
+              if (mp !== null && mp !== void 0 && mp.componentDictionary && updatedAsset !== null && updatedAsset !== void 0 && updatedAsset.uuid) {
+                mp.componentDictionary[updatedAsset.uuid] = _objectSpread2(_objectSpread2(_objectSpread2({}, mp.componentDictionary[updatedAsset.uuid] || {}), updatedAsset), {}, {
+                  id: updatedAsset.uuid
+                });
+              }
+              return _context4.a(2, updatedAsset);
+          }
+        }, _callee4, this);
+      }));
+      function addComponentAttachment() {
+        return _addComponentAttachment.apply(this, arguments);
+      }
+      return addComponentAttachment;
+    }()
+    /**
+     * Remove a single I/O device attachment from a smart component.
+     * Requires setAssetService() to have been called first.
+     * If this is the last attachment the component is demoted to a plain component.
+     * Updates S3 data and Vuex store only — does NOT update live scene objects.
+     * @param {Object} options
+     * @param {string} options.componentUuid - UUID of the smart component to update
+     * @param {string} options.attachmentId - The attachmentId key to remove
+     * @returns {Promise<Object>} The updated component asset object
+     * @example
+     * await centralPlant.removeComponentAttachment({
+     *   componentUuid: 'comp-smart-pump-01',
+     *   attachmentId: 'attch-led-01'
+     * })
+     */
+    )
+  }, {
+    key: "removeComponentAttachment",
+    value: (function () {
+      var _removeComponentAttachment = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+        var _ref5,
+          componentUuid,
+          attachmentId,
+          updatedAsset,
+          mp,
+          _args5 = arguments;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              _ref5 = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : {}, componentUuid = _ref5.componentUuid, attachmentId = _ref5.attachmentId;
+              if (this.assetService) {
+                _context5.n = 1;
+                break;
+              }
+              throw new Error('removeComponentAttachment(): no asset service set — call setAssetService() first');
+            case 1:
+              if (componentUuid) {
+                _context5.n = 2;
+                break;
+              }
+              throw new Error('removeComponentAttachment(): componentUuid is required');
+            case 2:
+              if (attachmentId) {
+                _context5.n = 3;
+                break;
+              }
+              throw new Error('removeComponentAttachment(): attachmentId is required');
+            case 3:
+              _context5.n = 4;
+              return this.assetService.removeComponentAttachment({
+                componentUuid: componentUuid,
+                attachmentId: attachmentId
+              });
+            case 4:
+              updatedAsset = _context5.v;
+              // Sync component dictionary
+              mp = this.getUtility('modelPreloader');
+              if (mp !== null && mp !== void 0 && mp.componentDictionary && updatedAsset !== null && updatedAsset !== void 0 && updatedAsset.uuid) {
+                mp.componentDictionary[updatedAsset.uuid] = _objectSpread2(_objectSpread2(_objectSpread2({}, mp.componentDictionary[updatedAsset.uuid] || {}), updatedAsset), {}, {
+                  id: updatedAsset.uuid
+                });
+              }
+              return _context5.a(2, updatedAsset);
+          }
+        }, _callee5, this);
+      }));
+      function removeComponentAttachment() {
+        return _removeComponentAttachment.apply(this, arguments);
+      }
+      return removeComponentAttachment;
+    }()
     /**
      * Get all component IDs from the scene
      * @returns {Array<string>} Array of component UUID strings, or empty array if none exist
@@ -37969,6 +38534,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
      * // Check if specific component exists
      * const hasChiller = componentIds.some(id => id.includes('chiller'));
      */
+    )
   }, {
     key: "getComponentIds",
     value: function getComponentIds() {
@@ -38137,41 +38703,41 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "getComponents",
     value: (function () {
-      var _getComponents = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+      var _getComponents = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
         var options,
           validation,
           enhancedOptions,
-          _args3 = arguments,
+          _args6 = arguments,
           _t;
-        return _regenerator().w(function (_context3) {
-          while (1) switch (_context3.n) {
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
             case 0:
-              options = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {};
+              options = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : {};
               // Validate filter options using centralized validator
               validation = this.internals.validator.validateComponentFilter(options);
               if (validation.isValid) {
-                _context3.n = 1;
+                _context6.n = 1;
                 break;
               }
               console.warn('⚠️ getComponents(): Invalid filter options provided:', validation.message);
-              return _context3.a(2, []);
+              return _context6.a(2, []);
             case 1:
-              _context3.p = 1;
+              _context6.p = 1;
               // Always include metadata
               enhancedOptions = _objectSpread2(_objectSpread2({}, options), {}, {
                 includeMetadata: true
               });
-              _context3.n = 2;
+              _context6.n = 2;
               return this.managers.componentDataManager.getDictionaryComponents(enhancedOptions);
             case 2:
-              return _context3.a(2, _context3.v);
+              return _context6.a(2, _context6.v);
             case 3:
-              _context3.p = 3;
-              _t = _context3.v;
+              _context6.p = 3;
+              _t = _context6.v;
               console.error('❌ getDictionaryComponents(): Error retrieving available components:', _t);
-              return _context3.a(2, []);
+              return _context6.a(2, []);
           }
-        }, _callee3, this, [[1, 3]]);
+        }, _callee6, this, [[1, 3]]);
       }));
       function getComponents() {
         return _getComponents.apply(this, arguments);
@@ -38274,23 +38840,23 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "extendComponentDictionary",
     value: (function () {
-      var _extendComponentDictionary = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(additionalComponents) {
-        return _regenerator().w(function (_context4) {
-          while (1) switch (_context4.n) {
+      var _extendComponentDictionary = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(additionalComponents) {
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
             case 0:
               if (this.managers.componentDataManager) {
-                _context4.n = 1;
+                _context7.n = 1;
                 break;
               }
               console.warn('⚠️ extendComponentDictionary(): Component data manager not available');
-              return _context4.a(2, false);
+              return _context7.a(2, false);
             case 1:
-              _context4.n = 2;
+              _context7.n = 2;
               return this.managers.componentDataManager.extendComponentDictionary(additionalComponents);
             case 2:
-              return _context4.a(2, _context4.v);
+              return _context7.a(2, _context7.v);
           }
-        }, _callee4, this);
+        }, _callee7, this);
       }));
       function extendComponentDictionary(_x3) {
         return _extendComponentDictionary.apply(this, arguments);
@@ -38313,23 +38879,23 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "removeS3Components",
     value: (function () {
-      var _removeS3Components = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
-        return _regenerator().w(function (_context5) {
-          while (1) switch (_context5.n) {
+      var _removeS3Components = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
             case 0:
               if (this.managers.componentDataManager) {
-                _context5.n = 1;
+                _context8.n = 1;
                 break;
               }
               console.warn('⚠️ removeS3Components(): Component data manager not available');
-              return _context5.a(2, false);
+              return _context8.a(2, false);
             case 1:
-              _context5.n = 2;
+              _context8.n = 2;
               return this.managers.componentDataManager.removeS3Components();
             case 2:
-              return _context5.a(2, _context5.v);
+              return _context8.a(2, _context8.v);
           }
-        }, _callee5, this);
+        }, _callee8, this);
       }));
       function removeS3Components() {
         return _removeS3Components.apply(this, arguments);
@@ -38353,23 +38919,23 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "removeComponentFromDictionary",
     value: (function () {
-      var _removeComponentFromDictionary = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(componentKey) {
-        return _regenerator().w(function (_context6) {
-          while (1) switch (_context6.n) {
+      var _removeComponentFromDictionary = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(componentKey) {
+        return _regenerator().w(function (_context9) {
+          while (1) switch (_context9.n) {
             case 0:
               if (this.managers.componentDataManager) {
-                _context6.n = 1;
+                _context9.n = 1;
                 break;
               }
               console.warn('⚠️ removeComponentFromDictionary(): Component data manager not available');
-              return _context6.a(2, false);
+              return _context9.a(2, false);
             case 1:
-              _context6.n = 2;
+              _context9.n = 2;
               return this.managers.componentDataManager.removeComponentFromDictionary(componentKey);
             case 2:
-              return _context6.a(2, _context6.v);
+              return _context9.a(2, _context9.v);
           }
-        }, _callee6, this);
+        }, _callee9, this);
       }));
       function removeComponentFromDictionary(_x4) {
         return _removeComponentFromDictionary.apply(this, arguments);
@@ -38616,49 +39182,49 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "initialize2DViewport",
     value: function () {
-      var _initialize2DViewport = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(container) {
+      var _initialize2DViewport = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(container) {
         var viewType,
           instanceKey,
           success,
-          _args7 = arguments,
+          _args0 = arguments,
           _t2;
-        return _regenerator().w(function (_context7) {
-          while (1) switch (_context7.n) {
+        return _regenerator().w(function (_context0) {
+          while (1) switch (_context0.n) {
             case 0:
-              viewType = _args7.length > 1 && _args7[1] !== undefined ? _args7[1] : 'top';
-              instanceKey = _args7.length > 2 && _args7[2] !== undefined ? _args7[2] : null;
+              viewType = _args0.length > 1 && _args0[1] !== undefined ? _args0[1] : 'top';
+              instanceKey = _args0.length > 2 && _args0[2] !== undefined ? _args0[2] : null;
               if (container) {
-                _context7.n = 1;
+                _context0.n = 1;
                 break;
               }
               console.warn('⚠️ initialize2DViewport(): No container provided');
-              return _context7.a(2, false);
+              return _context0.a(2, false);
             case 1:
               if (this.managers.viewport2DManager) {
-                _context7.n = 2;
+                _context0.n = 2;
                 break;
               }
               console.warn('⚠️ initialize2DViewport(): Viewport2D manager not available');
-              return _context7.a(2, false);
+              return _context0.a(2, false);
             case 2:
-              _context7.p = 2;
-              _context7.n = 3;
+              _context0.p = 2;
+              _context0.n = 3;
               return this.managers.viewport2DManager.initialize(container, viewType, instanceKey);
             case 3:
-              success = _context7.v;
+              success = _context0.v;
               if (success) {
                 console.log("\u2705 2D viewport initialized successfully (".concat(viewType, " view, key: ").concat(instanceKey || viewType, ")"));
               } else {
                 console.warn("\u26A0\uFE0F Failed to initialize 2D viewport (".concat(viewType, " view)"));
               }
-              return _context7.a(2, success);
+              return _context0.a(2, success);
             case 4:
-              _context7.p = 4;
-              _t2 = _context7.v;
+              _context0.p = 4;
+              _t2 = _context0.v;
               console.error('❌ initialize2DViewport(): Error initializing 2D viewport:', _t2);
-              return _context7.a(2, false);
+              return _context0.a(2, false);
           }
-        }, _callee7, this, [[2, 4]]);
+        }, _callee0, this, [[2, 4]]);
       }));
       function initialize2DViewport(_x5) {
         return _initialize2DViewport.apply(this, arguments);
@@ -38806,7 +39372,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "initializeModelPreloading",
     value: (function () {
-      var _initializeModelPreloading = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+      var _initializeModelPreloading = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1() {
         var basePath,
           normalizedBasePath,
           dictionaryPath,
@@ -38815,13 +39381,13 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
           componentDictionary,
           _modelPreloader2,
           progress,
-          _args8 = arguments,
+          _args1 = arguments,
           _t3;
-        return _regenerator().w(function (_context8) {
-          while (1) switch (_context8.n) {
+        return _regenerator().w(function (_context1) {
+          while (1) switch (_context1.n) {
             case 0:
-              basePath = _args8.length > 0 && _args8[0] !== undefined ? _args8[0] : '/library/';
-              _context8.p = 1;
+              basePath = _args1.length > 0 && _args1[0] !== undefined ? _args1[0] : '/library/';
+              _context1.p = 1;
               // Ensure basePath ends with a slash
               normalizedBasePath = basePath.endsWith('/') ? basePath : "".concat(basePath, "/");
               dictionaryPath = "".concat(normalizedBasePath, "component-dictionary.json");
@@ -38832,39 +39398,39 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
               console.log("\uFFFD Models path: ".concat(modelsBasePath));
 
               // Load the component dictionary
-              _context8.n = 2;
+              _context1.n = 2;
               return fetch(dictionaryPath);
             case 2:
-              response = _context8.v;
+              response = _context1.v;
               if (response.ok) {
-                _context8.n = 3;
+                _context1.n = 3;
                 break;
               }
               throw new Error("Failed to load component dictionary: ".concat(response.status));
             case 3:
-              _context8.n = 4;
+              _context1.n = 4;
               return response.json();
             case 4:
-              componentDictionary = _context8.v;
+              componentDictionary = _context1.v;
               console.log('📚 Component dictionary loaded:', Object.keys(componentDictionary));
 
               // Start preloading all models with the specified base path
               _modelPreloader2 = this.getUtility('modelPreloader');
-              _context8.n = 5;
+              _context1.n = 5;
               return _modelPreloader2.preloadAllModels(componentDictionary, modelsBasePath);
             case 5:
-              progress = _context8.v;
+              progress = _context1.v;
               console.log('🎉 Model preloading completed:', progress);
-              return _context8.a(2, progress);
+              return _context1.a(2, progress);
             case 6:
-              _context8.p = 6;
-              _t3 = _context8.v;
+              _context1.p = 6;
+              _t3 = _context1.v;
               console.error('❌ Failed to initialize model preloading:', _t3);
               throw _t3;
             case 7:
-              return _context8.a(2);
+              return _context1.a(2);
           }
-        }, _callee8, this, [[1, 6]]);
+        }, _callee1, this, [[1, 6]]);
       }));
       function initializeModelPreloading() {
         return _initializeModelPreloading.apply(this, arguments);
@@ -38881,55 +39447,55 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "importScene",
     value: (function () {
-      var _importScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(jsonData) {
+      var _importScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10(jsonData) {
         var validation, _t4;
-        return _regenerator().w(function (_context9) {
-          while (1) switch (_context9.n) {
+        return _regenerator().w(function (_context10) {
+          while (1) switch (_context10.n) {
             case 0:
               if (jsonData) {
-                _context9.n = 1;
+                _context10.n = 1;
                 break;
               }
               console.error('❌ No JSON data provided for import');
-              return _context9.a(2, false);
+              return _context10.a(2, false);
             case 1:
-              _context9.p = 1;
+              _context10.p = 1;
               // Validate scene data structure
               validation = this.internals.validateAndAnalyzeSceneData(jsonData);
               if (validation.isValid) {
-                _context9.n = 2;
+                _context10.n = 2;
                 break;
               }
               console.error('❌ Invalid scene data format:', validation.message);
-              return _context9.a(2, false);
+              return _context10.a(2, false);
             case 2:
-              _context9.n = 3;
+              _context10.n = 3;
               return this.setImportedSceneData(jsonData);
             case 3:
               if (!(this.sceneViewer && this.sceneViewer.sceneOperationsManager)) {
-                _context9.n = 5;
+                _context10.n = 5;
                 break;
               }
-              _context9.n = 4;
+              _context10.n = 4;
               return this.sceneViewer.sceneOperationsManager.loadSceneFromData(jsonData);
             case 4:
               console.log('✅ Scene imported successfully');
-              return _context9.a(2, true);
+              return _context10.a(2, true);
             case 5:
               console.error('❌ SceneViewer not available for scene loading');
-              return _context9.a(2, false);
+              return _context10.a(2, false);
             case 6:
-              _context9.n = 8;
+              _context10.n = 8;
               break;
             case 7:
-              _context9.p = 7;
-              _t4 = _context9.v;
+              _context10.p = 7;
+              _t4 = _context10.v;
               console.error('❌ Error importing scene:', _t4);
-              return _context9.a(2, false);
+              return _context10.a(2, false);
             case 8:
-              return _context9.a(2);
+              return _context10.a(2);
           }
-        }, _callee9, this, [[1, 7]]);
+        }, _callee10, this, [[1, 7]]);
       }));
       function importScene(_x6) {
         return _importScene.apply(this, arguments);
@@ -38953,33 +39519,33 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "exportSceneJSON",
     value: (function () {
-      var _exportSceneJSON = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0() {
+      var _exportSceneJSON = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11() {
         var filename,
-          _args0 = arguments,
+          _args11 = arguments,
           _t5;
-        return _regenerator().w(function (_context0) {
-          while (1) switch (_context0.n) {
+        return _regenerator().w(function (_context11) {
+          while (1) switch (_context11.n) {
             case 0:
-              filename = _args0.length > 0 && _args0[0] !== undefined ? _args0[0] : null;
+              filename = _args11.length > 0 && _args11[0] !== undefined ? _args11[0] : null;
               if (this.managers.sceneExportManager) {
-                _context0.n = 1;
+                _context11.n = 1;
                 break;
               }
               console.error('❌ Scene export manager not available');
-              return _context0.a(2, false);
+              return _context11.a(2, false);
             case 1:
-              _context0.p = 1;
-              _context0.n = 2;
+              _context11.p = 1;
+              _context11.n = 2;
               return this.managers.sceneExportManager.downloadSceneJSON(filename);
             case 2:
-              return _context0.a(2, _context0.v);
+              return _context11.a(2, _context11.v);
             case 3:
-              _context0.p = 3;
-              _t5 = _context0.v;
+              _context11.p = 3;
+              _t5 = _context11.v;
               console.error('❌ Error exporting scene as JSON:', _t5);
-              return _context0.a(2, false);
+              return _context11.a(2, false);
           }
-        }, _callee0, this, [[1, 3]]);
+        }, _callee11, this, [[1, 3]]);
       }));
       function exportSceneJSON() {
         return _exportSceneJSON.apply(this, arguments);
@@ -39004,33 +39570,33 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "exportSceneGLTF",
     value: (function () {
-      var _exportSceneGLTF = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1() {
+      var _exportSceneGLTF = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee12() {
         var filename,
-          _args1 = arguments,
+          _args12 = arguments,
           _t6;
-        return _regenerator().w(function (_context1) {
-          while (1) switch (_context1.n) {
+        return _regenerator().w(function (_context12) {
+          while (1) switch (_context12.n) {
             case 0:
-              filename = _args1.length > 0 && _args1[0] !== undefined ? _args1[0] : null;
+              filename = _args12.length > 0 && _args12[0] !== undefined ? _args12[0] : null;
               if (this.managers.sceneExportManager) {
-                _context1.n = 1;
+                _context12.n = 1;
                 break;
               }
               console.error('❌ Scene export manager not available');
-              return _context1.a(2, false);
+              return _context12.a(2, false);
             case 1:
-              _context1.p = 1;
-              _context1.n = 2;
+              _context12.p = 1;
+              _context12.n = 2;
               return this.managers.sceneExportManager.exportSceneAsGLTF(filename, false);
             case 2:
-              return _context1.a(2, _context1.v);
+              return _context12.a(2, _context12.v);
             case 3:
-              _context1.p = 3;
-              _t6 = _context1.v;
+              _context12.p = 3;
+              _t6 = _context12.v;
               console.error('❌ Error exporting scene as GLTF:', _t6);
-              return _context1.a(2, false);
+              return _context12.a(2, false);
           }
-        }, _callee1, this, [[1, 3]]);
+        }, _callee12, this, [[1, 3]]);
       }));
       function exportSceneGLTF() {
         return _exportSceneGLTF.apply(this, arguments);
@@ -39056,33 +39622,33 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "exportSceneGLB",
     value: (function () {
-      var _exportSceneGLB = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10() {
+      var _exportSceneGLB = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee13() {
         var filename,
-          _args10 = arguments,
+          _args13 = arguments,
           _t7;
-        return _regenerator().w(function (_context10) {
-          while (1) switch (_context10.n) {
+        return _regenerator().w(function (_context13) {
+          while (1) switch (_context13.n) {
             case 0:
-              filename = _args10.length > 0 && _args10[0] !== undefined ? _args10[0] : null;
+              filename = _args13.length > 0 && _args13[0] !== undefined ? _args13[0] : null;
               if (this.managers.sceneExportManager) {
-                _context10.n = 1;
+                _context13.n = 1;
                 break;
               }
               console.error('❌ Scene export manager not available');
-              return _context10.a(2, false);
+              return _context13.a(2, false);
             case 1:
-              _context10.p = 1;
-              _context10.n = 2;
+              _context13.p = 1;
+              _context13.n = 2;
               return this.managers.sceneExportManager.exportSceneAsGLB(filename);
             case 2:
-              return _context10.a(2, _context10.v);
+              return _context13.a(2, _context13.v);
             case 3:
-              _context10.p = 3;
-              _t7 = _context10.v;
+              _context13.p = 3;
+              _t7 = _context13.v;
               console.error('❌ Error exporting scene as GLB:', _t7);
-              return _context10.a(2, false);
+              return _context13.a(2, false);
           }
-        }, _callee10, this, [[1, 3]]);
+        }, _callee13, this, [[1, 3]]);
       }));
       function exportSceneGLB() {
         return _exportSceneGLB.apply(this, arguments);
@@ -39121,16 +39687,16 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "loadSceneFromData",
     value: (function () {
-      var _loadSceneFromData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11(sceneData) {
-        return _regenerator().w(function (_context11) {
-          while (1) switch (_context11.n) {
+      var _loadSceneFromData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee14(sceneData) {
+        return _regenerator().w(function (_context14) {
+          while (1) switch (_context14.n) {
             case 0:
-              _context11.n = 1;
+              _context14.n = 1;
               return this.setImportedSceneData(sceneData);
             case 1:
-              return _context11.a(2, true);
+              return _context14.a(2, true);
           }
-        }, _callee11, this);
+        }, _callee14, this);
       }));
       function loadSceneFromData(_x7) {
         return _loadSceneFromData.apply(this, arguments);