@2112-lab/central-plant 0.3.38 → 0.3.41

package/dist/esm/src/utils/behaviorRegistration.js

@@ -0,0 +1,71 @@
+import { slicedToArray as _slicedToArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * Register mesh animations and intra-component state links when a smart
+ * component is placed or imported into the scene.
+ *
+ * @param {import('../managers/behaviors/IoBehaviorManager.js').IoBehaviorManager} ioBehavMgr
+ * @param {string} componentUuid - Instance UUID of the parent component
+ * @param {Object} componentData - Smart component dictionary entry
+ * @param {Object} componentModel - Root THREE.Object3D of the placed component
+ * @param {Object} componentDictionary - modelPreloader.componentDictionary
+ */
+function registerBehaviorsForComponent(ioBehavMgr, componentUuid, componentData, componentModel, componentDictionary) {
+  var _componentData$behavi;
+  if (!ioBehavMgr || !componentData || !componentModel) {
+    return;
+  }
+  if (componentData.isSmart && componentData.attachedDevices) {
+    var _loop = function _loop() {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        attachmentId = _Object$entries$_i[0],
+        attachment = _Object$entries$_i[1];
+      var deviceData = componentDictionary === null || componentDictionary === void 0 ? void 0 : componentDictionary[attachment.deviceId];
+      if (!(deviceData !== null && deviceData !== void 0 && deviceData.behaviorConfig)) return 1; // continue
+      var deviceRoot = null;
+      componentModel.traverse(function (obj) {
+        var _obj$userData;
+        if (!deviceRoot && ((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.attachmentId) === attachmentId) deviceRoot = obj;
+      });
+      if (deviceRoot) {
+        ioBehavMgr.loadBehaviors(attachmentId, deviceData.behaviorConfig, deviceRoot, componentUuid);
+      }
+    };
+    for (var _i = 0, _Object$entries = Object.entries(componentData.attachedDevices); _i < _Object$entries.length; _i++) {
+      if (_loop()) continue;
+    }
+  }
+  if (((_componentData$behavi = componentData.behaviors) === null || _componentData$behavi === void 0 ? void 0 : _componentData$behavi.length) > 0) {
+    ioBehavMgr.registerComponentBehaviors(componentUuid, componentData.behaviors);
+  } else if (componentData.isSmart) {
+    ioBehavMgr.registerComponentBehaviors(componentUuid, []);
+  }
+}
+
+/**
+ * Reload mesh behaviorConfig for every placed instance of an I/O device asset.
+ * Call after the animation wizard saves updated behaviorConfig to the dictionary.
+ *
+ * @param {import('../managers/behaviors/IoBehaviorManager.js').IoBehaviorManager} ioBehavMgr
+ * @param {string} deviceAssetId - Dictionary / asset id of the I/O device
+ * @param {Object} componentDictionary
+ * @param {Object} centralPlant
+ */
+function reloadBehaviorsForDeviceAsset(ioBehavMgr, deviceAssetId, componentDictionary, centralPlant) {
+  var _centralPlant$sceneVi;
+  var scene = centralPlant === null || centralPlant === void 0 || (_centralPlant$sceneVi = centralPlant.sceneViewer) === null || _centralPlant$sceneVi === void 0 ? void 0 : _centralPlant$sceneVi.scene;
+  var deviceData = componentDictionary === null || componentDictionary === void 0 ? void 0 : componentDictionary[deviceAssetId];
+  if (!ioBehavMgr || !scene || !(deviceData !== null && deviceData !== void 0 && deviceData.behaviorConfig)) return;
+  scene.traverse(function (obj) {
+    var _obj$userData2, _obj$userData3, _obj$parent;
+    if (((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.objectType) !== 'io-device') return;
+    if (((_obj$userData3 = obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.deviceId) !== deviceAssetId) return;
+    var parentUuid = obj.userData.parentComponentId || ((_obj$parent = obj.parent) === null || _obj$parent === void 0 ? void 0 : _obj$parent.uuid);
+    var attachmentId = obj.userData.attachmentId;
+    if (!parentUuid || !attachmentId) return;
+    ioBehavMgr.unloadForAttachment(parentUuid, attachmentId);
+    ioBehavMgr.loadBehaviors(attachmentId, deviceData.behaviorConfig, obj, parentUuid);
+  });
+}
+
+export { registerBehaviorsForComponent, reloadBehaviorsForDeviceAsset };

package/dist/esm/src/utils/behaviorSceneUtils.js

@@ -0,0 +1,147 @@
+import { registerBehaviorsForComponent } from './behaviorRegistration.js';
+import { getScopedAttachmentKey, getIoBehaviorManager } from './behaviorDispatch.js';
+
+/**
+ * Scene-level behavior helpers: scan endpoints, register behaviors, cross-component links.
+ */
+function getComponentDictionary(centralPlant) {
+  var _centralPlant$getUtil, _centralPlant$manager;
+  return (centralPlant === null || centralPlant === void 0 || (_centralPlant$getUtil = centralPlant.getUtility) === null || _centralPlant$getUtil === void 0 || (_centralPlant$getUtil = _centralPlant$getUtil.call(centralPlant, 'modelPreloader')) === null || _centralPlant$getUtil === void 0 ? void 0 : _centralPlant$getUtil.componentDictionary) || (centralPlant === null || centralPlant === void 0 || (_centralPlant$manager = centralPlant.managers) === null || _centralPlant$manager === void 0 || (_centralPlant$manager = _centralPlant$manager.componentDataManager) === null || _centralPlant$manager === void 0 ? void 0 : _centralPlant$manager.componentDictionary) || null;
+}
+function statesFromBehaviorConfig(device) {
+  if (!(device !== null && device !== void 0 && device.behaviorConfig) || !Array.isArray(device.behaviorConfig)) return [];
+  return device.behaviorConfig.map(function (b) {
+    return b.stateVariable;
+  }).filter(Boolean).filter(function (v, i, arr) {
+    return arr.indexOf(v) === i;
+  });
+}
+function resolveStatesForDevice(ioObj, deviceId, componentDictionary) {
+  var _ioObj$userData;
+  var device = componentDictionary === null || componentDictionary === void 0 ? void 0 : componentDictionary[deviceId];
+  var fromBehaviorConfig = statesFromBehaviorConfig(device);
+  if (fromBehaviorConfig.length) return fromBehaviorConfig;
+  return (((_ioObj$userData = ioObj.userData) === null || _ioObj$userData === void 0 ? void 0 : _ioObj$userData.dataPoints) || []).map(function (dp) {
+    return dp.id || dp.name;
+  }).filter(Boolean).filter(function (v, i, arr) {
+    return arr.indexOf(v) === i;
+  });
+}
+
+/**
+ * Scan the live Three.js scene for smart-component io-device endpoints.
+ */
+function scanSceneIoEndpoints(centralPlant) {
+  var _centralPlant$sceneVi;
+  var scene = centralPlant === null || centralPlant === void 0 || (_centralPlant$sceneVi = centralPlant.sceneViewer) === null || _centralPlant$sceneVi === void 0 ? void 0 : _centralPlant$sceneVi.scene;
+  if (!scene) return [];
+  var dict = getComponentDictionary(centralPlant);
+  var endpoints = [];
+  scene.traverse(function (obj) {
+    var _obj$userData, _parent$userData, _parent$userData2;
+    if (((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) !== 'io-device') return;
+    var parent = obj.parent;
+    var parentUuid = obj.userData.parentComponentId || (parent === null || parent === void 0 ? void 0 : parent.uuid) || '';
+    var parentName = (parent === null || parent === void 0 || (_parent$userData = parent.userData) === null || _parent$userData === void 0 ? void 0 : _parent$userData.hardcodedUuid) || (parent === null || parent === void 0 ? void 0 : parent.name) || parentUuid;
+    var libraryId = (parent === null || parent === void 0 || (_parent$userData2 = parent.userData) === null || _parent$userData2 === void 0 ? void 0 : _parent$userData2.libraryId) || '';
+    var attachmentId = obj.userData.attachmentId || obj.name || obj.uuid;
+    var deviceId = obj.userData.deviceId || '';
+    endpoints.push({
+      key: getScopedAttachmentKey(attachmentId, parentUuid),
+      parentUuid: parentUuid,
+      parentName: parentName,
+      libraryId: libraryId,
+      attachmentId: attachmentId,
+      attachmentLabel: obj.userData.attachmentLabel || attachmentId,
+      deviceId: deviceId,
+      states: resolveStatesForDevice(obj, deviceId, dict)
+    });
+  });
+  return endpoints;
+}
+
+/**
+ * Load cross-component behaviors from scene data mirrors.
+ */
+function loadCrossComponentBehaviors(centralPlant) {
+  var _centralPlant$importe, _centralPlant$sceneVi2;
+  return (centralPlant === null || centralPlant === void 0 || (_centralPlant$importe = centralPlant.importedSceneData) === null || _centralPlant$importe === void 0 ? void 0 : _centralPlant$importe.behaviors) || (centralPlant === null || centralPlant === void 0 || (_centralPlant$sceneVi2 = centralPlant.sceneViewer) === null || _centralPlant$sceneVi2 === void 0 || (_centralPlant$sceneVi2 = _centralPlant$sceneVi2.currentSceneData) === null || _centralPlant$sceneVi2 === void 0 ? void 0 : _centralPlant$sceneVi2.behaviors) || [];
+}
+
+/**
+ * Persist cross-component behaviors to scene data mirrors and the runtime manager.
+ */
+function applyCrossComponentBehaviors(centralPlant, behaviors) {
+  var normalized = behaviors || [];
+  if (centralPlant.importedSceneData) {
+    if (normalized.length) {
+      centralPlant.importedSceneData.behaviors = normalized;
+    } else {
+      delete centralPlant.importedSceneData.behaviors;
+    }
+  }
+  var sceneViewer = centralPlant.sceneViewer;
+  if (sceneViewer && !sceneViewer.currentSceneData) {
+    var _centralPlant$getConn;
+    sceneViewer.currentSceneData = {
+      version: '2.3',
+      connections: ((_centralPlant$getConn = centralPlant.getConnections) === null || _centralPlant$getConn === void 0 ? void 0 : _centralPlant$getConn.call(centralPlant)) || [],
+      scene: {
+        children: []
+      }
+    };
+  }
+  var currentSceneData = sceneViewer === null || sceneViewer === void 0 ? void 0 : sceneViewer.currentSceneData;
+  if (currentSceneData) {
+    if (normalized.length) {
+      currentSceneData.behaviors = normalized;
+    } else {
+      delete currentSceneData.behaviors;
+    }
+  }
+  var ioBehavMgr = getIoBehaviorManager(sceneViewer);
+  if (ioBehavMgr) {
+    ioBehavMgr.setCrossComponentBehaviors(normalized);
+  }
+}
+
+/**
+ * Re-register intra-component behaviors on all scene instances of a smart component.
+ */
+function refreshSceneIntraBehaviors(centralPlant, libraryId, behaviors) {
+  var _centralPlant$sceneVi3;
+  var ioBehavMgr = getIoBehaviorManager(centralPlant === null || centralPlant === void 0 ? void 0 : centralPlant.sceneViewer);
+  var scene = centralPlant === null || centralPlant === void 0 || (_centralPlant$sceneVi3 = centralPlant.sceneViewer) === null || _centralPlant$sceneVi3 === void 0 ? void 0 : _centralPlant$sceneVi3.scene;
+  if (!ioBehavMgr || !scene || !libraryId) return;
+  scene.traverse(function (obj) {
+    var _obj$userData2, _obj$userData3;
+    if (((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.objectType) === 'component' && ((_obj$userData3 = obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.libraryId) === libraryId) {
+      ioBehavMgr.registerComponentBehaviors(obj.uuid, behaviors || []);
+    }
+  });
+}
+
+/**
+ * Re-register intra- and cross-component behaviors for all instances in the live scene.
+ */
+function reregisterSceneBehaviors(centralPlant) {
+  var _centralPlant$sceneVi4;
+  var ioBehavMgr = getIoBehaviorManager(centralPlant === null || centralPlant === void 0 ? void 0 : centralPlant.sceneViewer);
+  var scene = centralPlant === null || centralPlant === void 0 || (_centralPlant$sceneVi4 = centralPlant.sceneViewer) === null || _centralPlant$sceneVi4 === void 0 ? void 0 : _centralPlant$sceneVi4.scene;
+  var dict = getComponentDictionary(centralPlant);
+  if (!ioBehavMgr || !scene) return;
+  var crossBehaviors = loadCrossComponentBehaviors(centralPlant);
+  ioBehavMgr.setCrossComponentBehaviors(crossBehaviors);
+  if (!dict) return;
+  scene.traverse(function (obj) {
+    var _obj$userData4, _obj$userData5;
+    if (((_obj$userData4 = obj.userData) === null || _obj$userData4 === void 0 ? void 0 : _obj$userData4.objectType) !== 'component') return;
+    var libraryId = (_obj$userData5 = obj.userData) === null || _obj$userData5 === void 0 ? void 0 : _obj$userData5.libraryId;
+    if (!libraryId) return;
+    var componentData = dict[libraryId];
+    if (!componentData) return;
+    registerBehaviorsForComponent(ioBehavMgr, obj.uuid, componentData, obj, dict);
+  });
+}
+
+export { applyCrossComponentBehaviors, loadCrossComponentBehaviors, refreshSceneIntraBehaviors, reregisterSceneBehaviors, scanSceneIoEndpoints };

package/dist/esm/src/utils/behaviorSchema.js

@@ -0,0 +1,201 @@
+import { objectSpread2 as _objectSpread2, slicedToArray as _slicedToArray, typeof as _typeof } from '../../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * Shared behavior schema helpers for runtime normalization and UI authoring.
+ * Used by IoBehaviorManager and sandbox BehaviorDialog.
+ */
+
+/**
+ * Normalize behavior from shorthand to full format.
+ * Supports:
+ *   - input: "attachment.state" → { attachment, state }
+ *   - outputs: ["attachment.state", ...] → converted to _outputs array
+ *
+ * @param {Object} behavior - Raw behavior from scene JSON
+ * @returns {Object} Normalized behavior
+ */
+function normalizeBehavior(behavior) {
+  var normalized = _objectSpread2({}, behavior);
+  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
+    };
+  }
+  if (behavior.outputs) {
+    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') {
+    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;
+}
+
+/**
+ * Build intra-component shorthand behavior from form fields.
+ */
+function buildIntraBehavior(_ref) {
+  var id = _ref.id,
+    inputAttachment = _ref.inputAttachment,
+    inputState = _ref.inputState,
+    outputs = _ref.outputs;
+  return {
+    id: id || "behavior-".concat(Date.now()),
+    input: "".concat(inputAttachment, ".").concat(inputState),
+    outputs: outputs.filter(function (o) {
+      return o.attachment && o.state;
+    }).map(function (o) {
+      return "".concat(o.attachment, ".").concat(o.state);
+    })
+  };
+}
+
+/**
+ * Parse intra-component shorthand into form fields.
+ */
+function parseIntraBehavior(behavior) {
+  var inputAttachment = null;
+  var inputState = null;
+  if (typeof behavior.input === 'string') {
+    var _behavior$input$split3 = behavior.input.split('.');
+    var _behavior$input$split4 = _slicedToArray(_behavior$input$split3, 2);
+    inputAttachment = _behavior$input$split4[0];
+    inputState = _behavior$input$split4[1];
+  } else if (behavior.input && _typeof(behavior.input) === 'object') {
+    inputAttachment = behavior.input.attachment || null;
+    inputState = behavior.input.state || null;
+  }
+  var outputs = (behavior.outputs || []).map(function (out) {
+    if (typeof out === 'string') {
+      var _out$split3 = out.split('.'),
+        _out$split4 = _slicedToArray(_out$split3, 2),
+        attachment = _out$split4[0],
+        state = _out$split4[1];
+      return {
+        attachment: attachment,
+        state: state
+      };
+    }
+    return {
+      attachment: (out === null || out === void 0 ? void 0 : out.attachment) || null,
+      state: (out === null || out === void 0 ? void 0 : out.state) || null
+    };
+  });
+  return {
+    id: behavior.id || '',
+    inputAttachment: inputAttachment || null,
+    inputState: inputState || null,
+    outputs: outputs.length ? outputs : [{
+      attachment: null,
+      state: null
+    }]
+  };
+}
+
+/**
+ * Build cross-component behavior with component instance scoping.
+ */
+function buildCrossBehavior(_ref2) {
+  var id = _ref2.id,
+    inputEndpoint = _ref2.inputEndpoint,
+    inputState = _ref2.inputState,
+    outputs = _ref2.outputs;
+  var _split = (inputEndpoint || '').split('::'),
+    _split2 = _slicedToArray(_split, 2),
+    inputComponent = _split2[0],
+    inputAttachment = _split2[1];
+  return {
+    id: id || "behavior-".concat(Date.now()),
+    input: {
+      component: inputComponent,
+      attachment: inputAttachment,
+      state: inputState
+    },
+    outputs: outputs.filter(function (o) {
+      return o.endpoint && o.state;
+    }).map(function (o) {
+      var _o$endpoint$split = o.endpoint.split('::'),
+        _o$endpoint$split2 = _slicedToArray(_o$endpoint$split, 2),
+        component = _o$endpoint$split2[0],
+        attachment = _o$endpoint$split2[1];
+      return {
+        component: component,
+        attachment: attachment,
+        state: o.state
+      };
+    })
+  };
+}
+
+/**
+ * Parse cross-component behavior into form fields.
+ */
+function parseCrossBehavior(behavior) {
+  var inputComponent, inputAttachment, inputState;
+  if (typeof behavior.input === 'string') {
+    var _behavior$input$split5 = behavior.input.split('.'),
+      _behavior$input$split6 = _slicedToArray(_behavior$input$split5, 2),
+      attachment = _behavior$input$split6[0],
+      state = _behavior$input$split6[1];
+    inputAttachment = attachment;
+    inputState = state;
+    inputComponent = null;
+  } else if (behavior.input) {
+    inputComponent = behavior.input.component;
+    inputAttachment = behavior.input.attachment;
+    inputState = behavior.input.state;
+  }
+  var rawOutputs = behavior.outputs || (behavior.output ? [behavior.output] : behavior._outputs || []);
+  var outputs = rawOutputs.map(function (out) {
+    if (typeof out === 'string') {
+      var _out$split5 = out.split('.'),
+        _out$split6 = _slicedToArray(_out$split5, 2),
+        _attachment3 = _out$split6[0],
+        _state3 = _out$split6[1];
+      return {
+        endpoint: _attachment3 ? "::".concat(_attachment3) : null,
+        state: _state3
+      };
+    }
+    var endpoint = out.component && out.attachment ? "".concat(out.component, "::").concat(out.attachment) : out.attachment ? "::".concat(out.attachment) : null;
+    return {
+      endpoint: endpoint,
+      state: out.state || null
+    };
+  });
+  var inputEndpoint = inputComponent && inputAttachment ? "".concat(inputComponent, "::").concat(inputAttachment) : inputAttachment ? "::".concat(inputAttachment) : null;
+  return {
+    id: behavior.id || '',
+    inputEndpoint: inputEndpoint,
+    inputState: inputState || null,
+    outputs: outputs.length ? outputs : [{
+      endpoint: null,
+      state: null
+    }]
+  };
+}
+
+export { buildCrossBehavior, buildIntraBehavior, normalizeBehavior, parseCrossBehavior, parseIntraBehavior };

package/dist/index.d.ts

@@ -30,8 +30,9 @@ export interface IoDeviceState {
   id: string
   name: string
   defaultValue: any
-  stateType: 'binary' | 'number' | 'enum' | 'float' | 'string'
+  stateType: 'binary' | 'number' | 'enum' | 'float' | 'string' | 'continuous' | 'boolean'
   stateConfig?: Record<string, any>
+  direction?: 'input' | 'output'
 }
 
 export interface IoDeviceConfig {
@@ -39,11 +40,57 @@ export interface IoDeviceConfig {
   states: IoDeviceState[]
 }
 
+export interface BehaviorMapping {
+  stateValue: any
+  transform?: { x?: number; y?: number; z?: number }
+  rotationTransform?: number
+  colorTransform?: string
+}
+
+export interface BehaviorEntry {
+  name?: string
+  meshUuid?: string
+  meshName?: string
+  stateVariable: string
+  stateType?: 'binary' | 'enum' | 'continuous' | 'number' | 'boolean'
+  transformTypes?: string[]
+  rotAxis?: 'x' | 'y' | 'z'
+  rotAxisOffset?: { x: number; y: number; z: number }
+  mappingAxis?: 'x' | 'y' | 'z'
+  mappings?: BehaviorMapping[]
+}
+
+export interface CrossComponentBehavior {
+  id?: string
+  input: string | { component?: string; attachment: string; state: string }
+  output?: string | { component?: string; attachment: string; state: string; child?: string }
+  outputs?: Array<string | { component?: string; attachment: string; state: string; child?: string }>
+  conditions?: Array<{ expression: string }>
+}
+
+export interface IoStateAdapter {
+  getState(attachmentId: string, dataPointId: string): any
+  setState(attachmentId: string, dataPointId: string, value: any): void
+}
+
+export interface SceneIoEndpoint {
+  key: string
+  parentUuid: string
+  parentName: string
+  libraryId: string
+  attachmentId: string
+  attachmentLabel: string
+  deviceId: string
+  states: string[]
+}
+
 export interface IoDeviceAsset {
   uuid: string
   name: string
   assetType: 'I/O Device'
   ioConfig: IoDeviceConfig
+  behaviorConfig?: BehaviorEntry[]
+  meshNameMap?: Record<string, string>
 }
 
 export interface AttachmentDescriptor {
@@ -68,9 +115,122 @@ export interface SmartComponentAsset {
     attachmentPoint: AttachmentDescriptor['attachmentPoint'] | null
     attachedAt: string
   }>
+  behaviors?: CrossComponentBehavior[]
   [key: string]: any
 }
 
+export declare function normalizeBehavior(behavior: CrossComponentBehavior): CrossComponentBehavior
+export declare function buildIntraBehavior(form: {
+  id?: string
+  inputAttachment: string
+  inputState: string
+  outputs: Array<{ attachment: string; state: string }>
+}): CrossComponentBehavior
+export declare function parseIntraBehavior(behavior: CrossComponentBehavior): {
+  id: string
+  inputAttachment: string
+  inputState: string
+  outputs: Array<{ attachment: string; state: string }>
+}
+export declare function buildCrossBehavior(form: {
+  id?: string
+  inputEndpoint: string
+  inputState: string
+  outputs: Array<{ endpoint: string; state: string }>
+}): CrossComponentBehavior
+export declare function parseCrossBehavior(behavior: CrossComponentBehavior): {
+  id: string
+  inputEndpoint: string
+  inputState: string
+  outputs: Array<{ endpoint: string; state: string }>
+}
+
+export declare function getScopedAttachmentKey(attachmentId: string, parentUuid?: string | null): string
+export declare function getIoBehaviorManager(sceneViewer: any): IoBehaviorManager | null
+export declare function resolveDataPoints(
+  parentUuid: string,
+  attachmentId: string,
+  userData: Record<string, any>,
+  ioBehaviorManager: IoBehaviorManager | null,
+  hitMesh?: any
+): IoDeviceState[]
+
+export declare function registerBehaviorsForComponent(
+  ioBehavMgr: IoBehaviorManager,
+  componentUuid: string,
+  componentData: SmartComponentAsset,
+  componentModel: any,
+  componentDictionary: Record<string, any>
+): void
+
+export declare function reloadBehaviorsForDeviceAsset(
+  ioBehavMgr: IoBehaviorManager,
+  deviceAssetId: string,
+  componentDictionary: Record<string, any>,
+  centralPlant: any
+): void
+
+export declare function scanSceneIoEndpoints(centralPlant: any): SceneIoEndpoint[]
+export declare function applyCrossComponentBehaviors(centralPlant: any, behaviors: CrossComponentBehavior[]): void
+export declare function loadCrossComponentBehaviors(centralPlant: any): CrossComponentBehavior[]
+export declare function refreshSceneIntraBehaviors(centralPlant: any, libraryId: string, behaviors: CrossComponentBehavior[]): void
+export declare function reregisterSceneBehaviors(centralPlant: any): void
+
+export declare function modelOffsetToWorldDelta(
+  modelRoot: any,
+  offset: { x?: number; y?: number; z?: number } | { clone(): any }
+): any
+export declare function applyModelRootTranslation(
+  mesh: any,
+  modelRoot: any,
+  origLocalPos: any,
+  modelOffset: { x?: number; y?: number; z?: number }
+): void
+export declare function applyModelRootTranslationFromWorldBase(
+  mesh: any,
+  modelRoot: any,
+  baseWorldPos: any,
+  modelOffset: { x?: number; y?: number; z?: number }
+): void
+
+export declare class IoBehaviorManager {
+  constructor(sceneViewer: any)
+  loadBehaviors(attachmentId: string, behaviorConfig: BehaviorEntry[] | { behaviors: BehaviorEntry[] }, deviceModelRoot: any, parentUuid: string): void
+  triggerState(attachmentId: string, dataPointId: string, value: any, parentUuid?: string | null): void
+  setCrossComponentBehaviors(behaviors: CrossComponentBehavior[]): void
+  registerComponentBehaviors(componentUuid: string, behaviors: CrossComponentBehavior[]): void
+  configure(stateAdapter: IoStateAdapter): void
+  getAnimationDataPoints(parentUuid: string, attachmentId: string, hitMesh?: any): IoDeviceState[]
+  getAnimatedMeshes(parentUuid: string, attachmentId: string): any[]
+  unloadForComponent(parentUuid: string): void
+  unloadForAttachment(parentUuid: string, attachmentId: string): void
+  resetForScene(): void
+  dispose(): void
+}
+
+export declare class ComponentTooltipManager {
+  constructor(sceneViewer: any)
+  configure(stateAdapter: IoStateAdapter): void
+  onSelectionChanged(object: any | null): void
+  update(): void
+  hide(): void
+  dispose(): void
+}
+
+export interface CentralPlantBehaviorApi {
+  configureStateAdapter(adapter: IoStateAdapter): void
+  setIoDeviceState(attachmentId: string, stateId: string, value: any, parentUuid?: string | null): void
+  mergeBehaviorConfigsIntoDictionary(configsByAssetId: Record<string, {
+    behaviorConfig?: BehaviorEntry[]
+    meshNameMap?: Record<string, string>
+    behaviors?: CrossComponentBehavior[]
+  }>): number
+  scanSceneIoEndpoints(): SceneIoEndpoint[]
+  setSceneBehaviors(behaviors: CrossComponentBehavior[]): void
+  getSceneBehaviors(): CrossComponentBehavior[]
+  reregisterSceneBehaviors(): void
+}
+
 export interface IoDeviceUsageEntry {
   componentId: string
   componentName: string
@@ -140,6 +300,31 @@ export declare class PathFlowManager {
 
 // ─── Re-exports ───────────────────────────────────────────────────────────────
 export { CentralPlant } from './core/centralPlant.js';
+export { IoBehaviorManager } from './managers/behaviors/IoBehaviorManager.js';
+export { ComponentTooltipManager } from './managers/scene/componentTooltipManager.js';
+export {
+  normalizeBehavior,
+  buildIntraBehavior,
+  parseIntraBehavior,
+  buildCrossBehavior,
+  parseCrossBehavior
+} from './utils/behaviorSchema.js';
+export {
+  registerBehaviorsForComponent,
+  reloadBehaviorsForDeviceAsset
+} from './utils/behaviorRegistration.js';
+export {
+  getScopedAttachmentKey,
+  getIoBehaviorManager,
+  resolveDataPoints
+} from './utils/behaviorDispatch.js';
+export {
+  scanSceneIoEndpoints,
+  applyCrossComponentBehaviors,
+  loadCrossComponentBehaviors,
+  refreshSceneIntraBehaviors,
+  reregisterSceneBehaviors
+} from './utils/behaviorSceneUtils.js';
 export { DebugLogger, logger, transformLogger, pathfinderLogger, modelLogger } from './core/debugLogger.js';
 export { generateUuidFromName, getHardcodedUuid, findObjectByHardcodedUuid } from './core/nameUtils.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2112-lab/central-plant",
-  "version": "0.3.38",
+  "version": "0.3.41",
   "description": "Utility modules for the Central Plant Application",
   "main": "dist/bundle/index.js",
   "module": "dist/esm/src/index.js",