@2112-lab/central-plant 0.3.28 → 0.3.29

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

@@ -0,0 +1,571 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var THREE = require('three');
+var baseDisposable = require('../../core/baseDisposable.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
+  function IoBehaviorManager(sceneViewer) {
+    var _this;
+    _rollupPluginBabelHelpers.classCallCheck(this, IoBehaviorManager);
+    _this = _rollupPluginBabelHelpers.callSuper(this, IoBehaviorManager);
+    _this.sceneViewer = sceneViewer;
+
+    /**
+     * Map: `${parentUuid}::${attachmentId}` → Array<{
+     *   anim: Object,
+     *   mesh: THREE.Object3D,
+     *   origPos: THREE.Vector3,
+     *   origRot: THREE.Euler
+     * }>
+     */
+    _this._entries = new Map();
+    return _this;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // PUBLIC API
+  // ─────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Register animation entries for one attached I/O device.
+   * Should be called after the device GLB has been merged into the scene
+   * so that mesh references are live.
+   *
+   * @param {string} attachmentId - The attachment key (e.g. 'attch-switch-01')
+   * @param {Object|Array} behaviorConfig - Serialized config; either the full object
+   *   { behaviors: [...] } or a plain array of behavior entries.
+   * @param {THREE.Object3D} deviceModelRoot - The device's root Object3D as added to the scene
+   * @param {string} parentUuid - UUID of the host component Object3D
+   */
+  _rollupPluginBabelHelpers.inherits(IoBehaviorManager, _BaseDisposable);
+  return _rollupPluginBabelHelpers.createClass(IoBehaviorManager, [{
+    key: "loadBehaviors",
+    value: function loadBehaviors(attachmentId, behaviorConfig, deviceModelRoot, parentUuid) {
+      var _behaviorConfig$behav;
+      if (!behaviorConfig || !deviceModelRoot) return;
+      var anims = Array.isArray(behaviorConfig) ? behaviorConfig : (_behaviorConfig$behav = behaviorConfig.behaviors) !== null && _behaviorConfig$behav !== void 0 ? _behaviorConfig$behav : [];
+      if (!anims.length) return;
+      var key = this._key(parentUuid, attachmentId);
+      var entries = [];
+      var _iterator = _rollupPluginBabelHelpers.createForOfIteratorHelper(anims),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var anim = _step.value;
+          var mesh = this._resolveMesh(anim, deviceModelRoot);
+          if (!mesh) {
+            console.warn("[IoBehaviorManager] Could not find mesh for animation \"".concat(anim.name || anim.stateVariable, "\" (uuid: ").concat(anim.meshUuid, ", name: \"").concat(anim.meshName, "\")"));
+            continue;
+          }
+          entries.push({
+            anim: anim,
+            mesh: mesh,
+            origPos: mesh.position.clone(),
+            origRot: mesh.rotation.clone()
+          });
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (entries.length) {
+        this._entries.set(key, entries);
+        console.log("[IoBehaviorManager] Loaded ".concat(entries.length, " animation(s) for attachment \"").concat(attachmentId, "\" (parent: ").concat(parentUuid, ") \u2014 stateVariables: ").concat(entries.map(function (e) {
+          return e.anim.stateVariable;
+        }).join(', ')));
+      } else {
+        console.warn("[IoBehaviorManager] No mesh entries resolved for attachment \"".concat(attachmentId, "\" \u2014 behaviorConfig had ").concat(anims.length, " entries but none matched a mesh"));
+      }
+    }
+
+    /**
+     * 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
+     * @param {*}      value        - New state value
+     * @param {string} parentUuid   - UUID of the host component
+     */
+  }, {
+    key: "triggerState",
+    value: function triggerState(attachmentId, dataPointId, value, parentUuid) {
+      var key = this._key(parentUuid, attachmentId);
+      var entries = this._entries.get(key);
+      if (!(entries !== null && entries !== void 0 && entries.length)) return;
+      var _iterator2 = _rollupPluginBabelHelpers.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();
+      }
+    }
+
+    /**
+     * Return tooltip-compatible data point definitions derived from the loaded
+     * animation entries for a given attachment.  Used by componentTooltipManager
+     * to replace the static ioConfig.states[] snapshot with the richer animation
+     * state definitions created in the Animate window.
+     *
+     * One dp object is emitted per unique stateVariable; multiple mesh entries
+     * that share the same stateVariable are collapsed into one.
+     *
+     * Returned dp shape (matches what _buildDataPointRow / _buildInputControl expect):
+     * {
+     *   id: string,          // stateVariable name
+     *   name: string,        // human-readable label (anim.name or stateVariable)
+     *   stateType: string,   // normalised to 'binary' | 'enum' | 'number'
+     *   stateConfig: Object, // { onLabel?, offLabel?, options?, min?, max?, unit? }
+     *   defaultValue: any,   // sensible default for the stateType
+     *   direction: 'input'   // all animation-driven states are interactive
+     * }
+     *
+     * @param {string} parentUuid
+     * @param {string} attachmentId
+     * @returns {Object[]} Array of dp objects, or empty array if none loaded.
+     */
+  }, {
+    key: "getAnimationDataPoints",
+    value: function getAnimationDataPoints(parentUuid, attachmentId) {
+      var key = this._key(parentUuid, attachmentId);
+      var entries = this._entries.get(key);
+      if (!(entries !== null && entries !== void 0 && entries.length)) return [];
+
+      // Collapse multiple mesh entries that share the same stateVariable
+      var seen = new Map(); // stateVariable → anim
+      var _iterator3 = _rollupPluginBabelHelpers.createForOfIteratorHelper(entries),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var anim = _step3.value.anim;
+          if (!seen.has(anim.stateVariable)) {
+            seen.set(anim.stateVariable, anim);
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      var dps = [];
+      var _iterator4 = _rollupPluginBabelHelpers.createForOfIteratorHelper(seen),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _step4$value = _rollupPluginBabelHelpers.slicedToArray(_step4.value, 2),
+            stateVar = _step4$value[0],
+            _anim = _step4$value[1];
+          // Normalise stateType from AnimateDevicesDialog variants
+          var stateType = void 0;
+          var raw = (_anim.stateType || '').toLowerCase();
+          if (raw === 'binary' || raw === 'boolean') {
+            stateType = 'binary';
+          } else if (raw === 'enum') {
+            stateType = 'enum';
+          } else {
+            // 'continuous', 'range', 'number', or anything else → numeric slider
+            stateType = 'number';
+          }
+
+          // Derive stateConfig from mappings
+          var stateConfig = {};
+          var mappingValues = (_anim.mappings || []).map(function (m) {
+            return m.stateValue;
+          });
+          if (stateType === 'enum') {
+            stateConfig.options = _rollupPluginBabelHelpers.toConsumableArray(new Set(mappingValues.map(String)));
+          } else if (stateType === 'number') {
+            var nums = mappingValues.map(Number).filter(function (n) {
+              return !isNaN(n);
+            });
+            if (nums.length) {
+              stateConfig.min = Math.min.apply(Math, _rollupPluginBabelHelpers.toConsumableArray(nums));
+              stateConfig.max = Math.max.apply(Math, _rollupPluginBabelHelpers.toConsumableArray(nums));
+            }
+          }
+
+          // Sensible default values
+          var defaultValue = void 0;
+          if (stateType === 'binary') {
+            defaultValue = 0;
+          } else if (stateType === 'enum') {
+            var _stateConfig$options$, _stateConfig$options;
+            defaultValue = (_stateConfig$options$ = (_stateConfig$options = stateConfig.options) === null || _stateConfig$options === void 0 ? void 0 : _stateConfig$options[0]) !== null && _stateConfig$options$ !== void 0 ? _stateConfig$options$ : '';
+          } else {
+            var _stateConfig$min;
+            defaultValue = (_stateConfig$min = stateConfig.min) !== null && _stateConfig$min !== void 0 ? _stateConfig$min : 0;
+          }
+          dps.push({
+            id: stateVar,
+            name: _anim.name || stateVar,
+            stateType: stateType,
+            stateConfig: stateConfig,
+            defaultValue: defaultValue,
+            direction: 'input'
+          });
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      return dps;
+    }
+
+    /**
+     * Return the Three.js mesh objects that are animated for a given attachment.
+     * Used by IoOutlineManager to include animated meshes in the outline.
+     *
+     * @param {string} parentUuid
+     * @param {string} attachmentId
+     * @returns {THREE.Object3D[]}
+     */
+  }, {
+    key: "getAnimatedMeshes",
+    value: function getAnimatedMeshes(parentUuid, attachmentId) {
+      var key = this._key(parentUuid, attachmentId);
+      var entries = this._entries.get(key);
+      if (!(entries !== null && entries !== void 0 && entries.length)) return [];
+      // Deduplicate — multiple animations can target the same mesh
+      return _rollupPluginBabelHelpers.toConsumableArray(new Set(entries.map(function (e) {
+        return e.mesh;
+      })));
+    }
+
+    /**
+     * Remove all animation entries associated with a given host component.
+     * Call when a component is removed from the scene.
+     *
+     * @param {string} parentUuid
+     */
+  }, {
+    key: "unloadForComponent",
+    value: function unloadForComponent(parentUuid) {
+      var prefix = "".concat(parentUuid, "::");
+      var _iterator5 = _rollupPluginBabelHelpers.createForOfIteratorHelper(this._entries.keys()),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var key = _step5.value;
+          if (key.startsWith(prefix)) {
+            this._entries.delete(key);
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._entries.clear();
+      _rollupPluginBabelHelpers.superPropGet(IoBehaviorManager, "dispose", this, 3)([]);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // PRIVATE HELPERS
+    // ─────────────────────────────────────────────────────────────────────────
+  }, {
+    key: "_key",
+    value: function _key(parentUuid, attachmentId) {
+      return "".concat(parentUuid, "::").concat(attachmentId);
+    }
+
+    /**
+     * Find the mesh inside `root` using UUID first, then name as fallback.
+     * GLTFLoader assigns fresh UUIDs on every load, so name is the reliable key.
+     * @param {Object} anim
+     * @param {THREE.Object3D} root
+     * @returns {THREE.Object3D|null}
+     */
+  }, {
+    key: "_resolveMesh",
+    value: function _resolveMesh(anim, root) {
+      var found = null;
+      root.traverse(function (obj) {
+        if (found) return;
+
+        // Prefer UUID match (works when the device was cloned from a cached instance
+        // whose UUIDs were preserved)
+        if (anim.meshUuid && obj.uuid === anim.meshUuid) {
+          found = obj;
+          return;
+        }
+
+        // Reliable fallback: mesh name
+        if (anim.meshName && obj.name === anim.meshName) {
+          found = obj;
+        }
+      });
+      return found;
+    }
+
+    /**
+     * Resolve which mapping row to use and apply all declared transform types.
+     * @param {{ anim, mesh, origPos, origRot }} entry
+     * @param {*} value - Current state value
+     */
+  }, {
+    key: "_applyAnimation",
+    value: function _applyAnimation(entry, value) {
+      var anim = entry.anim,
+        mesh = entry.mesh,
+        origPos = entry.origPos,
+        origRot = entry.origRot;
+      var mapping = this._resolveMapping(anim, value);
+      if (!mapping) return;
+      var types = anim.transformTypes || [];
+      var _iterator6 = _rollupPluginBabelHelpers.createForOfIteratorHelper(types),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var type = _step6.value;
+          if (type === 'translation') {
+            this._applyTranslation(mesh, origPos, mapping.transform);
+          } else if (type === 'rotation') {
+            this._applyRotation(mesh, origPos, origRot, anim, mapping.rotationTransform);
+          } else if (type === 'color') {
+            this._applyColor(mesh, mapping.colorTransform);
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    }
+
+    /**
+     * Find the mapping row that matches `value` for the given animation entry.
+     *
+     * - binary / enum: find where mapping.stateValue == value (loose equality so
+     *   JSON-deserialised "true" matches boolean true)
+     * - continuous: linear interpolation between ordered anchor points
+     *
+     * @returns {Object|null} The matched/interpolated mapping row, or null.
+     */
+  }, {
+    key: "_resolveMapping",
+    value: function _resolveMapping(anim, value) {
+      var mappings = anim.mappings;
+      if (!(mappings !== null && mappings !== void 0 && mappings.length)) return null;
+
+      // Normalise stateType variants saved by AnimateDevicesDialog
+      // ('boolean' → 'binary', 'range' → 'continuous')
+      var raw = (anim.stateType || '').toLowerCase();
+      var stateType;
+      if (raw === 'binary' || raw === 'boolean') {
+        stateType = 'binary';
+      } else if (raw === 'continuous' || raw === 'range') {
+        stateType = 'continuous';
+      } else {
+        stateType = raw;
+      }
+      if (stateType === 'binary' || stateType === 'enum') {
+        var _mappings$find;
+        // eslint-disable-next-line eqeqeq
+        return (_mappings$find = mappings.find(function (m) {
+          return m.stateValue == value;
+        })) !== null && _mappings$find !== void 0 ? _mappings$find : null;
+      }
+      if (stateType === 'continuous') {
+        var num = Number(value);
+        if (isNaN(num)) return null;
+
+        // Sort anchors by numeric stateValue
+        var sorted = _rollupPluginBabelHelpers.toConsumableArray(mappings).filter(function (m) {
+          return m.stateValue != null && !isNaN(Number(m.stateValue));
+        }).sort(function (a, b) {
+          return Number(a.stateValue) - Number(b.stateValue);
+        });
+        if (!sorted.length) return null;
+        if (sorted.length === 1) return sorted[0];
+
+        // Clamp to range
+        if (num <= Number(sorted[0].stateValue)) return sorted[0];
+        if (num >= Number(sorted[sorted.length - 1].stateValue)) return sorted[sorted.length - 1];
+
+        // Find surrounding anchors and interpolate
+        for (var i = 0; i < sorted.length - 1; i++) {
+          var lo = sorted[i];
+          var hi = sorted[i + 1];
+          var loVal = Number(lo.stateValue);
+          var hiVal = Number(hi.stateValue);
+          if (num >= loVal && num <= hiVal) {
+            var t = (num - loVal) / (hiVal - loVal);
+            return this._lerpMapping(lo, hi, t);
+          }
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Linear-interpolate between two mapping rows.
+     * @param {Object} lo - lower anchor mapping
+     * @param {Object} hi - upper anchor mapping
+     * @param {number} t  - 0..1
+     */
+  }, {
+    key: "_lerpMapping",
+    value: function _lerpMapping(lo, hi, t) {
+      var _lo$transform$x, _lo$transform, _hi$transform$x, _hi$transform, _lo$transform$y, _lo$transform2, _hi$transform$y, _hi$transform2, _lo$transform$z, _lo$transform3, _hi$transform$z, _hi$transform3;
+      var lerp = function lerp(a, b) {
+        return a + (b - a) * t;
+      };
+      var transform = {
+        x: lerp((_lo$transform$x = (_lo$transform = lo.transform) === null || _lo$transform === void 0 ? void 0 : _lo$transform.x) !== null && _lo$transform$x !== void 0 ? _lo$transform$x : 0, (_hi$transform$x = (_hi$transform = hi.transform) === null || _hi$transform === void 0 ? void 0 : _hi$transform.x) !== null && _hi$transform$x !== void 0 ? _hi$transform$x : 0),
+        y: lerp((_lo$transform$y = (_lo$transform2 = lo.transform) === null || _lo$transform2 === void 0 ? void 0 : _lo$transform2.y) !== null && _lo$transform$y !== void 0 ? _lo$transform$y : 0, (_hi$transform$y = (_hi$transform2 = hi.transform) === null || _hi$transform2 === void 0 ? void 0 : _hi$transform2.y) !== null && _hi$transform$y !== void 0 ? _hi$transform$y : 0),
+        z: lerp((_lo$transform$z = (_lo$transform3 = lo.transform) === null || _lo$transform3 === void 0 ? void 0 : _lo$transform3.z) !== null && _lo$transform$z !== void 0 ? _lo$transform$z : 0, (_hi$transform$z = (_hi$transform3 = hi.transform) === null || _hi$transform3 === void 0 ? void 0 : _hi$transform3.z) !== null && _hi$transform$z !== void 0 ? _hi$transform$z : 0)
+      };
+      var rotationTransform = lerp(typeof lo.rotationTransform === 'number' ? lo.rotationTransform : 0, typeof hi.rotationTransform === 'number' ? hi.rotationTransform : 0);
+
+      // Color interpolation: convert hex → RGB components → lerp → back to hex
+      var colorTransform = this._lerpHex(lo.colorTransform, hi.colorTransform, t);
+      return {
+        stateValue: null,
+        transform: transform,
+        rotationTransform: rotationTransform,
+        colorTransform: colorTransform
+      };
+    }
+
+    /**
+     * Interpolate between two hex colour strings.
+     */
+  }, {
+    key: "_lerpHex",
+    value: function _lerpHex(hexA, hexB, t) {
+      try {
+        var ca = new THREE__namespace.Color(hexA);
+        var cb = new THREE__namespace.Color(hexB);
+        ca.lerp(cb, t);
+        return "#".concat(ca.getHexString());
+      } catch (_unused) {
+        return hexA !== null && hexA !== void 0 ? hexA : '#ffffff';
+      }
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // TRANSFORM APPLIERS
+    // ─────────────────────────────────────────────────────────────────────────
+
+    /**
+     * 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
+     */
+  }, {
+    key: "_applyTranslation",
+    value: function _applyTranslation(mesh, origPos, transform) {
+      var _transform$x, _transform$y, _transform$z;
+      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));
+    }
+
+    /**
+     * Apply a rotation around an arbitrary pivot point in device-local space,
+     * optionally also displacing the mesh position to simulate orbital motion.
+     *
+     * Math (all in device-local space):
+     *   pivot   = rotAxisOffset
+     *   delta   = origPos - pivot
+     *   newDelta = rotate(delta, angle, axis)
+     *   newPos  = pivot + newDelta
+     *   newRot[axis] = origRot[axis] + angle
+     *
+     * @param {THREE.Object3D} mesh
+     * @param {THREE.Vector3}  origPos
+     * @param {THREE.Euler}    origRot
+     * @param {Object}         anim
+     * @param {number}         angleDeg - Degrees
+     */
+  }, {
+    key: "_applyRotation",
+    value: function _applyRotation(mesh, origPos, origRot, anim, angleDeg) {
+      var _anim$rotAxis, _anim$rotAxisOffset, _off$x, _off$y, _off$z;
+      var angle = THREE__namespace.MathUtils.degToRad(typeof angleDeg === 'number' ? angleDeg : 0);
+      var axis = ((_anim$rotAxis = anim.rotAxis) !== null && _anim$rotAxis !== void 0 ? _anim$rotAxis : 'x').toLowerCase();
+      var off = (_anim$rotAxisOffset = anim.rotAxisOffset) !== null && _anim$rotAxisOffset !== void 0 ? _anim$rotAxisOffset : {
+        x: 0,
+        y: 0,
+        z: 0
+      };
+
+      // Unit vector for the chosen axis
+      var axisVec = new THREE__namespace.Vector3(axis === 'x' ? 1 : 0, axis === 'y' ? 1 : 0, axis === 'z' ? 1 : 0);
+      var pivot = new THREE__namespace.Vector3((_off$x = off.x) !== null && _off$x !== void 0 ? _off$x : 0, (_off$y = off.y) !== null && _off$y !== void 0 ? _off$y : 0, (_off$z = off.z) !== null && _off$z !== void 0 ? _off$z : 0);
+      var delta = origPos.clone().sub(pivot);
+      delta.applyAxisAngle(axisVec, angle);
+      mesh.position.copy(pivot).add(delta);
+      mesh.rotation[axis] = origRot[axis] + angle;
+    }
+
+    /**
+     * Apply a colour to all Mesh descendants of `mesh`.
+     * Creates a cloned material per mesh on first call to avoid shared-material
+     * cross-contamination between different device instances.
+     *
+     * @param {THREE.Object3D} mesh
+     * @param {string} colorHex - e.g. '#ff0000'
+     */
+  }, {
+    key: "_applyColor",
+    value: function _applyColor(mesh, colorHex) {
+      if (!colorHex) return;
+      mesh.traverse(function (obj) {
+        if (!obj.isMesh || !obj.material) return;
+
+        // Ensure this mesh has its own material instance
+        if (!obj.userData._materialCloned) {
+          obj.material = obj.material.clone();
+          obj.userData._materialCloned = true;
+        }
+        try {
+          obj.material.color.set(colorHex);
+        } catch (e) {
+          // Material may not have a color property (e.g. MeshDepthMaterial)
+        }
+      });
+    }
+  }]);
+}(baseDisposable.BaseDisposable);
+
+exports.IoBehaviorManager = IoBehaviorManager;

package/dist/cjs/src/managers/scene/componentTooltipManager.js

@@ -163,7 +163,7 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
       var currentVal = (_ref = storedVal !== null && storedVal !== void 0 ? storedVal : binaryState.defaultValue) !== null && _ref !== void 0 ? _ref : false;
       var newVal = !Boolean(currentVal);
       this._stateAdapter.setState(scopedAttachmentId, dpId, newVal);
-      (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.ioAnimationManager) === null || _this$sceneViewer === void 0 || _this$sceneViewer.triggerState(attachmentId, dpId, newVal, parentUuid);
+      (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.ioBehaviorManager) === null || _this$sceneViewer === void 0 || _this$sceneViewer.triggerState(attachmentId, dpId, newVal, parentUuid);
       console.log("\uD83D\uDD04 [IODevice] Toggled ".concat(scopedAttachmentId, ".").concat(dpId, ": ").concat(currentVal, " \u2192 ").concat(newVal));
     }
 
@@ -196,8 +196,8 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
         obj = obj.parent;
       }
       var scopedAttachmentId = this._getScopedAttachmentKey(attachmentId, parentUuid);
-      var ioAnimMgr = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.managers) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.ioAnimationManager;
-      var dataPoints = ((ioAnimMgr === null || ioAnimMgr === void 0 ? void 0 : ioAnimMgr.getAnimationDataPoints(parentUuid, attachmentId)) || []).concat((ud === null || ud === void 0 ? void 0 : ud.dataPoints) || [])
+      var ioBehavMgr = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.managers) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.ioBehaviorManager;
+      var dataPoints = ((ioBehavMgr === null || ioBehavMgr === void 0 ? void 0 : ioBehavMgr.getAnimationDataPoints(parentUuid, attachmentId)) || []).concat((ud === null || ud === void 0 ? void 0 : ud.dataPoints) || [])
       // deduplicate by id
       .filter(function (dp, i, arr) {
         return arr.findIndex(function (d) {
@@ -326,7 +326,7 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
         dp = _ref2.dp;
       var dpId = dp.id;
       (_this$_stateAdapter = this._stateAdapter) === null || _this$_stateAdapter === void 0 || _this$_stateAdapter.setState(scopedAttachmentId, dpId, newVal);
-      (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.managers) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.ioAnimationManager) === null || _this$sceneViewer3 === void 0 || _this$sceneViewer3.triggerState(attachmentId, dpId, newVal, parentUuid);
+      (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.managers) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.ioBehaviorManager) === null || _this$sceneViewer3 === void 0 || _this$sceneViewer3.triggerState(attachmentId, dpId, newVal, parentUuid);
     }
 
     /**
@@ -451,11 +451,11 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
           var _this3$sceneViewer$ma, _this3$sceneViewer;
           var attachmentId = child.userData.attachmentId || '';
 
-          // Use only data points from the animate window (animationConfig).
+          // Use only data points from the animate window (behaviorConfig).
           // The static ioConfig.states[] snapshot on userData is intentionally ignored.
-          var dataPoints = (_this3$sceneViewer$ma = (_this3$sceneViewer = _this3.sceneViewer) === null || _this3$sceneViewer === void 0 || (_this3$sceneViewer = _this3$sceneViewer.managers) === null || _this3$sceneViewer === void 0 || (_this3$sceneViewer = _this3$sceneViewer.ioAnimationManager) === null || _this3$sceneViewer === void 0 ? void 0 : _this3$sceneViewer.getAnimationDataPoints(parentUuid, attachmentId)) !== null && _this3$sceneViewer$ma !== void 0 ? _this3$sceneViewer$ma : [];
+          var dataPoints = (_this3$sceneViewer$ma = (_this3$sceneViewer = _this3.sceneViewer) === null || _this3$sceneViewer === void 0 || (_this3$sceneViewer = _this3$sceneViewer.managers) === null || _this3$sceneViewer === void 0 || (_this3$sceneViewer = _this3$sceneViewer.ioBehaviorManager) === null || _this3$sceneViewer === void 0 ? void 0 : _this3$sceneViewer.getAnimationDataPoints(parentUuid, attachmentId)) !== null && _this3$sceneViewer$ma !== void 0 ? _this3$sceneViewer$ma : [];
 
-          // When data points come from animationConfig they already carry direction:'input'.
+          // When data points come from behaviorConfig they already carry direction:'input'.
           // Pass null so _buildDataPointRow uses the per-dp direction instead of the
           // device-level ioDirection (which may be 'output' and would hide controls).
           var deviceDirection = dataPoints.length > 0 ? null : child.userData.ioDirection || 'output';
@@ -694,7 +694,7 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
           var _this5$_stateAdapter, _this5$selectedObject, _this5$sceneViewer;
           (_this5$_stateAdapter = _this5._stateAdapter) === null || _this5$_stateAdapter === void 0 || _this5$_stateAdapter.setState(scopedAttachmentId, dpId, newVal);
           var parentUuid = ((_this5$selectedObject = _this5.selectedObject) === null || _this5$selectedObject === void 0 ? void 0 : _this5$selectedObject.uuid) || null;
-          (_this5$sceneViewer = _this5.sceneViewer) === null || _this5$sceneViewer === void 0 || (_this5$sceneViewer = _this5$sceneViewer.managers) === null || _this5$sceneViewer === void 0 || (_this5$sceneViewer = _this5$sceneViewer.ioAnimationManager) === null || _this5$sceneViewer === void 0 || _this5$sceneViewer.triggerState(originalAttachmentId || scopedAttachmentId, dpId, newVal, parentUuid);
+          (_this5$sceneViewer = _this5.sceneViewer) === null || _this5$sceneViewer === void 0 || (_this5$sceneViewer = _this5$sceneViewer.managers) === null || _this5$sceneViewer === void 0 || (_this5$sceneViewer = _this5$sceneViewer.ioBehaviorManager) === null || _this5$sceneViewer === void 0 || _this5$sceneViewer.triggerState(originalAttachmentId || scopedAttachmentId, dpId, newVal, parentUuid);
         });
         row.appendChild(ctrl);
         this._stateElements.set(key, {

package/dist/cjs/src/managers/scene/modelManager.js

@@ -77,7 +77,7 @@ var ModelManager = /*#__PURE__*/function () {
     key: "loadLibraryModel",
     value: function () {
       var _loadLibraryModel = _rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee(targetMesh, jsonEntry, componentData) {
-        var component, _jsonEntry$userData, _jsonEntry$userData2, _jsonEntry$userData3, originalProps, connectorChildren, gltfScene, libraryModel, _this$sceneViewer, ioAnimMgr, _loop, _i, _Object$entries, warmFn, _jsonEntry$userData4, _t;
+        var component, _jsonEntry$userData, _jsonEntry$userData2, _jsonEntry$userData3, originalProps, connectorChildren, gltfScene, libraryModel, _this$sceneViewer, ioBehavMgr, _loop, _i, _Object$entries, warmFn, _jsonEntry$userData4, _t;
         return _rollupPluginBabelHelpers.regenerator().w(function (_context2) {
           while (1) switch (_context2.n) {
             case 0:
@@ -120,22 +120,22 @@ var ModelManager = /*#__PURE__*/function () {
               _context2.n = 4;
               return ioDeviceUtils.attachIODevicesToComponent(libraryModel, componentData, modelPreloader["default"], originalProps.uuid);
             case 4:
-              // Register animation configs for each attached device
-              ioAnimMgr = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.ioAnimationManager;
-              if (!ioAnimMgr) {
+              // Register behavior configs for each attached device
+              ioBehavMgr = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.ioBehaviorManager;
+              if (!ioBehavMgr) {
                 _context2.n = 8;
                 break;
               }
               _loop = /*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _loop() {
-                var _modelPreloader$compo, _deviceData$animation;
+                var _modelPreloader$compo, _deviceData$behaviorC;
                 var _Object$entries$_i, attachmentId, attachment, deviceData, deviceRoot;
                 return _rollupPluginBabelHelpers.regenerator().w(function (_context) {
                   while (1) switch (_context.n) {
                     case 0:
                       _Object$entries$_i = _rollupPluginBabelHelpers.slicedToArray(_Object$entries[_i], 2), attachmentId = _Object$entries$_i[0], attachment = _Object$entries$_i[1];
                       deviceData = (_modelPreloader$compo = modelPreloader["default"].componentDictionary) === null || _modelPreloader$compo === void 0 ? void 0 : _modelPreloader$compo[attachment.deviceId];
-                      console.log("[ModelManager] attachment \"".concat(attachmentId, "\" \u2192 deviceId \"").concat(attachment.deviceId, "\" \u2192 animationConfig:"), (_deviceData$animation = deviceData === null || deviceData === void 0 ? void 0 : deviceData.animationConfig) !== null && _deviceData$animation !== void 0 ? _deviceData$animation : 'NONE');
-                      if (deviceData !== null && deviceData !== void 0 && deviceData.animationConfig) {
+                      console.log("[ModelManager] attachment \"".concat(attachmentId, "\" \u2192 deviceId \"").concat(attachment.deviceId, "\" \u2192 behaviorConfig:"), (_deviceData$behaviorC = deviceData === null || deviceData === void 0 ? void 0 : deviceData.behaviorConfig) !== null && _deviceData$behaviorC !== void 0 ? _deviceData$behaviorC : 'NONE');
+                      if (deviceData !== null && deviceData !== void 0 && deviceData.behaviorConfig) {
                         _context.n = 1;
                         break;
                       }
@@ -147,7 +147,7 @@ var ModelManager = /*#__PURE__*/function () {
                         if (!deviceRoot && ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.attachmentId) === attachmentId) deviceRoot = obj;
                       });
                       if (deviceRoot) {
-                        ioAnimMgr.loadAnimations(attachmentId, deviceData.animationConfig, deviceRoot, originalProps.uuid);
+                        ioBehavMgr.loadBehaviors(attachmentId, deviceData.behaviorConfig, deviceRoot, originalProps.uuid);
                       }
                     case 2:
                       return _context.a(2);