@2112-lab/central-plant 0.2.8 → 0.2.12

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

@@ -18,16 +18,58 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
       emissive: 0
     });
     _this.registerDisposable(_this._gatewayGeometry, _this._gatewayMaterial);
+
+    /**
+     * Map of pathId -> THREE.Material for per-path color control.
+     * pathId format: "${from}-->${to}"
+     * All segments within a path share the same material instance.
+     * @type {Map<string, THREE.Material>}
+     */
+    _this._pathMaterials = new Map();
     return _this;
   }
 
   /**
-   * Get path colors for visual distinction
-   * @param {number} index - Path index
-   * @returns {string} Hex color string
+   * Dispose all tracked per-path materials and clear the map.
+   * Called at the start of createPipePaths to clean up stale materials.
+   * @private
    */
   _inherits(PathRenderingManager, _BaseDisposable);
   return _createClass(PathRenderingManager, [{
+    key: "_clearPathMaterials",
+    value: function _clearPathMaterials() {
+      this._pathMaterials.forEach(function (mat) {
+        return mat.dispose();
+      });
+      this._pathMaterials.clear();
+    }
+
+    /**
+     * Update the color of all pipe segments belonging to a specific path.
+     * Operates on the shared per-path material — no scene traversal needed.
+     *
+     * @param {string} from - Source connector ID
+     * @param {string} to - Target connector ID
+     * @param {string|number} color - Any value accepted by THREE.Color.set()
+     */
+  }, {
+    key: "updatePathColor",
+    value: function updatePathColor(from, to, color) {
+      var pathId = "".concat(from, "-->").concat(to);
+      var mat = this._pathMaterials.get(pathId);
+      if (mat) {
+        mat.color.set(color);
+      } else {
+        console.warn("\u26A0\uFE0F PathRenderingManager.updatePathColor: no material found for path \"".concat(pathId, "\""));
+      }
+    }
+
+    /**
+     * Get path colors for visual distinction
+     * @param {number} index - Path index
+     * @returns {string} Hex color string
+     */
+  }, {
     key: "getPathColor",
     value: function getPathColor(index) {
       var colors = [
@@ -182,7 +224,11 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
       var globalSegmentIndex = maxExistingIndex + 1;
       console.log("\uD83D\uDD22 Starting segment index at ".concat(globalSegmentIndex, " (max existing: ").concat(maxExistingIndex, ")"));
       var pipeRadius = 0.1;
-      var pipeMaterial = this.createPipeMaterial(crosscubeTextureSet);
+      // Base material created once; per-path materials are cloned from it below.
+      var baseMaterial = this.createPipeMaterial(crosscubeTextureSet);
+
+      // Dispose previous path materials (they were attached to now-removed segments)
+      this._clearPathMaterials();
       paths.forEach(function (pathData, index) {
         if (pathData.path && pathData.path.length >= 2) {
           // Convert path points to Vector3 objects for consistent handling
@@ -199,6 +245,12 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             }
           });
 
+          // Create a per-path material clone so each path can have its color updated independently.
+          var pathId = "".concat(pathData.from, "-->").concat(pathData.to);
+          var perPathMaterial = baseMaterial.clone();
+          _this3._pathMaterials.set(pathId, perPathMaterial);
+          console.log("\uD83C\uDFA8 Created per-path material for \"".concat(pathId, "\""));
+
           // Check if endpoints are component connectors (from pathfinder result)
           var fromIsComponentConnector = pathData.fromObjectType === 'component-connector';
           var toIsComponentConnector = pathData.toObjectType === 'component-connector';
@@ -223,13 +275,13 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             var cylinderGeometry = new THREE.CylinderGeometry(pipeRadius, pipeRadius, length, 16, 1, false);
 
             // Determine material (debug red if rectified and in dev mode)
-            var materialToUse = pipeMaterial;
+            var materialToUse = perPathMaterial;
 
             // Check for dev mode (strict localhost only)
             var isDev = typeof window !== 'undefined' && (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1');
             if (isDev && pathData.rectifiedSegments && pathData.rectifiedSegments.includes(j)) {
-              // Create red debug material by cloning the pipe material to match the look
-              materialToUse = pipeMaterial.clone();
+              // Create red debug material by cloning the per-path material to match the look
+              materialToUse = perPathMaterial.clone();
               materialToUse.color.setHex(0xff0000);
               console.log("\uD83C\uDFA8 Coloring rectified segment ".concat(j, " red"));
             }
@@ -291,7 +343,7 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             sceneViewer.scene.add(cylinder);
 
             // Add smooth elbow joints only at actual direction changes (not at every point)
-            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, cylinder // Pass the segment so elbow can be added as a child
+            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, perPathMaterial, pathData, index, cylinder // Pass the segment so elbow can be added as a child
             );
           }
         }
@@ -396,6 +448,9 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
     value: function dispose() {
       console.log('🗑️ Disposing PathRenderingManager...');
 
+      // Dispose per-path materials
+      this._clearPathMaterials();
+
       // Call parent dispose to clean up registered resources (shared gateway geometry/material)
       _superPropGet(PathRenderingManager, "dispose", this, 3)([]);
 

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

@@ -1,4 +1,4 @@
-import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, objectSpread2 as _objectSpread2, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, slicedToArray as _slicedToArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, objectSpread2 as _objectSpread2, slicedToArray as _slicedToArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, typeof as _typeof } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { Pathfinder } from '@2112-lab/pathfinder';
 import { BaseDisposable } from '../../core/baseDisposable.js';
@@ -386,7 +386,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "_executePathfinding",
     value: (function () {
       var _executePathfinding2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(sceneData, connections) {
-        var _sceneDataCopy$childr, _sceneDataCopy$childr2, _pathfindingResult$pa, _pathfindingResult$pa2;
+        var _this4 = this,
+          _sceneDataCopy$childr,
+          _sceneDataCopy$childr2,
+          _pathfindingResult$pa,
+          _pathfindingResult$pa2;
         var options,
           _options$context,
           context,
@@ -447,6 +451,15 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
 
               // Create pipe paths with materials using the paths from pathfinder
               this.renderingManager.createPipePaths(pathfindingResult.paths, this.crosscubeTextureSet);
+
+              // ── Stage 3b: Ensure PathData entries exist for all rendered paths ──────
+              // This preserves any flowAttributes already set on existing entries.
+              if (pathfindingResult.paths) {
+                pathfindingResult.paths.forEach(function (path) {
+                  var pathId = "".concat(path.from, "-->").concat(path.to);
+                  _this4._getOrCreatePathData(pathId, path.from, path.to);
+                });
+              }
               timers.pathRendering = performance.now() - renderStart;
 
               // ── Performance Summary ────────────────────────────────────────────
@@ -484,6 +497,123 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
       return this.sceneDataManager.getSimplifiedSceneData();
     }
 
+    /**
+     * Return an existing PathData for pathId from the store, or create and register a new one.
+     * Preserves existing flowAttributes when the entry already exists.
+     *
+     * @param {string} pathId - Canonical path identifier "${from}-->${to}"
+     * @param {string} from - Source connector ID
+     * @param {string} to - Target connector ID
+     * @returns {PathData}
+     * @private
+     */
+  }, {
+    key: "_getOrCreatePathData",
+    value: function _getOrCreatePathData(pathId, from, to) {
+      if (!this.pathDataStore.has(pathId)) {
+        var pd = new PathData(pathId, from, to);
+        this.pathDataStore.set(pathId, pd);
+      }
+      return this.pathDataStore.get(pathId);
+    }
+
+    /**
+     * Propagate flowAttributes from the original connection list to any gateway-split
+     * rendered sub-paths in pathDataStore, then apply all flow visualizations.
+     * Called after every pathfinding execution (initial load and transform updates).
+     *
+     * @param {Array} connections - Original connections array (may include flowAttributes)
+     * @param {object} pathfindingResult - Result returned by _executePathfinding
+     * @private
+     */
+  }, {
+    key: "_propagateFlowAttributesAndApplyVisualizations",
+    value: function _propagateFlowAttributesAndApplyVisualizations(connections, pathfindingResult) {
+      var _this5 = this,
+        _this$sceneViewer;
+      if (!Array.isArray(connections) || !pathfindingResult) return;
+
+      // Pass 1: use the explicit gateway connection mappings to build a precise
+      //         original-pathId → Set<renderedPathId> map.
+      var originalToSubPaths = new Map();
+      if (pathfindingResult.gateways) {
+        pathfindingResult.gateways.forEach(function (gateway) {
+          var _ref = gateway.connections || {},
+            removed = _ref.removed,
+            added = _ref.added;
+          if (!(removed !== null && removed !== void 0 && removed.length) || !(added !== null && added !== void 0 && added.length)) return;
+          removed.forEach(function (removedConn) {
+            var origId = "".concat(removedConn.from, "-->").concat(removedConn.to);
+            if (!originalToSubPaths.has(origId)) originalToSubPaths.set(origId, new Set());
+            added.forEach(function (addedConn) {
+              originalToSubPaths.get(origId).add("".concat(addedConn.from, "-->").concat(addedConn.to));
+            });
+          });
+        });
+      }
+      connections.forEach(function (conn) {
+        if (!conn.flowAttributes) return;
+        var origId = "".concat(conn.from, "-->").concat(conn.to);
+        var subPathIds = new Set(originalToSubPaths.get(origId) || []);
+        subPathIds.add(origId);
+        subPathIds.forEach(function (subPathId) {
+          var pd = _this5.pathDataStore.get(subPathId);
+          if (pd && Object.keys(pd.flowAttributes).length === 0) {
+            Object.entries(conn.flowAttributes).forEach(function (_ref2) {
+              var _ref3 = _slicedToArray(_ref2, 2),
+                key = _ref3[0],
+                value = _ref3[1];
+              return pd.setFlowAttribute(key, value);
+            });
+          }
+        });
+      });
+
+      // Pass 2: endpoint fallback for Gateway→Gateway intermediate segments and
+      // for paths whose connections were restructured by manualizeSegment/manualizeGateway.
+      // After manualization, currentSceneData.connections no longer contains the original
+      // A→B entry with flowAttributes (it's been split into new sub-connections), so we
+      // seed the endpoint maps from both the connections array AND from existing pathDataStore
+      // entries that already carry flowAttributes — those persist across re-executions.
+      var fromEndpointAttrs = new Map();
+      var toEndpointAttrs = new Map();
+
+      // Seed from persisted pathDataStore entries first (covers post-manualization re-runs)
+      this.pathDataStore.forEach(function (pd, pathId) {
+        if (Object.keys(pd.flowAttributes).length === 0) return;
+        var sepIdx = pathId.indexOf('-->');
+        if (sepIdx === -1) return;
+        var from = pathId.slice(0, sepIdx);
+        var to = pathId.slice(sepIdx + 3);
+        if (!fromEndpointAttrs.has(from)) fromEndpointAttrs.set(from, pd.flowAttributes);
+        if (!toEndpointAttrs.has(to)) toEndpointAttrs.set(to, pd.flowAttributes);
+      });
+
+      // Also seed from connections array (covers initial load before pathDataStore has any attrs)
+      connections.forEach(function (conn) {
+        if (!conn.flowAttributes) return;
+        if (!fromEndpointAttrs.has(conn.from)) fromEndpointAttrs.set(conn.from, conn.flowAttributes);
+        if (!toEndpointAttrs.has(conn.to)) toEndpointAttrs.set(conn.to, conn.flowAttributes);
+      });
+      this.pathDataStore.forEach(function (pd, pathId) {
+        if (Object.keys(pd.flowAttributes).length > 0) return;
+        var sepIdx = pathId.indexOf('-->');
+        if (sepIdx === -1) return;
+        var from = pathId.slice(0, sepIdx);
+        var to = pathId.slice(sepIdx + 3);
+        var attrs = fromEndpointAttrs.get(from) || toEndpointAttrs.get(to);
+        if (attrs) Object.entries(attrs).forEach(function (_ref4) {
+          var _ref5 = _slicedToArray(_ref4, 2),
+            key = _ref5[0],
+            value = _ref5[1];
+          return pd.setFlowAttribute(key, value);
+        });
+      });
+
+      // Apply visualizations
+      (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.pathFlowManager) === null || _this$sceneViewer === void 0 || _this$sceneViewer.applyAllVisualizations();
+    }
+
     /**
      * Initialize pathfinder and create paths
      */
@@ -491,12 +621,32 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "initializePathfinder",
     value: (function () {
       var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(data, crosscubeTextureSet) {
+        var _this6 = this;
         var pathfindingResult;
         return _regenerator().w(function (_context2) {
           while (1) switch (_context2.n) {
             case 0:
               this.crosscubeTextureSet = crosscubeTextureSet;
 
+              // ── Pre-load declared flowAttributes from connections JSON ─────────────
+              // This must happen before pathfinding so that PathData entries carrying
+              // flowAttributes are available for visualization right after rendering.
+              if (Array.isArray(data.connections)) {
+                data.connections.forEach(function (conn) {
+                  if (conn.flowAttributes && _typeof(conn.flowAttributes) === 'object') {
+                    var pathId = "".concat(conn.from, "-->").concat(conn.to);
+                    var pd = _this6._getOrCreatePathData(pathId, conn.from, conn.to);
+                    Object.entries(conn.flowAttributes).forEach(function (_ref6) {
+                      var _ref7 = _slicedToArray(_ref6, 2),
+                        key = _ref7[0],
+                        value = _ref7[1];
+                      pd.setFlowAttribute(key, value);
+                    });
+                    console.log("\uD83C\uDF0A Loaded flowAttributes for path \"".concat(pathId, "\":"), conn.flowAttributes);
+                  }
+                });
+              }
+
               // Use shared pathfinding logic with gateway creation enabled
               _context2.n = 1;
               return this._executePathfinding(data.scene, data.connections, {
@@ -505,6 +655,8 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               });
             case 1:
               pathfindingResult = _context2.v;
+              this._propagateFlowAttributesAndApplyVisualizations(data.connections, pathfindingResult);
+
               // Update connections with rewired connections
               if (pathfindingResult.rewiredConnections) {
                 // data.connections = pathfindingResult.rewiredConnections;
@@ -629,6 +781,9 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               });
             case 2:
               result = _context3.v;
+              // Re-apply flow attribute colors (new materials are created on each execution)
+              this._propagateFlowAttributesAndApplyVisualizations(currentSceneData.connections, result);
+
               // Cache fingerprint + result for next comparison
               this._lastPathfindingFingerprint = fingerprint;
               this._lastPathfindingResult = result;

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

@@ -1747,7 +1747,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       if (typeof window !== 'undefined') {
         isDev = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1';
       }
-      if (isDev && segment.material) {
+      if (isDev && process.env.DISABLE_MANUALIZED_SEGMENT_COLORING !== 'true' && segment.material) {
         segment.material.color.setHex(0x0000ff); // Blue
         console.log('🎨 Set manual segment material color to blue (dev mode)');
       }
@@ -1778,7 +1778,7 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       console.log('🔌 Created connectors:', connectors);
 
       // In dev mode, enlarge connectors by 1.5x and turn them red
-      if (isDev) {
+      if (isDev && process.env.DISABLE_MANUALIZED_SEGMENT_COLORING !== 'true') {
         connectors.forEach(function (connector) {
           if (connector) {
             connector.scale.set(1.25, 1.25, 1.25);

package/dist/index.d.ts

@@ -82,6 +82,62 @@ export interface IAssetService {
   removeComponentAttachment(options: { componentUuid: string; attachmentId: string }): Promise<SmartComponentAsset>
 }
 
+// ─── Flow attribute types ─────────────────────────────────────────────────────
+
+/** The canonical set of flow-related attribute keys for a path. */
+export declare const FLOW_ATTRIBUTE_KEYS: ['flowDirection', 'flowSpeed', 'flowTemperature', 'flowMaterial']
+
+/** Union type of all valid flow attribute keys. */
+export type FlowAttributeKey = 'flowDirection' | 'flowSpeed' | 'flowTemperature' | 'flowMaterial'
+
+/** Resolved values for all four flow attributes on a path (null = unset). */
+export interface ResolvedFlowAttributes {
+  flowDirection: any | null
+  flowSpeed: any | null
+  flowTemperature: any | null
+  flowMaterial: any | null
+}
+
+/**
+ * Manages flow-related attributes (flowDirection, flowSpeed, flowTemperature,
+ * flowMaterial) for rendered paths at the central-plant level.
+ *
+ * Two layers:
+ *   - Declared  — persisted in PathData.flowAttributes, serialised with the scene
+ *   - Derived   — ephemeral runtime overrides (e.g. driven by I/O device state)
+ *
+ * Resolution: derived > declared > null
+ */
+export declare class PathFlowManager {
+  constructor(sceneViewer: object)
+
+  /** Set a declared (persistent) flow attribute on a path. */
+  setDeclared(pathId: string, key: FlowAttributeKey, value: any): void
+
+  /** Set a derived (runtime) flow attribute on a path. */
+  setDerived(pathId: string, key: FlowAttributeKey, value: any): void
+
+  /**
+   * Clear derived overrides for one path or all paths.
+   * @param pathId - Omit to reset all paths.
+   */
+  resetDerived(pathId?: string): void
+
+  /** Resolve the effective value of a single attribute (derived > declared > null). */
+  resolve(pathId: string, key: FlowAttributeKey): any | null
+
+  /** Resolve all four flow attributes for a path. */
+  resolveAll(pathId: string): ResolvedFlowAttributes
+
+  /** Apply temperature-based colour to the pipe material of a single path. */
+  applyVisualizationForPath(pathId: string): void
+
+  /** Apply temperature-based colour to every known path. */
+  applyAllVisualizations(): void
+
+  dispose(): void
+}
+
 // ─── Re-exports ───────────────────────────────────────────────────────────────
 export { CentralPlant } from './core/centralPlant.js';
 export { DebugLogger, logger, transformLogger, pathfinderLogger, modelLogger } from './core/debugLogger.js';

package/package.json

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