@2112-lab/central-plant 0.3.57 → 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/controls/transformControlsManager.js

@@ -140,6 +140,12 @@ var TransformControlsManager = /*#__PURE__*/function () {
         // Update bounding box if the transformed object is in current selection
         if (_this.selectedObjects.includes(eventData.object)) {
           console.log('🔲 Updating bounding boxes for selected objects after transform');
+          // Reposition the transform gizmo (and its selection group) to follow the
+          // object's new position. Programmatic transforms (e.g. the Transform tab's
+          // Translate/Rotate buttons) move the object directly without touching the
+          // multi-selection group the gizmo is attached to, so without this the widget
+          // would stay at the pre-transform centroid.
+          _this.syncSelectionToObjects();
           _this.updateBoundingBox();
         }
       };
@@ -1246,6 +1252,59 @@ var TransformControlsManager = /*#__PURE__*/function () {
       console.log("\uD83D\uDCE6 Multi-selection group created at centroid:", centroid.toArray());
     }
 
+    /**
+     * Re-sync the multi-selection group (and the attached transform gizmo) to the
+     * current world positions of the selected objects, in place.
+     *
+     * Used after a *programmatic* transform (e.g. the Transform tab's Translate /
+     * Rotate buttons), which mutates the object directly and does not move the
+     * selection group the gizmo is attached to. Unlike a full updateMultiSelection()
+     * this keeps the same group instance so the gizmo doesn't detach/re-attach.
+     *
+     * It also refreshes the cached original transforms so a subsequent gizmo drag
+     * computes its delta from the object's new position rather than jumping.
+     */
+  }, {
+    key: "syncSelectionToObjects",
+    value: function syncSelectionToObjects() {
+      var _this$transformContro;
+      if (!this.multiSelectionGroup || this.selectedObjects.length === 0) {
+        return;
+      }
+
+      // Recompute the centroid from the objects' current world positions.
+      var centroid = new THREE.Vector3();
+      this.selectedObjects.forEach(function (obj) {
+        obj.updateMatrixWorld(true);
+        var worldPos = new THREE.Vector3();
+        obj.getWorldPosition(worldPos);
+        centroid.add(worldPos);
+      });
+      centroid.divideScalar(this.selectedObjects.length);
+
+      // Move the group (and thus the attached gizmo) to the new centroid. Reset any
+      // rotation so the gizmo matches the freshly-created-group convention.
+      this.multiSelectionGroup.position.copy(centroid);
+      this.multiSelectionGroup.rotation.set(0, 0, 0);
+      this.multiSelectionGroup.updateMatrixWorld(true);
+
+      // Refresh cached originals so applyRealtimeTransform's delta stays correct on
+      // the next drag (its "original centroid" is derived from these values).
+      this.selectedObjects.forEach(function (obj) {
+        obj.userData._multiSelectOriginalPosition = obj.position.clone();
+        obj.userData._multiSelectOriginalRotation = obj.rotation.clone();
+        obj.userData._multiSelectOriginalScale = obj.scale.clone();
+        var worldPos = new THREE.Vector3();
+        obj.getWorldPosition(worldPos);
+        obj.userData._multiSelectOriginalWorldPosition = worldPos;
+      });
+
+      // Keep the gizmo's world matrix in sync with the repositioned group.
+      if ((_this$transformContro = this.transformControls) !== null && _this$transformContro !== void 0 && _this$transformContro.object) {
+        this.transformControls.updateMatrixWorld(true);
+      }
+    }
+
     /**
      * Create a bounding box that encompasses all selected objects
      */
@@ -1525,10 +1584,10 @@ var TransformControlsManager = /*#__PURE__*/function () {
   }, {
     key: "toggleTransformMode",
     value: function toggleTransformMode() {
-      var _this$transformContro;
+      var _this$transformContro2;
       var newMode = this.currentMode === 'translate' ? 'rotate' : 'translate';
       this.setMode(newMode);
-      if ((_this$transformContro = this.transformControls) !== null && _this$transformContro !== void 0 && _this$transformContro.object) {
+      if ((_this$transformContro2 = this.transformControls) !== null && _this$transformContro2 !== void 0 && _this$transformContro2.object) {
         this.transformControls.updateMatrixWorld(true);
       }
     }

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);