@2112-lab/central-plant 0.2.5 → 0.2.10

package/dist/bundle/index.js

@@ -25783,10 +25783,19 @@ function createPathfindingRequest(startConnector, endConnector) {
   };
 }
 
+/**
+ * The official set of flow-related attribute keys that can be set on a path.
+ * These attributes belong to the full path and are inherited by all segments.
+ *
+ * @type {string[]}
+ */
+var FLOW_ATTRIBUTE_KEYS = ['flowDirection', 'flowSpeed', 'flowTemperature', 'flowMaterial'];
+
 /**
  * Data structure for storing path information with segments.
  * Tracks both computed and declared (manually edited) segments.
- * 
+ * Also stores path-level flow attributes shared by all segments.
+ *
  * Business logic layer - stores coordinate data without Three.js dependencies.
  */
 var PathData = /*#__PURE__*/function () {
@@ -25806,16 +25815,60 @@ var PathData = /*#__PURE__*/function () {
      * @type {Array<{start: {x, y, z}, end: {x, y, z}, isDeclared: boolean, modifiedAt: number|null}>}
      */
     this.segments = [];
+
+    /**
+     * Path-level flow attributes shared by all segments within this path.
+     * Keys must come from FLOW_ATTRIBUTE_KEYS. Values are application-defined.
+     * @type {Record<string, any>}
+     */
+    this.flowAttributes = {};
     this.createdAt = Date.now();
   }
 
   /**
-   * Add a computed segment (from pathfinding algorithm)
-   * 
-   * @param {{x: number, y: number, z: number}} start - Start coordinate
-   * @param {{x: number, y: number, z: number}} end - End coordinate
+   * Set a flow attribute on this path.
+   * All segments within this path inherit the value.
+   *
+   * @param {string} key - Attribute key (should be one of FLOW_ATTRIBUTE_KEYS)
+   * @param {any} value - Attribute value
    */
   return _createClass(PathData, [{
+    key: "setFlowAttribute",
+    value: function setFlowAttribute(key, value) {
+      this.flowAttributes[key] = value;
+    }
+
+    /**
+     * Get the declared value of a flow attribute.
+     * Returns null if the attribute has not been set.
+     *
+     * @param {string} key - Attribute key
+     * @returns {any|null}
+     */
+  }, {
+    key: "getFlowAttribute",
+    value: function getFlowAttribute(key) {
+      return Object.prototype.hasOwnProperty.call(this.flowAttributes, key) ? this.flowAttributes[key] : null;
+    }
+
+    /**
+     * Get a shallow copy of all declared flow attributes.
+     *
+     * @returns {Record<string, any>}
+     */
+  }, {
+    key: "getAllFlowAttributes",
+    value: function getAllFlowAttributes() {
+      return _objectSpread2({}, this.flowAttributes);
+    }
+
+    /**
+     * Add a computed segment (from pathfinding algorithm)
+     * 
+     * @param {{x: number, y: number, z: number}} start - Start coordinate
+     * @param {{x: number, y: number, z: number}} end - End coordinate
+     */
+  }, {
     key: "addSegment",
     value: function addSegment(start, end) {
       this.segments.push({
@@ -25892,6 +25945,7 @@ var PathData = /*#__PURE__*/function () {
         segments: this.segments.map(function (seg) {
           return _objectSpread2({}, seg);
         }),
+        flowAttributes: _objectSpread2({}, this.flowAttributes),
         createdAt: this.createdAt
       };
     }
@@ -25952,6 +26006,7 @@ var PathData = /*#__PURE__*/function () {
       pathData.segments = json.segments.map(function (seg) {
         return _objectSpread2({}, seg);
       });
+      pathData.flowAttributes = json.flowAttributes ? _objectSpread2({}, json.flowAttributes) : {};
       pathData.createdAt = json.createdAt || Date.now();
       return pathData;
     }
@@ -26109,16 +26164,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 = [
@@ -26273,7 +26370,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
@@ -26290,6 +26391,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';
@@ -26314,13 +26421,13 @@ var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
             var cylinderGeometry = new THREE__namespace.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"));
             }
@@ -26382,7 +26489,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
             );
           }
         }
@@ -26487,6 +26594,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)([]);
 
@@ -27923,7 +28033,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,
@@ -27984,6 +28098,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 ────────────────────────────────────────────
@@ -28021,6 +28144,26 @@ 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);
+    }
+
     /**
      * Initialize pathfinder and create paths
      */
@@ -28028,12 +28171,33 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "initializePathfinder",
     value: (function () {
       var _initializePathfinder = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(data, crosscubeTextureSet) {
-        var pathfindingResult;
+        var _this5 = this,
+          _this$sceneViewer;
+        var pathfindingResult, originalToSubPaths, fromEndpointAttrs, flowMgr;
         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 = _this5._getOrCreatePathData(pathId, conn.from, conn.to);
+                    Object.entries(conn.flowAttributes).forEach(function (_ref) {
+                      var _ref2 = _slicedToArray(_ref, 2),
+                        key = _ref2[0],
+                        value = _ref2[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, {
@@ -28042,6 +28206,83 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
               });
             case 1:
               pathfindingResult = _context2.v;
+              // ── Propagate flowAttributes to gateway-split rendered paths ──────────
+              // The pathfinder may split a connection A→B through gateway waypoints,
+              // producing sub-paths like A→G and G→B with different pathIds.
+              // We need to copy the original connection's flowAttributes onto every
+              // rendered sub-path entry in pathDataStore so the visualisation can
+              // find them by their rendered pathId.
+              if (Array.isArray(data.connections) && pathfindingResult) {
+                // Pass 1: use the explicit gateway connection mappings to get a precise
+                //         original→sub-path map.
+                originalToSubPaths = new Map(); // origPathId → Set<renderedPathId>
+                if (pathfindingResult.gateways) {
+                  pathfindingResult.gateways.forEach(function (gateway) {
+                    var _ref3 = gateway.connections || {},
+                      removed = _ref3.removed,
+                      added = _ref3.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));
+                      });
+                    });
+                  });
+                }
+                data.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); // include the direct path if it wasn't rewired
+
+                  subPathIds.forEach(function (subPathId) {
+                    var pd = _this5.pathDataStore.get(subPathId);
+                    if (pd && Object.keys(pd.flowAttributes).length === 0) {
+                      Object.entries(conn.flowAttributes).forEach(function (_ref4) {
+                        var _ref5 = _slicedToArray(_ref4, 2),
+                          key = _ref5[0],
+                          value = _ref5[1];
+                        pd.setFlowAttribute(key, value);
+                      });
+                      console.log("\uD83C\uDF0A Propagated flowAttributes to sub-path \"".concat(subPathId, "\" from \"").concat(origId, "\""));
+                    }
+                  });
+                });
+
+                // Pass 2: endpoint fallback for any rendered path still missing attributes
+                // (covers Gateway→Gateway intermediate segments not captured by gateway.connections.added)
+                fromEndpointAttrs = new Map(); // connectorId → flowAttributes
+                data.connections.forEach(function (conn) {
+                  if (conn.flowAttributes && !fromEndpointAttrs.has(conn.from)) {
+                    fromEndpointAttrs.set(conn.from, 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 attrs = fromEndpointAttrs.get(from);
+                  if (attrs) {
+                    Object.entries(attrs).forEach(function (_ref6) {
+                      var _ref7 = _slicedToArray(_ref6, 2),
+                        key = _ref7[0],
+                        value = _ref7[1];
+                      return pd.setFlowAttribute(key, value);
+                    });
+                    console.log("\uD83C\uDF0A Endpoint-matched flowAttributes for path \"".concat(pathId, "\""));
+                  }
+                });
+              }
+
+              // ── Apply flow visualizations now that paths are rendered ──────────────
+              flowMgr = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.pathFlowManager;
+              if (flowMgr) {
+                flowMgr.applyAllVisualizations();
+              }
+
               // Update connections with rewired connections
               if (pathfindingResult.rewiredConnections) {
                 // data.connections = pathfindingResult.rewiredConnections;
@@ -28221,6 +28462,262 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
   }]);
 }(BaseDisposable);
 
+// ── Temperature visualisation constants ────────────────────────────────────
+
+/** Minimum temperature in the colour ramp (maps to pure blue). */
+var TEMP_MIN = 0;
+
+/** Maximum temperature in the colour ramp (maps to pure red). */
+var TEMP_MAX = 100;
+
+/**
+ * Convert a temperature value to a CSS hex colour string using a blue→red HSL
+ * ramp.  Values are clamped to [TEMP_MIN, TEMP_MAX].
+ *
+ * • TEMP_MIN  →  hsl(240, 80%, 50%)  — blue
+ * • TEMP_MAX  →  hsl(0,   80%, 50%)  — red
+ *
+ * @param {number} temp
+ * @returns {string} CSS hex colour string e.g. '#2255cc'
+ */
+function temperatureToColor(temp) {
+  var clamped = Math.max(TEMP_MIN, Math.min(TEMP_MAX, temp));
+  var t = (clamped - TEMP_MIN) / (TEMP_MAX - TEMP_MIN); // 0 (cold) → 1 (hot)
+  // Map t=0 → hue 240 (blue), t=1 → hue 0 (red)
+  var hue = Math.round(240 - t * 240);
+  return "hsl(".concat(hue, ", 80%, 50%)");
+}
+
+// ── PathFlowManager ─────────────────────────────────────────────────────────
+
+var PathFlowManager = /*#__PURE__*/function (_BaseDisposable) {
+  /**
+   * @param {Object} sceneViewer - The central sceneViewer hub
+   */
+  function PathFlowManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, PathFlowManager);
+    _this = _callSuper(this, PathFlowManager);
+    _this.sceneViewer = sceneViewer;
+
+    /**
+     * Runtime-only attribute overrides.
+     * Map<pathId, Record<attributeKey, value>>
+     * Cleared when the session ends or resetDerived() is called.
+     * @type {Map<string, Record<string, any>>}
+     */
+    _this._derivedStore = new Map();
+    return _this;
+  }
+
+  // ── 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
+   */
+  _inherits(PathFlowManager, _BaseDisposable);
+  return _createClass(PathFlowManager, [{
+    key: "setDeclared",
+    value: function setDeclared(pathId, key, value) {
+      var pd = this._getPathData(pathId);
+      if (!pd) {
+        console.warn("PathFlowManager.setDeclared: no PathData found for \"".concat(pathId, "\""));
+        return;
+      }
+      pd.setFlowAttribute(key, value);
+      this.applyVisualizationForPath(pathId);
+    }
+
+    /**
+     * Set a derived (runtime) flow attribute on a path.
+     * Overrides the declared value during this session but is not persisted.
+     * Triggers a visual update.
+     *
+     * @param {string} pathId
+     * @param {string} key
+     * @param {any}    value
+     */
+  }, {
+    key: "setDerived",
+    value: function setDerived(pathId, key, value) {
+      if (!this._derivedStore.has(pathId)) {
+        this._derivedStore.set(pathId, {});
+      }
+      this._derivedStore.get(pathId)[key] = value;
+      this.applyVisualizationForPath(pathId);
+    }
+
+    /**
+     * Clear derived overrides for one path or all paths, then re-apply
+     * visualizations so that declared values take effect again.
+     *
+     * @param {string} [pathId] - Omit to reset all paths.
+     */
+  }, {
+    key: "resetDerived",
+    value: function resetDerived(pathId) {
+      var _this2 = this;
+      if (pathId !== undefined) {
+        this._derivedStore.delete(pathId);
+        this.applyVisualizationForPath(pathId);
+      } else {
+        var affected = _toConsumableArray(this._derivedStore.keys());
+        this._derivedStore.clear();
+        affected.forEach(function (id) {
+          return _this2.applyVisualizationForPath(id);
+        });
+      }
+    }
+
+    // ── Public API — attribute read ───────────────────────────────────────────
+
+    /**
+     * Resolve the effective value of a single attribute for a path.
+     * Resolution order: derived > declared > null.
+     *
+     * @param {string} pathId
+     * @param {string} key
+     * @returns {any|null}
+     */
+  }, {
+    key: "resolve",
+    value: function resolve(pathId, key) {
+      var derived = this._derivedStore.get(pathId);
+      if (derived && Object.prototype.hasOwnProperty.call(derived, key)) {
+        return derived[key];
+      }
+      var pd = this._getPathData(pathId);
+      if (pd) {
+        return pd.getFlowAttribute(key);
+      }
+      return null;
+    }
+
+    /**
+     * Resolve all four flow attributes for a path as a plain object.
+     * Each key is either the effective value or null if unset.
+     *
+     * @param {string} pathId
+     * @returns {{ flowDirection: any, flowSpeed: any, flowTemperature: any, flowMaterial: any }}
+     */
+  }, {
+    key: "resolveAll",
+    value: function resolveAll(pathId) {
+      var _this3 = this;
+      return Object.fromEntries(FLOW_ATTRIBUTE_KEYS.map(function (key) {
+        return [key, _this3.resolve(pathId, key)];
+      }));
+    }
+
+    // ── Visualization ─────────────────────────────────────────────────────────
+
+    /**
+     * Compute and apply the visual colour for a single path based on its resolved
+     * flow attributes.  Currently maps flowTemperature to a blue→red colour ramp.
+     * No-ops gracefully if the path has no renderable attributes or no pipe
+     * material exists yet.
+     *
+     * @param {string} pathId
+     */
+  }, {
+    key: "applyVisualizationForPath",
+    value: function applyVisualizationForPath(pathId) {
+      var temp = this.resolve(pathId, 'flowTemperature');
+      if (temp === null || temp === undefined) {
+        return; // No temperature declared — leave default pipe color
+      }
+      var color = temperatureToColor(temp);
+      var renderingManager = this._getRenderingManager();
+      if (!renderingManager) return;
+
+      // pathId = "from-->to"; extract the two halves
+      var sepIdx = pathId.indexOf('-->');
+      if (sepIdx === -1) {
+        console.warn("PathFlowManager: malformed pathId \"".concat(pathId, "\""));
+        return;
+      }
+      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));
+    }
+
+    /**
+     * Apply visualizations for every known path (union of pathDataStore and derived store).
+     * Call this after scene load or after bulk attribute changes.
+     */
+  }, {
+    key: "applyAllVisualizations",
+    value: function applyAllVisualizations() {
+      var _this4 = this;
+      var pathIds = new Set();
+      var pfMgr = this._getPathfindingManager();
+      if (pfMgr !== null && pfMgr !== void 0 && pfMgr.pathDataStore) {
+        pfMgr.pathDataStore.forEach(function (_, id) {
+          return pathIds.add(id);
+        });
+      }
+      this._derivedStore.forEach(function (_, id) {
+        return pathIds.add(id);
+      });
+      pathIds.forEach(function (id) {
+        return _this4.applyVisualizationForPath(id);
+      });
+      console.log("\uD83C\uDF0A PathFlowManager.applyAllVisualizations: processed ".concat(pathIds.size, " path(s)"));
+    }
+
+    // ── Lifecycle ─────────────────────────────────────────────────────────────
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._derivedStore.clear();
+      this.sceneViewer = null;
+      _superPropGet(PathFlowManager, "dispose", this, 3)([]);
+    }
+
+    // ── Private helpers ───────────────────────────────────────────────────────
+
+    /**
+     * @returns {import('../../core/pathfindingData.js').PathData|null}
+     * @private
+     */
+  }, {
+    key: "_getPathData",
+    value: function _getPathData(pathId) {
+      var _this$_getPathfinding, _this$_getPathfinding2;
+      return (_this$_getPathfinding = (_this$_getPathfinding2 = this._getPathfindingManager()) === null || _this$_getPathfinding2 === void 0 || (_this$_getPathfinding2 = _this$_getPathfinding2.pathDataStore) === null || _this$_getPathfinding2 === void 0 ? void 0 : _this$_getPathfinding2.get(pathId)) !== null && _this$_getPathfinding !== void 0 ? _this$_getPathfinding : null;
+    }
+
+    /**
+     * @returns {import('../pathfinding/pathfindingManager.js').PathfindingManager|null}
+     * @private
+     */
+  }, {
+    key: "_getPathfindingManager",
+    value: function _getPathfindingManager() {
+      var _this$sceneViewer$man, _this$sceneViewer;
+      return (_this$sceneViewer$man = (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 ? void 0 : _this$sceneViewer.pathfindingManager) !== null && _this$sceneViewer$man !== void 0 ? _this$sceneViewer$man : null;
+    }
+
+    /**
+     * @returns {import('../pathfinding/PathRenderingManager.js').PathRenderingManager|null}
+     * @private
+     */
+  }, {
+    key: "_getRenderingManager",
+    value: function _getRenderingManager() {
+      var _this$_getPathfinding3, _this$_getPathfinding4;
+      return (_this$_getPathfinding3 = (_this$_getPathfinding4 = this._getPathfindingManager()) === null || _this$_getPathfinding4 === void 0 ? void 0 : _this$_getPathfinding4.renderingManager) !== null && _this$_getPathfinding3 !== void 0 ? _this$_getPathfinding3 : null;
+    }
+  }]);
+}(BaseDisposable);
+
 var BehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   function BehaviorManager(sceneViewer) {
     var _this;
@@ -36042,6 +36539,59 @@ var Viewport2DManager = /*#__PURE__*/function (_BaseDisposable2) {
   }]);
 }(BaseDisposable);
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Flow-direction helpers (module-level)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Returns the flow direction of a connector from the current scene data.
+ * @param {Object} sceneData - currentSceneData object
+ * @param {string} connectorId
+ * @returns {'in'|'out'|'bi'} Defaults to 'bi' if not set.
+ */
+function _getConnectorFlow(sceneData, connectorId) {
+  var _sceneData$scene;
+  var children = (sceneData === null || sceneData === void 0 || (_sceneData$scene = sceneData.scene) === null || _sceneData$scene === void 0 ? void 0 : _sceneData$scene.children) || [];
+  var _iterator = _createForOfIteratorHelper(children),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var component = _step.value;
+      var _iterator2 = _createForOfIteratorHelper(component.children || []),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _child$userData;
+          var child = _step2.value;
+          if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) === 'connector' && child.uuid === connectorId) {
+            return child.userData.flow || 'bi';
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return 'bi';
+}
+
+/**
+ * Returns true if fromFlow → toFlow is a valid connection.
+ * @param {'in'|'out'|'bi'} fromFlow
+ * @param {'in'|'out'|'bi'} toFlow
+ * @returns {boolean}
+ */
+function _areFlowsCompatible$1(fromFlow, toFlow) {
+  if (fromFlow === 'bi' || toFlow === 'bi') return true;
+  return fromFlow !== toFlow;
+}
+
 /**
  * CentralPlantInternals class containing internal methods and functionality
  */
@@ -36103,6 +36653,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       this.centralPlant.managers.environmentManager = new EnvironmentManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.keyboardControlsManager = new KeyboardControlsManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.pathfindingManager = new PathfindingManager(this.centralPlant.sceneViewer);
+      this.centralPlant.managers.pathFlowManager = new PathFlowManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.behaviorManager = new BehaviorManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.sceneOperationsManager = new SceneOperationsManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.animationManager = new AnimationManager(this.centralPlant.sceneViewer);
@@ -36493,12 +37044,12 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       console.log("\uD83D\uDD27 Translating ".concat(selectedObjects.length, " selected object(s) on ").concat(axis, " axis by ").concat(value));
 
       // Translate each selected object using the appropriate method
-      var _iterator = _createForOfIteratorHelper(selectedObjects),
-        _step;
+      var _iterator3 = _createForOfIteratorHelper(selectedObjects),
+        _step3;
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
           var _obj$userData;
-          var obj = _step.value;
+          var obj = _step3.value;
           var objectType = (_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType;
           var objectId = obj.uuid;
           var success = false;
@@ -36525,9 +37076,9 @@ var CentralPlantInternals = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator.f();
+        _iterator3.f();
       }
       result.success = result.translatedCount === result.totalCount;
       if (result.success) {
@@ -36711,7 +37262,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "addConnection",
     value: function addConnection(fromConnectorId, toConnectorId) {
-      var _this$centralPlant$sc4;
+      var _this$centralPlant$sc4, _this$centralPlant$sc5;
       // Use centralized validation for connection parameters
       var existingConnections = ((_this$centralPlant$sc4 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc4 === void 0 || (_this$centralPlant$sc4 = _this$centralPlant$sc4.currentSceneData) === null || _this$centralPlant$sc4 === void 0 ? void 0 : _this$centralPlant$sc4.connections) || [];
       var validation = this.validator.validateConnectionParams(fromConnectorId, toConnectorId, existingConnections);
@@ -36719,6 +37270,17 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         return false; // Validator already logged the error
       }
 
+      // Validate flow direction compatibility
+      var sceneData = (_this$centralPlant$sc5 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc5 === void 0 ? void 0 : _this$centralPlant$sc5.currentSceneData;
+      if (sceneData) {
+        var fromFlow = _getConnectorFlow(sceneData, fromConnectorId);
+        var toFlow = _getConnectorFlow(sceneData, toConnectorId);
+        if (!_areFlowsCompatible$1(fromFlow, toFlow)) {
+          console.error("\u274C addConnection(): Incompatible flow directions \u2014 '".concat(fromConnectorId, "' is '").concat(fromFlow, "' and '").concat(toConnectorId, "' is '").concat(toFlow, "'. ") + "'".concat(fromFlow, "' \u2192 '").concat(toFlow, "' connections are not allowed."));
+          return false;
+        }
+      }
+
       // Validate scene availability
       var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer);
       if (!sceneValidation.isValid) {
@@ -36839,7 +37401,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "addComponent",
     value: function addComponent(libraryId) {
-      var _this$centralPlant$sc5;
+      var _this$centralPlant$sc6;
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       // Use centralized validation for component addition parameters
       var existingIds = this.getComponentIds();
@@ -36849,7 +37411,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       }
 
       // Validate scene availability
-      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc5 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc5 === void 0 ? void 0 : _this$centralPlant$sc5.scene);
+      var sceneValidation = this.validator.validateSceneViewer(this.centralPlant.sceneViewer, (_this$centralPlant$sc6 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc6 === void 0 ? void 0 : _this$centralPlant$sc6.scene);
       if (!sceneValidation.isValid) {
         return false;
       }
@@ -36868,7 +37430,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         return false;
       }
       try {
-        var _componentData$childr, _componentData$childr2, _this$centralPlant$sc6, _componentData$childr3, _componentData$defaul;
+        var _componentData$childr, _componentData$childr2, _this$centralPlant$sc7, _componentData$childr3, _componentData$defaul;
         // Generate a unique component ID if not provided
         var componentId = options.customId || this.generateUniqueComponentId(libraryId);
 
@@ -36980,7 +37542,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         componentModel.updateMatrixWorld(true);
 
         // Check if component is underground and fix if needed (based on settings)
-        var checkUnderground = (_this$centralPlant$sc6 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc6 === void 0 || (_this$centralPlant$sc6 = _this$centralPlant$sc6.managers) === null || _this$centralPlant$sc6 === void 0 || (_this$centralPlant$sc6 = _this$centralPlant$sc6.settingsManager) === null || _this$centralPlant$sc6 === void 0 ? void 0 : _this$centralPlant$sc6.getSetting('scene', 'checkUnderground');
+        var checkUnderground = (_this$centralPlant$sc7 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc7 === void 0 || (_this$centralPlant$sc7 = _this$centralPlant$sc7.managers) === null || _this$centralPlant$sc7 === void 0 || (_this$centralPlant$sc7 = _this$centralPlant$sc7.settingsManager) === null || _this$centralPlant$sc7 === void 0 ? void 0 : _this$centralPlant$sc7.getSetting('scene', 'checkUnderground');
         if (checkUnderground) {
           var wasFixed = this.fixUndergroundComponent(componentModel);
           if (wasFixed) {
@@ -37078,8 +37640,8 @@ var CentralPlantInternals = /*#__PURE__*/function () {
         // responds to tooltip-driven state changes immediately after drop.
         // (The scene-load path uses _processBehaviors instead, which runs on loadSceneData.)
         if ((_componentData$defaul = componentData.defaultBehaviors) !== null && _componentData$defaul !== void 0 && _componentData$defaul.length) {
-          var _this$centralPlant$sc7, _som$registerBehavior;
-          var som = (_this$centralPlant$sc7 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc7 === void 0 ? void 0 : _this$centralPlant$sc7.sceneOperationsManager;
+          var _this$centralPlant$sc8, _som$registerBehavior;
+          var som = (_this$centralPlant$sc8 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc8 === void 0 ? void 0 : _this$centralPlant$sc8.sceneOperationsManager;
           som === null || som === void 0 || (_som$registerBehavior = som.registerBehaviorsForComponentInstance) === null || _som$registerBehavior === void 0 || _som$registerBehavior.call(som, componentData, componentId);
         }
 
@@ -37141,9 +37703,9 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }, {
     key: "deleteComponent",
     value: function deleteComponent(componentId) {
-      var _this$centralPlant$sc8;
+      var _this$centralPlant$sc9;
       // Check if component manager is available
-      var componentManager = (_this$centralPlant$sc8 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc8 === void 0 ? void 0 : _this$centralPlant$sc8.componentManager;
+      var componentManager = (_this$centralPlant$sc9 = this.centralPlant.sceneViewer) === null || _this$centralPlant$sc9 === void 0 ? void 0 : _this$centralPlant$sc9.componentManager;
       if (!componentManager) {
         console.error('❌ deleteComponent(): Component manager not available');
         return false;
@@ -37218,8 +37780,8 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       }
       var componentIds = [];
       this.centralPlant.sceneViewer.scene.traverse(function (child) {
-        var _child$userData;
-        if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) === 'component') {
+        var _child$userData2;
+        if (((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.objectType) === 'component') {
           componentIds.push(child.uuid || child.userData.originalUuid);
         }
       });
@@ -37228,6 +37790,22 @@ var CentralPlantInternals = /*#__PURE__*/function () {
   }]);
 }();
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Flow-direction compatibility helper (module-level, no class dependency)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Returns true if the two flow directions are compatible for a connection.
+ * @param {string} fromFlow - 'in' | 'out' | 'bi'
+ * @param {string} toFlow   - 'in' | 'out' | 'bi'
+ * @returns {boolean}
+ */
+function _areFlowsCompatible(fromFlow, toFlow) {
+  if (fromFlow === 'bi' || toFlow === 'bi') return true;
+  // in ↔ out are compatible; in → in and out → out are not
+  return fromFlow !== toFlow;
+}
+
 /**
  * CentralPlant class that manages all scene utility instances and provides public API
  * 
@@ -37238,7 +37816,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.2.5
+   * @version 0.2.10
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -38171,6 +38749,107 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       return availableConnectorIds;
     }
 
+    /**
+     * Get available connectors with their flow direction metadata.
+     * Same filtering logic as getAvailableConnections() but returns objects instead of strings.
+     * @returns {Array<{id: string, flow: string}>} Array of connector info objects.
+     *   flow is one of 'in', 'out', 'bi'. Defaults to 'bi' if not set in userData.
+     * @example
+     * const infos = centralPlant.getAvailableConnectionsInfo()
+     * // [{ id: 'PUMP-1-CONNECTOR-1', flow: 'out' }, ...]
+     */
+  }, {
+    key: "getAvailableConnectionsInfo",
+    value: function getAvailableConnectionsInfo() {
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ getAvailableConnectionsInfo(): Scene viewer or current scene data not available');
+        return [];
+      }
+      var sceneData = this.sceneViewer.currentSceneData;
+      if (!sceneData.scene || !sceneData.scene.children) {
+        console.warn('⚠️ getAvailableConnectionsInfo(): Invalid scene data structure');
+        return [];
+      }
+      var allConnectorInfos = [];
+      sceneData.scene.children.forEach(function (component) {
+        if (component.children && Array.isArray(component.children)) {
+          component.children.forEach(function (child) {
+            if (child.userData && child.userData.objectType === 'connector' && child.uuid) {
+              allConnectorInfos.push({
+                id: child.uuid,
+                flow: child.userData.flow || 'bi'
+              });
+            }
+          });
+        }
+      });
+      var existingConnections = this.getConnections();
+      var usedConnectorIds = new Set();
+      existingConnections.forEach(function (connection) {
+        if (connection.from) usedConnectorIds.add(connection.from);
+        if (connection.to) usedConnectorIds.add(connection.to);
+      });
+      return allConnectorInfos.filter(function (info) {
+        return !usedConnectorIds.has(info.id);
+      });
+    }
+
+    /**
+     * Validate all connections in the current scene for flow direction compatibility.
+     * @returns {{ valid: Array<Object>, invalid: Array<{connection: Object, reason: string}> }}
+     * @example
+     * const result = centralPlant.validateConnections()
+     * result.invalid.forEach(({ connection, reason }) => console.warn(reason, connection))
+     */
+  }, {
+    key: "validateConnections",
+    value: function validateConnections() {
+      if (!this.sceneViewer || !this.sceneViewer.currentSceneData) {
+        console.warn('⚠️ validateConnections(): Scene viewer or current scene data not available');
+        return {
+          valid: [],
+          invalid: []
+        };
+      }
+      var connections = this.getConnections();
+      var sceneData = this.sceneViewer.currentSceneData;
+
+      // Build lookup map: connectorId → flow
+      var flowMap = {};
+      var scene = sceneData.scene || {};
+      var children = scene.children || [];
+      children.forEach(function (component) {
+        if (component.children && Array.isArray(component.children)) {
+          component.children.forEach(function (child) {
+            if (child.userData && child.userData.objectType === 'connector' && child.uuid) {
+              flowMap[child.uuid] = child.userData.flow || 'bi';
+            }
+          });
+        }
+      });
+      var valid = [];
+      var invalid = [];
+      connections.forEach(function (connection) {
+        var fromFlow = flowMap[connection.from] || 'bi';
+        var toFlow = flowMap[connection.to] || 'bi';
+        if (_areFlowsCompatible(fromFlow, toFlow)) {
+          valid.push(connection);
+        } else {
+          var reason = "Incompatible flow directions: connector '".concat(connection.from, "' is '").concat(fromFlow, "' and connector '").concat(connection.to, "' is '").concat(toFlow, "' \u2014 ").concat(fromFlow, " \u2192 ").concat(toFlow, " is not allowed");
+          console.warn("\u26A0\uFE0F validateConnections(): ".concat(reason));
+          invalid.push({
+            connection: connection,
+            reason: reason
+          });
+        }
+      });
+      console.log("\u2705 validateConnections(): ".concat(valid.length, " valid, ").concat(invalid.length, " invalid connections"));
+      return {
+        valid: valid,
+        invalid: invalid
+      };
+    }
+
     // ─────────────────────────────────────────────────────────────────────────
     // BEHAVIORS API
     // ─────────────────────────────────────────────────────────────────────────
@@ -40154,7 +40833,7 @@ var sceneViewer = /*#__PURE__*/function (_BaseDisposable) {
               this.centralPlant.attachToComponent();
 
               // Sync our managers tracking object after attachment
-              managerKeys = ['threeJSResourceManager', 'performanceMonitorManager', 'settingsManager', 'sceneExportManager', 'componentManager', 'sceneInitializationManager', 'environmentManager', 'keyboardControlsManager', 'pathfindingManager', 'behaviorManager', 'sceneOperationsManager', 'animationManager', 'cameraControlsManager', 'componentDragManager', 'tooltipsManager', 'componentTooltipManager']; // Populate our managers tracking object
+              managerKeys = ['threeJSResourceManager', 'performanceMonitorManager', 'settingsManager', 'sceneExportManager', 'componentManager', 'sceneInitializationManager', 'environmentManager', 'keyboardControlsManager', 'pathfindingManager', 'pathFlowManager', 'behaviorManager', 'sceneOperationsManager', 'animationManager', 'cameraControlsManager', 'componentDragManager', 'tooltipsManager', 'componentTooltipManager']; // Populate our managers tracking object
               managerKeys.forEach(function (key) {
                 if (_this2[key]) {
                   _this2.managers[key] = _this2[key];
@@ -43770,10 +44449,12 @@ exports.ComponentDragManager = ComponentDragManager;
 exports.ComponentManager = ComponentManager;
 exports.ComponentTooltipManager = ComponentTooltipManager;
 exports.EnvironmentManager = EnvironmentManager;
+exports.FLOW_ATTRIBUTE_KEYS = FLOW_ATTRIBUTE_KEYS;
 exports.KeyboardControlsManager = KeyboardControlsManager;
 exports.ModelManager = ModelManager;
 exports.OperationHistoryManager = OperationHistoryManager;
 exports.PathData = PathData;
+exports.PathFlowManager = PathFlowManager;
 exports.PathfindingManager = PathfindingManager;
 exports.PerformanceMonitorManager = PerformanceMonitorManager;
 exports.Rendering2D = rendering2D;