@2112-lab/central-plant 0.3.37 → 0.3.39

package/dist/esm/src/managers/behaviors/IoBehaviorManager.js

@@ -1,6 +1,9 @@
-import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, slicedToArray as _slicedToArray, objectSpread2 as _objectSpread2, toConsumableArray as _toConsumableArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, slicedToArray as _slicedToArray, toConsumableArray as _toConsumableArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { BaseDisposable } from '../../core/baseDisposable.js';
+import { normalizeBehavior } from '../../utils/behaviorSchema.js';
+import { getScopedAttachmentKey } from '../../utils/behaviorDispatch.js';
+import { applyModelRootTranslation } from '../../utils/animationTransformUtils.js';
 
 var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   function IoBehaviorManager(sceneViewer) {
@@ -19,12 +22,11 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
      */
     _this._entries = new Map();
     _this._crossComponentBehaviors = [];
-
-    /**
-     * Map: `${componentUuid}` → Array<{ id, input, outputs }>
-     * Component-level behaviors for intra-component io-device linking
-     */
     _this._componentBehaviors = new Map();
+    /** @type {Map<string, string>} parentUuid::attachmentId → parentUuid */
+    _this._attachmentParentMap = new Map();
+    /** @type {Map<string, Object[]>} cache key → data point definitions */
+    _this._dataPointsCache = new Map();
 
     /**
      * Injected by the host application to read and write I/O device state.
@@ -114,7 +116,10 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
       }
       if (entries.length) {
         this._entries.set(key, entries);
-        // Loaded ${entries.length} animation(s) for attachment "${attachmentId}"
+        if (parentUuid && attachmentId) {
+          this._attachmentParentMap.set(this._key(parentUuid, attachmentId), parentUuid);
+        }
+        this._invalidateDataPointsCache(parentUuid, attachmentId);
       } else {
         console.warn("[IoBehaviorManager] No mesh entries resolved for attachment \"".concat(attachmentId, "\" \u2014 behaviorConfig had ").concat(anims.length, " entries but none matched a mesh"));
       }
@@ -122,7 +127,6 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
 
     /**
      * Apply animations triggered by an IO device state change.
-     * Should be called in parallel with BehaviorManager.triggerState().
      *
      * @param {string} attachmentId - Raw attachment key (not scoped)
      * @param {string} dataPointId  - The data point / state variable id that changed
@@ -132,70 +136,36 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "triggerState",
     value: function triggerState(attachmentId, dataPointId, value, parentUuid) {
-      // triggerState: ${attachmentId}.${dataPointId} = ${value}
-
-      if (parentUuid) {
-        var key = this._key(parentUuid, attachmentId);
-        var entries = this._entries.get(key);
-        if (entries) {
-          var _iterator2 = _createForOfIteratorHelper(entries),
-            _step2;
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var entry = _step2.value;
-              if (entry.anim.stateVariable !== dataPointId) continue;
-              this._applyAnimation(entry, value);
-            }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
-          }
-        }
-      } else {
-        // Fallback when parentUuid is not provided: match by attachmentId suffix or exact key match
-        var suffix = "::".concat(attachmentId);
-        var _iterator3 = _createForOfIteratorHelper(this._entries.entries()),
-          _step3;
+      var _this$_crossComponent;
+      var resolvedParent = parentUuid || this._findComponentByAttachment(attachmentId);
+      if (!resolvedParent) return;
+      var key = this._key(resolvedParent, attachmentId);
+      var entries = this._entries.get(key);
+      if (entries) {
+        var _iterator2 = _createForOfIteratorHelper(entries),
+          _step2;
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var _step3$value = _slicedToArray(_step3.value, 2),
-              _key2 = _step3$value[0],
-              _entries = _step3$value[1];
-            if (_key2 === attachmentId || _key2.endsWith(suffix)) {
-              var _iterator4 = _createForOfIteratorHelper(_entries),
-                _step4;
-              try {
-                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-                  var _entry = _step4.value;
-                  if (_entry.anim.stateVariable !== dataPointId) continue;
-                  this._applyAnimation(_entry, value);
-                }
-              } catch (err) {
-                _iterator4.e(err);
-              } finally {
-                _iterator4.f();
-              }
-            }
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var entry = _step2.value;
+            if (entry.anim.stateVariable !== dataPointId) continue;
+            this._applyAnimation(entry, value);
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator2.e(err);
         } finally {
-          _iterator3.f();
+          _iterator2.f();
         }
       }
 
       // Evaluate component-level behaviors (intra-component io-device linking)
-      if (parentUuid && this._componentBehaviors.has(parentUuid)) {
-        var componentBehaviors = this._componentBehaviors.get(parentUuid);
-        // Checking component-level behaviors (count: ${componentBehaviors.length})
-        this.triggerCrossComponentBehaviors(componentBehaviors, parentUuid, attachmentId, dataPointId, value);
+      if (this._componentBehaviors.has(resolvedParent)) {
+        var componentBehaviors = this._componentBehaviors.get(resolvedParent);
+        this.triggerCrossComponentBehaviors(componentBehaviors, resolvedParent, attachmentId, dataPointId, value, {
+          sameComponent: true
+        });
       }
-
-      // Evaluate cross-component behaviors if any are registered
-      // Checking cross-component behaviors (count: ${this._crossComponentBehaviors?.length || 0})
-      if (this._crossComponentBehaviors && this._crossComponentBehaviors.length > 0) {
-        this.triggerCrossComponentBehaviors(this._crossComponentBehaviors, parentUuid, attachmentId, dataPointId, value);
+      if (((_this$_crossComponent = this._crossComponentBehaviors) === null || _this$_crossComponent === void 0 ? void 0 : _this$_crossComponent.length) > 0) {
+        this.triggerCrossComponentBehaviors(this._crossComponentBehaviors, resolvedParent, attachmentId, dataPointId, value);
       }
     }
 
@@ -208,9 +178,8 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "setCrossComponentBehaviors",
     value: function setCrossComponentBehaviors(behaviors) {
-      var _this2 = this;
       this._crossComponentBehaviors = (behaviors || []).map(function (b) {
-        return _this2._normalizeBehavior(b);
+        return normalizeBehavior(b);
       });
       // Loaded ${this._crossComponentBehaviors.length} cross-component behavior(s)
     }
@@ -225,72 +194,17 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "registerComponentBehaviors",
     value: function registerComponentBehaviors(componentUuid, behaviors) {
-      var _this3 = this;
-      if (!behaviors || behaviors.length === 0) return;
+      if (!behaviors || behaviors.length === 0) {
+        this._componentBehaviors.delete(componentUuid);
+        return;
+      }
       var normalized = behaviors.map(function (b) {
-        return _this3._normalizeBehavior(b);
+        return normalizeBehavior(b);
       });
       this._componentBehaviors.set(componentUuid, normalized);
       // Registered ${normalized.length} component-level behavior(s) for component ${componentUuid}
     }
 
-    /**
-     * Normalize behavior from shorthand to full format.
-     * Supports:
-     *   - input: "attachment.state" → { attachment, state }
-     *   - outputs: ["attachment.state", ...] → converted to individual behaviors
-     *
-     * @param {Object} behavior - Raw behavior from scene JSON
-     * @returns {Object} Normalized behavior
-     */
-  }, {
-    key: "_normalizeBehavior",
-    value: function _normalizeBehavior(behavior) {
-      var normalized = _objectSpread2({}, behavior);
-
-      // Parse shorthand input: "attachment.state"
-      if (typeof behavior.input === 'string') {
-        var _behavior$input$split = behavior.input.split('.'),
-          _behavior$input$split2 = _slicedToArray(_behavior$input$split, 2),
-          attachment = _behavior$input$split2[0],
-          state = _behavior$input$split2[1];
-        normalized.input = {
-          attachment: attachment,
-          state: state
-        };
-      }
-
-      // Parse shorthand output/outputs
-      if (behavior.outputs) {
-        // Multiple outputs - expand to array
-        normalized._outputs = behavior.outputs.map(function (out) {
-          if (typeof out === 'string') {
-            var _out$split = out.split('.'),
-              _out$split2 = _slicedToArray(_out$split, 2),
-              _attachment = _out$split2[0],
-              _state = _out$split2[1];
-            return {
-              attachment: _attachment,
-              state: _state
-            };
-          }
-          return out;
-        });
-        delete normalized.outputs;
-      } else if (typeof behavior.output === 'string') {
-        // Single output string
-        var _behavior$output$spli = behavior.output.split('.'),
-          _behavior$output$spli2 = _slicedToArray(_behavior$output$spli, 2),
-          _attachment2 = _behavior$output$spli2[0],
-          _state2 = _behavior$output$spli2[1];
-        normalized.output = {
-          attachment: _attachment2,
-          state: _state2
-        };
-      }
-      return normalized;
-    }
-
     /**
      * Find the parent component UUID for a given attachment ID.
      * Searches the scene tree for the io-device with this attachment ID,
@@ -304,12 +218,10 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function _findComponentByAttachment(attachmentId) {
       var _this$sceneViewer;
       if (!((_this$sceneViewer = this.sceneViewer) !== null && _this$sceneViewer !== void 0 && _this$sceneViewer.scene)) return null;
-      var scene = this.sceneViewer.scene;
       var found = null;
-      scene.traverse(function (obj) {
+      this.sceneViewer.scene.traverse(function (obj) {
         var _obj$userData, _obj$userData2;
         if (found) return;
-        // Find the io-device object with this attachmentId
         if (((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'io-device' && ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.attachmentId) === attachmentId) {
           found = obj.userData.parentComponentId;
         }
@@ -353,20 +265,21 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
      * @param {string} triggerAttachmentId - Attachment ID of the triggering device
      * @param {string} triggerStateId - The state variable ID that changed
      * @param {*} value - The new state value
+     * @param {{ sameComponent?: boolean }} [options] - Intra-component links share one parent instance
      */
   }, {
     key: "triggerCrossComponentBehaviors",
     value: function triggerCrossComponentBehaviors(behaviors, triggerParentUuid, triggerAttachmentId, triggerStateId, value) {
+      var options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
       if (!behaviors || !Array.isArray(behaviors)) {
         return;
       }
-
-      // Evaluating ${behaviors.length} behavior(s)
-      var _iterator5 = _createForOfIteratorHelper(behaviors),
-        _step5;
+      var sameComponent = options.sameComponent === true;
+      var _iterator3 = _createForOfIteratorHelper(behaviors),
+        _step3;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var behavior = _step5.value;
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var behavior = _step3.value;
           var input = behavior.input,
             output = behavior.output,
             _outputs = behavior._outputs,
@@ -375,94 +288,69 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
             console.warn('[Behavior] Skipping behavior - missing input or output(s):', behavior);
             continue;
           }
-
-          // Auto-lookup component if not specified
-          var inputComponent = input.component || this._findComponentByAttachment(input.attachment);
-          console.log("[Behavior] Checking behavior \"".concat(behavior.id, "\":"), {
-            inputMatch: inputComponent === triggerParentUuid,
-            attachmentMatch: input.attachment === triggerAttachmentId,
-            stateMatch: input.state === triggerStateId,
-            expected: {
-              component: inputComponent,
-              attachment: input.attachment,
-              state: input.state
-            },
-            actual: {
-              component: triggerParentUuid,
-              attachment: triggerAttachmentId,
-              state: triggerStateId
-            }
-          });
-
-          // Verify that the input matches the triggering source
-          if (inputComponent === triggerParentUuid && input.attachment === triggerAttachmentId && input.state === triggerStateId) {
+          var inputComponent = input.component || (sameComponent ? triggerParentUuid : this._findComponentByAttachment(input.attachment));
+          var inputMatches = sameComponent ? input.attachment === triggerAttachmentId && input.state === triggerStateId : inputComponent === triggerParentUuid && input.attachment === triggerAttachmentId && input.state === triggerStateId;
+          if (inputMatches) {
             // Behavior "${behavior.id}" matched
 
             // Collect all outputs (single or multiple)
             var outputs = _outputs || (output ? [output] : []);
 
             // Process each output
-            var _iterator6 = _createForOfIteratorHelper(outputs),
-              _step6;
+            var _iterator4 = _createForOfIteratorHelper(outputs),
+              _step4;
             try {
-              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-                var out = _step6.value;
+              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                var out = _step4.value;
                 // NEW: State-to-state pass-through pattern
                 if (out.state) {
-                  // Auto-lookup output component if not specified
-                  var outputComponent = out.component || this._findComponentByAttachment(out.attachment);
-
-                  // Direct state mapping without conditions
+                  var outputComponent = out.component || (sameComponent ? triggerParentUuid : this._findComponentByAttachment(out.attachment));
                   if (this._stateAdapter) {
-                    // Dispatching state-to-state: ${out.attachment}.${out.state} = ${value}
-                    this._stateAdapter.setState(out.attachment, out.state, value);
-
-                    // Trigger animations on the output component
-                    // triggerState(attachmentId, dataPointId, value, parentUuid)
+                    var scopedKey = getScopedAttachmentKey(out.attachment, outputComponent);
+                    this._stateAdapter.setState(scopedKey, out.state, value);
                     if (outputComponent) {
-                      // Triggering animations on output component
                       this.triggerState(out.attachment, out.state, value, outputComponent);
                     } else {
                       console.warn("[Behavior] Could not find component for attachment \"".concat(out.attachment, "\""));
                     }
                   } else {
-                    console.warn('[Behavior] ✗ State adapter not configured for state-to-state behavior');
+                    console.warn('[Behavior] State adapter not configured for state-to-state behavior');
                   }
                 }
                 // LEGACY: Mesh-based pattern with conditions
                 else if (conditions && out.child) {
                   // Using legacy mesh-based pattern with conditions
                   // Evaluate conditions
-                  var _iterator7 = _createForOfIteratorHelper(conditions),
-                    _step7;
+                  var _iterator5 = _createForOfIteratorHelper(conditions),
+                    _step5;
                   try {
-                    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-                      var condition = _step7.value;
+                    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                      var condition = _step5.value;
                       if (this._evaluateCondition(condition.when, value)) {
                         // Apply actions to the target output component/attachment/child mesh
                         this._applyCrossComponentActions(out, condition.actions);
                       }
                     }
                   } catch (err) {
-                    _iterator7.e(err);
+                    _iterator5.e(err);
                   } finally {
-                    _iterator7.f();
+                    _iterator5.f();
                   }
                 } else {
                   console.warn('[Behavior] Output has neither state nor (child + conditions):', out);
                 }
               } // end outputs loop
             } catch (err) {
-              _iterator6.e(err);
+              _iterator4.e(err);
             } finally {
-              _iterator6.f();
+              _iterator4.f();
             }
           }
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator5.f();
+        _iterator3.f();
       }
     }
 
@@ -532,17 +420,17 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
       }
 
       // 4. Apply actions to targetObj
-      var _iterator8 = _createForOfIteratorHelper(actions),
-        _step8;
+      var _iterator6 = _createForOfIteratorHelper(actions),
+        _step6;
       try {
-        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-          var action = _step8.value;
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var action = _step6.value;
           this._applyCrossComponentAction(targetObj, action);
         }
       } catch (err) {
-        _iterator8.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator8.f();
+        _iterator6.f();
       }
     }
 
@@ -634,8 +522,12 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "getAnimationDataPoints",
     value: function getAnimationDataPoints(parentUuid, attachmentId) {
-      var _this4 = this;
+      var _this2 = this;
       var hitMesh = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var cacheKey = "".concat(this._key(parentUuid, attachmentId), "::").concat((hitMesh === null || hitMesh === void 0 ? void 0 : hitMesh.uuid) || '');
+      if (this._dataPointsCache.has(cacheKey)) {
+        return this._dataPointsCache.get(cacheKey);
+      }
       var key = this._key(parentUuid, attachmentId);
       var entries = this._entries.get(key);
       if (!(entries !== null && entries !== void 0 && entries.length)) return [];
@@ -646,35 +538,35 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
       var filtered = entries;
       if (hitMesh) {
         var matching = entries.filter(function (e) {
-          return _this4._isMeshOrDescendant(hitMesh, e.mesh);
+          return _this2._isMeshOrDescendant(hitMesh, e.mesh);
         });
         if (matching.length > 0) filtered = matching;
       }
 
       // Collapse multiple mesh entries that share the same stateVariable
       var seen = new Map(); // stateVariable → anim
-      var _iterator9 = _createForOfIteratorHelper(filtered),
-        _step9;
+      var _iterator7 = _createForOfIteratorHelper(filtered),
+        _step7;
       try {
-        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-          var anim = _step9.value.anim;
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var anim = _step7.value.anim;
           if (!seen.has(anim.stateVariable)) {
             seen.set(anim.stateVariable, anim);
           }
         }
       } catch (err) {
-        _iterator9.e(err);
+        _iterator7.e(err);
       } finally {
-        _iterator9.f();
+        _iterator7.f();
       }
       var dps = [];
-      var _iterator0 = _createForOfIteratorHelper(seen),
-        _step0;
+      var _iterator8 = _createForOfIteratorHelper(seen),
+        _step8;
       try {
-        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-          var _step0$value = _slicedToArray(_step0.value, 2),
-            stateVar = _step0$value[0],
-            _anim = _step0$value[1];
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var _step8$value = _slicedToArray(_step8.value, 2),
+            stateVar = _step8$value[0],
+            _anim = _step8$value[1];
           // Normalise stateType from AnimateDevicesDialog variants
           var stateType = void 0;
           var raw = (_anim.stateType || '').toLowerCase();
@@ -725,10 +617,11 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
           });
         }
       } catch (err) {
-        _iterator0.e(err);
+        _iterator8.e(err);
       } finally {
-        _iterator0.f();
+        _iterator8.f();
       }
+      this._dataPointsCache.set(cacheKey, dps);
       return dps;
     }
 
@@ -762,25 +655,46 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "unloadForComponent",
     value: function unloadForComponent(parentUuid) {
       var prefix = "".concat(parentUuid, "::");
-      var _iterator1 = _createForOfIteratorHelper(this._entries.keys()),
-        _step1;
-      try {
-        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
-          var key = _step1.value;
-          if (key.startsWith(prefix)) {
-            this._entries.delete(key);
-          }
+      for (var _i = 0, _arr = _toConsumableArray(this._entries.keys()); _i < _arr.length; _i++) {
+        var key = _arr[_i];
+        if (key.startsWith(prefix)) {
+          this._attachmentParentMap.delete(key);
+          this._entries.delete(key);
         }
-      } catch (err) {
-        _iterator1.e(err);
-      } finally {
-        _iterator1.f();
       }
+      this._componentBehaviors.delete(parentUuid);
+      this._invalidateDataPointsCacheForParent(parentUuid);
+    }
+
+    /**
+     * Remove animation entries for a single attachment on a component instance.
+     */
+  }, {
+    key: "unloadForAttachment",
+    value: function unloadForAttachment(parentUuid, attachmentId) {
+      var key = this._key(parentUuid, attachmentId);
+      this._entries.delete(key);
+      this._attachmentParentMap.delete(key);
+      this._invalidateDataPointsCache(parentUuid, attachmentId);
+    }
+
+    /**
+     * Clear all runtime behavior state when the scene is cleared or replaced.
+     */
+  }, {
+    key: "resetForScene",
+    value: function resetForScene() {
+      this._entries.clear();
+      this._componentBehaviors.clear();
+      this._crossComponentBehaviors = [];
+      this._attachmentParentMap.clear();
+      this._dataPointsCache.clear();
     }
   }, {
     key: "dispose",
     value: function dispose() {
-      this._entries.clear();
+      this.resetForScene();
+      this._stateAdapter = null;
       _superPropGet(IoBehaviorManager, "dispose", this, 3)([]);
     }
 
@@ -847,20 +761,20 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "_applyAnimation",
     value: function _applyAnimation(entry, value) {
       var anim = entry.anim,
-        mesh = entry.mesh,
-        origPos = entry.origPos;
+        mesh = entry.mesh;
+        entry.origPos;
         entry.origRot;
         var viewerMaxDim = entry.viewerMaxDim;
       var mapping = this._resolveMapping(anim, value);
       if (!mapping) return;
       var types = anim.transformTypes || [];
-      var _iterator10 = _createForOfIteratorHelper(types),
-        _step10;
+      var _iterator9 = _createForOfIteratorHelper(types),
+        _step9;
       try {
-        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-          var type = _step10.value;
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var type = _step9.value;
           if (type === 'translation') {
-            this._applyTranslation(mesh, origPos, mapping.transform);
+            this._applyTranslation(entry, mapping.transform);
           } else if (type === 'rotation') {
             this._applyRotation(entry, anim, mapping.rotationTransform, viewerMaxDim);
           } else if (type === 'color') {
@@ -868,9 +782,9 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
           }
         }
       } catch (err) {
-        _iterator10.e(err);
+        _iterator9.e(err);
       } finally {
-        _iterator10.f();
+        _iterator9.f();
       }
     }
 
@@ -990,20 +904,21 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
     // ─────────────────────────────────────────────────────────────────────────
 
     /**
-     * Apply a position delta relative to the mesh's original position.
-     * @param {THREE.Object3D} mesh
-     * @param {THREE.Vector3} origPos
-     * @param {{ x, y, z }} transform - Deltas
+     * Apply a translation offset in device-model-root space so every animated mesh
+     * shares the same axis directions regardless of intermediate parent transforms.
+     *
+     * @param {{ mesh, origPos, deviceModelRoot }} entry
+     * @param {{ x, y, z }} transform - Offset in model-root local space
      */
   }, {
     key: "_applyTranslation",
-    value: function _applyTranslation(mesh, origPos, transform) {
-      var _transform$x, _transform$y, _transform$z;
+    value: function _applyTranslation(entry, transform) {
       if (!transform) return;
-      // X and Y are negated to match the sign convention used in the AnimateDevicesDialog
-      // preview (_syncViewerTransform negates x and y before calling setMeshPreviewOffset).
-      // Z is added directly (no negation) — matching the dialog's z handling.
-      mesh.position.set(origPos.x - ((_transform$x = transform.x) !== null && _transform$x !== void 0 ? _transform$x : 0), origPos.y - ((_transform$y = transform.y) !== null && _transform$y !== void 0 ? _transform$y : 0), origPos.z + ((_transform$z = transform.z) !== null && _transform$z !== void 0 ? _transform$z : 0));
+      var mesh = entry.mesh,
+        origPos = entry.origPos,
+        deviceModelRoot = entry.deviceModelRoot;
+      if (!mesh || !origPos || !deviceModelRoot) return;
+      applyModelRootTranslation(mesh, deviceModelRoot, origPos, transform);
     }
 
     /**
@@ -1022,6 +937,9 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
         origRot = entry.origRot,
         deviceModelRoot = entry.deviceModelRoot;
       if (!mesh || !origPos || !origRot) return null;
+      if (entry._restWorldCache) {
+        return entry._restWorldCache;
+      }
       var savedPos = mesh.position.clone();
       var savedQuat = mesh.quaternion.clone();
       mesh.position.copy(origPos);
@@ -1040,12 +958,35 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
       }
       mesh.position.copy(savedPos);
       mesh.quaternion.copy(savedQuat);
-      return {
+      entry._restWorldCache = {
         origWorldPos: origWorldPos,
         origWorldQuat: origWorldQuat,
         origWorldCenter: origWorldCenter,
         deviceWorldQuat: deviceWorldQuat
       };
+      return entry._restWorldCache;
+    }
+  }, {
+    key: "_invalidateDataPointsCache",
+    value: function _invalidateDataPointsCache(parentUuid, attachmentId) {
+      var prefix = "".concat(this._key(parentUuid, attachmentId), "::");
+      for (var _i2 = 0, _arr2 = _toConsumableArray(this._dataPointsCache.keys()); _i2 < _arr2.length; _i2++) {
+        var key = _arr2[_i2];
+        if (key.startsWith(prefix)) {
+          this._dataPointsCache.delete(key);
+        }
+      }
+    }
+  }, {
+    key: "_invalidateDataPointsCacheForParent",
+    value: function _invalidateDataPointsCacheForParent(parentUuid) {
+      var prefix = "".concat(parentUuid, "::");
+      for (var _i3 = 0, _arr3 = _toConsumableArray(this._dataPointsCache.keys()); _i3 < _arr3.length; _i3++) {
+        var key = _arr3[_i3];
+        if (key.startsWith(prefix)) {
+          this._dataPointsCache.delete(key);
+        }
+      }
     }
 
     /**