@2112-lab/central-plant 0.3.58 → 0.3.59

package/dist/esm/src/core/stateEngineScene.js

@@ -0,0 +1,90 @@
+import { slicedToArray as _slicedToArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { makeAddress } from './stateEngine.js';
+import { getScopedAttachmentKey } from '../utils/behaviorDispatch.js';
+
+/**
+ * Registry address for an I/O device data point.
+ * Shape: `${parentUuid}::${attachmentId}::${stateId}` (matches §17
+ * `pump-001::start-switch::mode`). The scoped key is `${parentUuid}::${attachmentId}`.
+ *
+ * @param {string} attachmentId
+ * @param {string} stateId
+ * @param {string} [parentUuid]
+ * @returns {string}
+ */
+function ioAddress(attachmentId, stateId, parentUuid) {
+  return makeAddress(getScopedAttachmentKey(attachmentId, parentUuid), stateId);
+}
+
+/**
+ * Parse an I/O device address back into its parts. Returns null for
+ * plant/group/object/pipe addresses (2-part) — I/O device data points are 3-part
+ * because a device always has a parent component (§8; free-floating I/O rejected).
+ *
+ * @param {string} address
+ * @returns {{ parentUuid: string, attachmentId: string, stateId: string, scopedKey: string } | null}
+ */
+function parseIoAddress(address) {
+  if (typeof address !== 'string') return null;
+  var parts = address.split('::');
+  if (parts.length !== 3) return null;
+  var _parts = _slicedToArray(parts, 3),
+    parentUuid = _parts[0],
+    attachmentId = _parts[1],
+    stateId = _parts[2];
+  return {
+    parentUuid: parentUuid,
+    attachmentId: attachmentId,
+    stateId: stateId,
+    scopedKey: "".concat(parentUuid, "::").concat(attachmentId)
+  };
+}
+
+/**
+ * Read a State Engine declaration out of scene data, tolerating legacy scenes.
+ * v3.0 scenes carry `plant` / `groups` / `chains` / `stateRegistry`; older v2.3
+ * scenes have none of these and load with safe defaults (plant power on, no
+ * groups, no chains) so nothing crashes on unknown/missing fields (§15).
+ *
+ * @param {object} [sceneData]
+ * @returns {{ plant: object, groups: object, chains: object[], stateRegistry: object }}
+ */
+function extractDeclaration() {
+  var sceneData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return {
+    plant: sceneData.plant || {
+      states: {
+        power: {
+          type: 'Boolean',
+          default: true,
+          gate: true
+        }
+      }
+    },
+    groups: sceneData.groups || {},
+    chains: Array.isArray(sceneData.chains) ? sceneData.chains : [],
+    stateRegistry: sceneData.stateRegistry || {}
+  };
+}
+
+/**
+ * Merge a State Engine's current declaration (plant / groups / chains /
+ * stateRegistry) into an export object, bumping it to version 3.0. Mutates and
+ * returns `exportData`.
+ *
+ * @param {object} exportData - the scene export object being assembled
+ * @param {{ toDeclaration: () => object }} engine
+ * @returns {object} exportData
+ */
+function applyDeclarationToExport(exportData, engine) {
+  if (!exportData || !engine || typeof engine.toDeclaration !== 'function') return exportData;
+  var declaration = engine.toDeclaration();
+  exportData.version = '3.0';
+  exportData.plant = declaration.plant;
+  exportData.groups = declaration.groups;
+  if (declaration.chains.length > 0) exportData.chains = declaration.chains;
+  exportData.stateRegistry = declaration.stateRegistry;
+  return exportData;
+}
+
+export { applyDeclarationToExport, extractDeclaration, ioAddress, parseIoAddress };

package/dist/esm/src/index.js

@@ -1,5 +1,7 @@
 export { default as CentralPlant } from './core/centralPlant.js';
 export { default as sceneViewer } from './core/sceneViewer.js';
+export { StateEngine, makeAddress, offValue, valuesEqual } from './core/stateEngine.js';
+export { applyDeclarationToExport, extractDeclaration, ioAddress, parseIoAddress } from './core/stateEngineScene.js';
 export { findObjectByHardcodedUuid, generateUniqueComponentId, generateUuidFromName, getHardcodedUuid } from './utils/nameUtils.js';
 export { FLOW_ATTRIBUTE_KEYS, PathData, createPathfindingRequest } from './core/pathfindingData.js';
 export { getObjectTypeName, getObjectsByType, isComponent, isComputed, isConnector, isDeclared, isExportable, isGateway, isSegment, markAsComputed, markAsDeclared, shouldRemoveOnRegeneration } from './utils/objectTypes.js';

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

@@ -10,6 +10,9 @@ var TEMP_MIN = 0;
 /** Maximum temperature in the colour ramp (maps to pure red). */
 var TEMP_MAX = 100;
 
+/** Colour a pipe is painted when its effective flow is gated off (§6.1). */
+var PIPE_OFF_GRAY = '#3a3a3a';
+
 /**
  * Convert a temperature value to a CSS hex colour string using a blue→red HSL
  * ramp.  Values are clamped to [TEMP_MIN, TEMP_MAX].
@@ -47,22 +50,78 @@ var PathFlowManager = /*#__PURE__*/function (_BaseDisposable) {
      * @type {Map<string, Record<string, any>>}
      */
     _this._derivedStore = new Map();
+
+    /**
+     * Paths whose effective flow is gated off (State Engine §6.1). While a path
+     * is in this set it is painted {@link PIPE_OFF_GRAY} and temperature updates
+     * are suppressed so they don't override the off-look.
+     * @type {Set<string>}
+     */
+    _this._flowGatedOff = new Set();
+
+    /**
+     * Baseline (on-state) colour snapshotted the moment a path is gated off, so
+     * it can be restored exactly when flow returns — including pipes with no
+     * declared flowTemperature, whose colour is the base pipe material.
+     * @type {Map<string, string>}
+     */
+    _this._flowBaseColor = new Map();
     return _this;
   }
 
-  // ── Public API — attribute write ──────────────────────────────────────────
+  // ── Flow gating (State Engine effective → 3D bridge, §6.1) ─────────────────
 
   /**
-   * Set a declared (persistent) flow attribute on a path.
-   * The value is stored in PathData and will be serialised with the scene.
-   * Triggers a visual update.
+   * Gate a path's flow visual on/off from the State Engine's effective `flow`.
+   * Off → paint the shared per-path material gray; on → restore the temperature
+   * colour. The off state is sticky (see {@link _flowGatedOff}).
    *
-   * @param {string} pathId - e.g. "PUMP-1-CONN-1-->CHILLER-1-CONN-2"
-   * @param {string} key    - One of FLOW_ATTRIBUTE_KEYS
-   * @param {any}    value
+   * @param {string} pathId  - `${from}-->${to}`
+   * @param {boolean} enabled - Effective flow
    */
   _inherits(PathFlowManager, _BaseDisposable);
   return _createClass(PathFlowManager, [{
+    key: "setFlowEnabled",
+    value: function setFlowEnabled(pathId, enabled) {
+      var split = this._splitPathId(pathId);
+      if (!split) return;
+      var renderingManager = this._getRenderingManager();
+      if (enabled) {
+        this._flowGatedOff.delete(pathId);
+        // Prefer a temperature-derived colour if one is declared; otherwise
+        // restore the baseline snapshotted when the pipe was gated off (this is
+        // what fixes plain, non-temperature pipes getting stuck gray).
+        var temp = this.resolve(pathId, 'flowTemperature');
+        if (temp !== null && temp !== undefined) {
+          this.applyVisualizationForPath(pathId);
+        } else if (this._flowBaseColor.has(pathId)) {
+          renderingManager === null || renderingManager === void 0 || renderingManager.updatePathColor(split.from, split.to, this._flowBaseColor.get(pathId));
+        }
+        this._flowBaseColor.delete(pathId);
+      } else {
+        // Snapshot the current (on-state) colour once, before overpainting gray.
+        if (!this._flowGatedOff.has(pathId) && renderingManager) {
+          var _renderingManager$get;
+          var base = (_renderingManager$get = renderingManager.getPathColorHex) === null || _renderingManager$get === void 0 ? void 0 : _renderingManager$get.call(renderingManager, pathId);
+          if (base) this._flowBaseColor.set(pathId, base);
+        }
+        this._flowGatedOff.add(pathId);
+        renderingManager === null || renderingManager === void 0 || renderingManager.updatePathColor(split.from, split.to, PIPE_OFF_GRAY);
+      }
+    }
+
+    // ── Public API — attribute write ──────────────────────────────────────────
+
+    /**
+     * Set a declared (persistent) flow attribute on a path.
+     * The value is stored in PathData and will be serialised with the scene.
+     * Triggers a visual update.
+     *
+     * @param {string} pathId - e.g. "PUMP-1-CONN-1-->CHILLER-1-CONN-2"
+     * @param {string} key    - One of FLOW_ATTRIBUTE_KEYS
+     * @param {any}    value
+     */
+  }, {
     key: "setDeclared",
     value: function setDeclared(pathId, key, value) {
       var pd = this._getPathData(pathId);
@@ -168,6 +227,13 @@ var PathFlowManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "applyVisualizationForPath",
     value: function applyVisualizationForPath(pathId) {
+      // Effective flow gated off (§6.1) — keep the off-look, ignore temperature.
+      if (this._flowGatedOff.has(pathId)) {
+        var _this$_getRenderingMa;
+        var _split = this._splitPathId(pathId);
+        if (_split) (_this$_getRenderingMa = this._getRenderingManager()) === null || _this$_getRenderingMa === void 0 || _this$_getRenderingMa.updatePathColor(_split.from, _split.to, PIPE_OFF_GRAY);
+        return;
+      }
       var temp = this.resolve(pathId, 'flowTemperature');
       if (temp === null || temp === undefined) {
         return; // No temperature declared — leave default pipe color
@@ -175,17 +241,30 @@ var PathFlowManager = /*#__PURE__*/function (_BaseDisposable) {
       var color = temperatureToColor(temp);
       var renderingManager = this._getRenderingManager();
       if (!renderingManager) return;
+      var split = this._splitPathId(pathId);
+      if (!split) return;
+      renderingManager.updatePathColor(split.from, split.to, color);
+      console.log("\uD83C\uDF21\uFE0F PathFlowManager: \"".concat(pathId, "\" \u2192 flowTemperature ").concat(temp, " \u2192 ").concat(color));
+    }
 
-      // pathId = "from-->to"; extract the two halves
+    /**
+     * Split a `${from}-->${to}` pathId into its two connector halves.
+     * @param {string} pathId
+     * @returns {{ from: string, to: string }|null} null if malformed
+     * @private
+     */
+  }, {
+    key: "_splitPathId",
+    value: function _splitPathId(pathId) {
       var sepIdx = pathId.indexOf('-->');
       if (sepIdx === -1) {
         console.warn("PathFlowManager: malformed pathId \"".concat(pathId, "\""));
-        return;
+        return null;
       }
-      var from = pathId.slice(0, sepIdx);
-      var to = pathId.slice(sepIdx + 3);
-      renderingManager.updatePathColor(from, to, color);
-      console.log("\uD83C\uDF21\uFE0F PathFlowManager: \"".concat(pathId, "\" \u2192 flowTemperature ").concat(temp, " \u2192 ").concat(color));
+      return {
+        from: pathId.slice(0, sepIdx),
+        to: pathId.slice(sepIdx + 3)
+      };
     }
 
     /**
@@ -217,6 +296,8 @@ var PathFlowManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "dispose",
     value: function dispose() {
       this._derivedStore.clear();
+      this._flowGatedOff.clear();
+      this._flowBaseColor.clear();
       this.sceneViewer = null;
       _superPropGet(PathFlowManager, "dispose", this, 3)([]);
     }

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

@@ -64,6 +64,21 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
       }
     }
 
+    /**
+     * Read the current color of a path's shared material as a `#rrggbb` string,
+     * or null if the path has no material. Used to snapshot a pipe's baseline
+     * colour before it is temporarily overpainted (e.g. flow gating).
+     *
+     * @param {string} pathId - "${from}-->${to}"
+     * @returns {string|null}
+     */
+  }, {
+    key: "getPathColorHex",
+    value: function getPathColorHex(pathId) {
+      var mat = this._pathMaterials.get(pathId);
+      return mat ? "#".concat(mat.color.getHexString()) : null;
+    }
+
     /**
      * Get path colors for visual distinction
      * @param {number} index - Path index

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

@@ -120,7 +120,6 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
       if (!ioDeviceObject || !this._stateAdapter) return;
       var ud = ioDeviceObject.userData;
       var attachmentId = ud === null || ud === void 0 ? void 0 : ud.attachmentId;
-      var dataPoints = (ud === null || ud === void 0 ? void 0 : ud.dataPoints) || [];
       if (!attachmentId) return;
 
       // Walk up to find parent component UUID for scoped state/behavior handling
@@ -135,6 +134,13 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
         obj = obj.parent;
       }
 
+      // Derive the device's data points from its behaviorConfig (same resolver the
+      // drag path uses). `userData.dataPoints` is not populated for attached
+      // devices, so reading it directly would find nothing — resolve instead, and
+      // keep the legacy field only as a fallback.
+      var resolved = resolveDataPoints(parentUuid, attachmentId, ud, getIoBehaviorManager(this.sceneViewer), null);
+      var dataPoints = resolved !== null && resolved !== void 0 && resolved.length ? resolved : (ud === null || ud === void 0 ? void 0 : ud.dataPoints) || [];
+
       // Create a scoped attachment key to prevent state sharing between instances
       // of the same smart component that share the same attachmentId
       var scopedAttachmentId = getScopedAttachmentKey(attachmentId, parentUuid);

package/dist/esm/src/managers/scene/controlPanelManager.js

@@ -0,0 +1,352 @@
+import { inherits as _inherits, createClass as _createClass, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+import modelPreloader from '../../rendering/modelPreloader.js';
+import { attachIODevicesToComponent } from '../../utils/ioDeviceUtils.js';
+import { registerBehaviorsForComponent } from '../../utils/behaviorRegistration.js';
+
+/**
+ * X offsets for `count` switches evenly spaced and centered on 0.
+ * @param {number} count
+ * @param {number} spacing
+ * @returns {number[]}
+ */
+function computeSwitchRowX(count, spacing) {
+  var start = -((count - 1) * spacing) / 2;
+  return Array.from({
+    length: count
+  }, function (_, i) {
+    return start + i * spacing;
+  });
+}
+var ControlPanelManager = /*#__PURE__*/function (_BaseDisposable) {
+  /**
+   * @param {Object} sceneViewer - The central sceneViewer hub
+   */
+  function ControlPanelManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, ControlPanelManager);
+    _this = _callSuper(this, ControlPanelManager);
+    _this.sceneViewer = sceneViewer;
+    _this._panel = null;
+    _this._labels = [];
+    _this._panelId = null;
+    _this._build = _this._build.bind(_this);
+    if (sceneViewer !== null && sceneViewer !== void 0 && sceneViewer.on) {
+      sceneViewer.on('scene-loaded', _this._build);
+    }
+    return _this;
+  }
+
+  /**
+   * Build (or rebuild) the panel from the current scene's `controlPanel` spec.
+   * @private
+   */
+  _inherits(ControlPanelManager, _BaseDisposable);
+  return _createClass(ControlPanelManager, [{
+    key: "_build",
+    value: (function () {
+      var _build2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _this$sceneViewer,
+          _centralPlant$importe,
+          _this$sceneViewer2,
+          _b$width,
+          _b$height,
+          _b$thickness,
+          _desk$tilt,
+          _desk$height,
+          _desk$legThickness,
+          _desk$legInset,
+          _spec$switchSpacing,
+          _this$sceneViewer3,
+          _spec$labelSize,
+          _this2 = this;
+        var centralPlant, spec, scene, panelId, panel, p, r, d2r, scale, b, width, depth, thickness, desk, tilt, deskHeight, legThickness, legInset, legColor, top, board, legMat, halfW, halfD, _i, _arr, ly, cornerZ, legH, yPos, _i2, _arr2, lx, leg, switches, spacing, xs, topZ, attachedDevices, componentData, switchScale, ioBehavMgr, engine, _iterator, _step, sw, current, lo, labelSize;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              this._teardown();
+              centralPlant = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.centralPlant;
+              spec = centralPlant === null || centralPlant === void 0 || (_centralPlant$importe = centralPlant.importedSceneData) === null || _centralPlant$importe === void 0 ? void 0 : _centralPlant$importe.controlPanel;
+              scene = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.scene;
+              if (!(!spec || !scene)) {
+                _context.n = 1;
+                break;
+              }
+              return _context.a(2);
+            case 1:
+              panelId = spec.id || 'CONTROL-PANEL-1';
+              this._panelId = panelId;
+              panel = new THREE.Group();
+              panel.name = 'Control Panel';
+              panel.uuid = panelId;
+              panel.userData = {
+                objectType: 'component',
+                isControlPanel: true
+              };
+              p = spec.position || {};
+              panel.position.set(p.x || 0, p.y || 0, p.z || 0);
+              r = spec.rotation || {};
+              d2r = Math.PI / 180;
+              panel.rotation.set((r.x || 0) * d2r, (r.y || 0) * d2r, (r.z || 0) * d2r, 'XYZ');
+              scale = Number.isFinite(spec.scale) && spec.scale > 0 ? spec.scale : 1;
+              panel.scale.setScalar(scale);
+
+              // ── Drawing-desk geometry (Z-up scene) ───────────────────────────────────
+              // A tilted top surface (the drafting board) raised on legs. Switches +
+              // labels live on the tilted `top` group so they sit on the angled surface.
+              b = spec.board || {};
+              width = (_b$width = b.width) !== null && _b$width !== void 0 ? _b$width : 7; // x-extent of the top
+              depth = (_b$height = b.height) !== null && _b$height !== void 0 ? _b$height : 2; // y-extent of the top (spec key kept as `height`)
+              thickness = (_b$thickness = b.thickness) !== null && _b$thickness !== void 0 ? _b$thickness : 0.15;
+              desk = spec.desk || {};
+              tilt = ((_desk$tilt = desk.tilt) !== null && _desk$tilt !== void 0 ? _desk$tilt : 30) * d2r; // surface tilt; +raises the back (+y) edge
+              deskHeight = (_desk$height = desk.height) !== null && _desk$height !== void 0 ? _desk$height : 1.3; // world height of the top's center
+              legThickness = (_desk$legThickness = desk.legThickness) !== null && _desk$legThickness !== void 0 ? _desk$legThickness : 0.18;
+              legInset = (_desk$legInset = desk.legInset) !== null && _desk$legInset !== void 0 ? _desk$legInset : 0.35;
+              legColor = desk.legColor || '#22303c'; // Tilted top group: raised to deskHeight, rotated about X.
+              top = new THREE.Group();
+              top.position.set(0, 0, deskHeight);
+              top.rotation.set(tilt, 0, 0, 'XYZ');
+              panel.add(top);
+              board = new THREE.Mesh(new THREE.BoxGeometry(width, depth, thickness), new THREE.MeshStandardMaterial({
+                color: b.color || '#2c3e50',
+                roughness: 0.6,
+                metalness: 0.2
+              }));
+              board.userData = {
+                objectType: 'control-panel-board'
+              };
+              top.add(board);
+
+              // Legs: one per corner, from the ground up to the tilted top's underside.
+              legMat = new THREE.MeshStandardMaterial({
+                color: legColor,
+                roughness: 0.7,
+                metalness: 0.1
+              });
+              halfW = Math.max(0.1, width / 2 - legInset);
+              halfD = Math.max(0.1, depth / 2 - legInset);
+              for (_i = 0, _arr = [halfD, -halfD]; _i < _arr.length; _i++) {
+                ly = _arr[_i];
+                // Underside height at this front/back row after the tilt.
+                cornerZ = deskHeight + ly * Math.sin(tilt) - thickness / 2 * Math.cos(tilt);
+                legH = Math.max(0.1, cornerZ);
+                yPos = ly * Math.cos(tilt); // corner's y in panel space after tilt
+                for (_i2 = 0, _arr2 = [halfW, -halfW]; _i2 < _arr2.length; _i2++) {
+                  lx = _arr2[_i2];
+                  leg = new THREE.Mesh(new THREE.BoxGeometry(legThickness, legThickness, legH), legMat);
+                  leg.position.set(lx, yPos, legH / 2);
+                  panel.add(leg);
+                }
+              }
+
+              // ── Switch layout: a row along X on the top face (+Z) of the board ───────
+              switches = Array.isArray(spec.switches) ? spec.switches : [];
+              spacing = (_spec$switchSpacing = spec.switchSpacing) !== null && _spec$switchSpacing !== void 0 ? _spec$switchSpacing : 1.3;
+              xs = computeSwitchRowX(switches.length, spacing);
+              topZ = thickness / 2;
+              attachedDevices = {};
+              switches.forEach(function (sw, i) {
+                attachedDevices[sw.attachmentId] = {
+                  deviceId: spec.deviceId,
+                  attachmentLabel: sw.label || sw.attachmentId,
+                  attachmentPoint: {
+                    position: {
+                      x: xs[i],
+                      y: 0,
+                      z: topZ
+                    },
+                    rotation: spec.switchRotation || {
+                      x: 0,
+                      y: 0,
+                      z: 0
+                    }
+                  }
+                };
+              });
+              componentData = {
+                isSmart: true,
+                attachedDevices: attachedDevices
+              }; // Clone + tag the switch devices onto the tilted top (reuses smart-component path).
+              _context.n = 2;
+              return attachIODevicesToComponent(top, componentData, modelPreloader, panelId);
+            case 2:
+              // Optional switch-only scale (attach path always leaves devices at 1:1).
+              switchScale = Number.isFinite(spec.switchScale) && spec.switchScale > 0 ? spec.switchScale : 1;
+              if (switchScale !== 1) {
+                top.traverse(function (obj) {
+                  var _obj$userData;
+                  if (((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'io-device') {
+                    obj.scale.setScalar(switchScale);
+                  }
+                });
+              }
+
+              // Panel must be in the scene before behaviors register (default-state seeding
+              // scans the live scene graph for io-devices).
+              scene.add(panel);
+              this._panel = panel;
+              ioBehavMgr = (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 || (_this$sceneViewer3 = _this$sceneViewer3.managers) === null || _this$sceneViewer3 === void 0 ? void 0 : _this$sceneViewer3.ioBehaviorManager;
+              if (ioBehavMgr) {
+                registerBehaviorsForComponent(ioBehavMgr, panelId, componentData, panel, modelPreloader.componentDictionary, centralPlant);
+
+                // Drive each switch's mesh to its current engine value so the initial
+                // pose/colour reflects the state. `registerBehaviorsForComponent`'s
+                // default-seeding writes through the engine, which no-ops when the value
+                // already matches the seeded `stateRegistry` — leaving the button at its
+                // neutral GLB rest pose. Trigger the animation directly to avoid that.
+                engine = centralPlant === null || centralPlant === void 0 ? void 0 : centralPlant.stateEngine;
+                _iterator = _createForOfIteratorHelper(switches);
+                try {
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    sw = _step.value;
+                    current = engine === null || engine === void 0 ? void 0 : engine.getDesired("".concat(panelId, "::").concat(sw.attachmentId, "::mode"));
+                    ioBehavMgr.triggerState(sw.attachmentId, 'mode', current !== null && current !== void 0 ? current : true, panelId);
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+              }
+
+              // ── Floating labels above each switch (on the tilted top) ────────────────
+              lo = spec.labelOffset || {
+                x: 0,
+                y: 0,
+                z: 0.7
+              };
+              labelSize = (_spec$labelSize = spec.labelSize) !== null && _spec$labelSize !== void 0 ? _spec$labelSize : 0.5;
+              switches.forEach(function (sw, i) {
+                var _lo$z;
+                var label = _this2._makeLabel(sw.label || sw.attachmentId, labelSize);
+                if (!label) return;
+                label.position.set(xs[i] + (lo.x || 0), lo.y || 0, topZ + ((_lo$z = lo.z) !== null && _lo$z !== void 0 ? _lo$z : 0.7));
+                top.add(label);
+                _this2._labels.push(label);
+              });
+            case 3:
+              return _context.a(2);
+          }
+        }, _callee, this);
+      }));
+      function _build() {
+        return _build2.apply(this, arguments);
+      }
+      return _build;
+    }()
+    /**
+     * Build one text label as a camera-facing `THREE.Sprite` (canvas texture),
+     * drawn by the main WebGL renderer alongside the scene — no dependency on the
+     * tooltip CSS2D renderer. Returns null when there is no DOM (headless tests).
+     * @param {string} text
+     * @param {number} worldHeight - label height in world units
+     * @returns {THREE.Sprite|null}
+     * @private
+     */
+    )
+  }, {
+    key: "_makeLabel",
+    value: function _makeLabel(text, worldHeight) {
+      if (typeof document === 'undefined') return null;
+      var dpr = 4; // supersample for crisp text
+      var fontPx = 40;
+      var padX = 14;
+      var padY = 8;
+      var font = "600 ".concat(fontPx, "px -apple-system, \"Segoe UI\", Roboto, sans-serif");
+      var canvas = document.createElement('canvas');
+      var ctx = canvas.getContext('2d');
+      ctx.font = font;
+      var textW = ctx.measureText(text).width;
+      canvas.width = Math.ceil((textW + padX * 2) * dpr);
+      canvas.height = Math.ceil((fontPx + padY * 2) * dpr);
+
+      // Re-apply after the resize (which clears the canvas), scaled by dpr.
+      ctx.scale(dpr, dpr);
+      ctx.font = font;
+      var wCss = canvas.width / dpr;
+      var hCss = canvas.height / dpr;
+      ctx.fillStyle = 'rgba(20,28,38,0.86)';
+      this._roundRect(ctx, 0, 0, wCss, hCss, 8);
+      ctx.fill();
+      ctx.fillStyle = '#eaf2f8';
+      ctx.textAlign = 'center';
+      ctx.textBaseline = 'middle';
+      ctx.fillText(text, wCss / 2, hCss / 2);
+      var texture = new THREE.CanvasTexture(canvas);
+      texture.minFilter = THREE.LinearFilter;
+      texture.anisotropy = 4;
+      var material = new THREE.SpriteMaterial({
+        map: texture,
+        transparent: true,
+        depthTest: false,
+        // always readable, never occluded by the board/switch
+        depthWrite: false
+      });
+      var sprite = new THREE.Sprite(material);
+      var aspect = canvas.width / canvas.height;
+      sprite.scale.set(worldHeight * aspect, worldHeight, 1);
+      sprite.renderOrder = 999;
+      return sprite;
+    }
+
+    /** Trace a rounded-rect path (fill applied by caller). @private */
+  }, {
+    key: "_roundRect",
+    value: function _roundRect(ctx, x, y, w, h, r) {
+      var rr = Math.min(r, w / 2, h / 2);
+      ctx.beginPath();
+      ctx.moveTo(x + rr, y);
+      ctx.arcTo(x + w, y, x + w, y + h, rr);
+      ctx.arcTo(x + w, y + h, x, y + h, rr);
+      ctx.arcTo(x, y + h, x, y, rr);
+      ctx.arcTo(x, y, x + w, y, rr);
+      ctx.closePath();
+    }
+
+    /**
+     * Remove the panel, its labels, and its registered behaviors (scene reload).
+     * @private
+     */
+  }, {
+    key: "_teardown",
+    value: function _teardown() {
+      this._labels = [];
+      if (this._panelId) {
+        var _this$sceneViewer4;
+        (_this$sceneViewer4 = this.sceneViewer) === null || _this$sceneViewer4 === void 0 || (_this$sceneViewer4 = _this$sceneViewer4.managers) === null || _this$sceneViewer4 === void 0 || (_this$sceneViewer4 = _this$sceneViewer4.ioBehaviorManager) === null || _this$sceneViewer4 === void 0 || _this$sceneViewer4.unloadForComponent(this._panelId);
+      }
+      if (this._panel) {
+        var _this$sceneViewer5;
+        (_this$sceneViewer5 = this.sceneViewer) === null || _this$sceneViewer5 === void 0 || (_this$sceneViewer5 = _this$sceneViewer5.scene) === null || _this$sceneViewer5 === void 0 || _this$sceneViewer5.remove(this._panel);
+        this._panel.traverse(function (obj) {
+          if (obj.isMesh || obj.isSprite) {
+            var _obj$geometry, _obj$geometry$dispose;
+            (_obj$geometry = obj.geometry) === null || _obj$geometry === void 0 || (_obj$geometry$dispose = _obj$geometry.dispose) === null || _obj$geometry$dispose === void 0 || _obj$geometry$dispose.call(_obj$geometry);
+            var mats = Array.isArray(obj.material) ? obj.material : [obj.material];
+            mats.forEach(function (m) {
+              var _m$map, _m$map$dispose, _m$dispose;
+              m === null || m === void 0 || (_m$map = m.map) === null || _m$map === void 0 || (_m$map$dispose = _m$map.dispose) === null || _m$map$dispose === void 0 || _m$map$dispose.call(_m$map); // sprite canvas texture
+              m === null || m === void 0 || (_m$dispose = m.dispose) === null || _m$dispose === void 0 || _m$dispose.call(m);
+            });
+          }
+        });
+        this._panel = null;
+      }
+      this._panelId = null;
+    }
+  }, {
+    key: "_doDispose",
+    value: function _doDispose() {
+      var _this$sceneViewer6;
+      if ((_this$sceneViewer6 = this.sceneViewer) !== null && _this$sceneViewer6 !== void 0 && _this$sceneViewer6.off) {
+        this.sceneViewer.off('scene-loaded', this._build);
+      }
+      this._teardown();
+      this.sceneViewer = null;
+    }
+  }]);
+}(BaseDisposable);
+
+export { ControlPanelManager, computeSwitchRowX };