@2112-lab/central-plant 0.3.58 → 0.3.59

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

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
+var stateEngine = require('./stateEngine.js');
+var behaviorDispatch = require('../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 stateEngine.makeAddress(behaviorDispatch.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 = _rollupPluginBabelHelpers.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;
+}
+
+exports.applyDeclarationToExport = applyDeclarationToExport;
+exports.extractDeclaration = extractDeclaration;
+exports.ioAddress = ioAddress;
+exports.parseIoAddress = parseIoAddress;

package/dist/cjs/src/index.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var centralPlant = require('./core/centralPlant.js');
 var sceneViewer = require('./core/sceneViewer.js');
+var stateEngine = require('./core/stateEngine.js');
+var stateEngineScene = require('./core/stateEngineScene.js');
 var nameUtils = require('./utils/nameUtils.js');
 var pathfindingData = require('./core/pathfindingData.js');
 var objectTypes = require('./utils/objectTypes.js');
@@ -48,6 +50,14 @@ var rendering3D = require('./rendering/rendering3D.js');
 
 exports.CentralPlant = centralPlant["default"];
 exports.sceneViewer = sceneViewer["default"];
+exports.StateEngine = stateEngine.StateEngine;
+exports.makeAddress = stateEngine.makeAddress;
+exports.offValue = stateEngine.offValue;
+exports.valuesEqual = stateEngine.valuesEqual;
+exports.applyDeclarationToExport = stateEngineScene.applyDeclarationToExport;
+exports.extractDeclaration = stateEngineScene.extractDeclaration;
+exports.ioAddress = stateEngineScene.ioAddress;
+exports.parseIoAddress = stateEngineScene.parseIoAddress;
 exports.findObjectByHardcodedUuid = nameUtils.findObjectByHardcodedUuid;
 exports.generateUniqueComponentId = nameUtils.generateUniqueComponentId;
 exports.generateUuidFromName = nameUtils.generateUuidFromName;

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

@@ -14,6 +14,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].
@@ -51,22 +54,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
    */
   _rollupPluginBabelHelpers.inherits(PathFlowManager, _BaseDisposable);
   return _rollupPluginBabelHelpers.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);
@@ -172,6 +231,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
@@ -179,17 +245,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)
+      };
     }
 
     /**
@@ -221,6 +300,8 @@ var PathFlowManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "dispose",
     value: function dispose() {
       this._derivedStore.clear();
+      this._flowGatedOff.clear();
+      this._flowBaseColor.clear();
       this.sceneViewer = null;
       _rollupPluginBabelHelpers.superPropGet(PathFlowManager, "dispose", this, 3)([]);
     }

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

@@ -88,6 +88,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/cjs/src/managers/scene/componentTooltipManager.js

@@ -144,7 +144,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
@@ -159,6 +158,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 = behaviorDispatch.resolveDataPoints(parentUuid, attachmentId, ud, behaviorDispatch.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 = behaviorDispatch.getScopedAttachmentKey(attachmentId, parentUuid);