@2112-lab/central-plant 0.2.8 → 0.2.12

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

@@ -410,7 +410,11 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "_executePathfinding",
     value: (function () {
       var _executePathfinding2 = _rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.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,
@@ -471,6 +475,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 ────────────────────────────────────────────
@@ -508,6 +521,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 pathfindingData.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 = _rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.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
      */
@@ -515,12 +645,32 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "initializePathfinder",
     value: (function () {
       var _initializePathfinder = _rollupPluginBabelHelpers.asyncToGenerator(/*#__PURE__*/_rollupPluginBabelHelpers.regenerator().m(function _callee2(data, crosscubeTextureSet) {
+        var _this6 = this;
         var pathfindingResult;
         return _rollupPluginBabelHelpers.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 && _rollupPluginBabelHelpers["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 = _rollupPluginBabelHelpers.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, {
@@ -529,6 +679,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;
@@ -653,6 +805,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/cjs/src/managers/scene/sceneOperationsManager.js

@@ -1771,7 +1771,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)');
       }
@@ -1802,7 +1802,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/esm/src/core/centralPlant.js

@@ -31,7 +31,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.2.8
+   * @version 0.2.12
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.

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

@@ -14,6 +14,7 @@ import { SceneInitializationManager } from '../managers/scene/sceneInitializatio
 import { EnvironmentManager } from '../managers/environment/environmentManager.js';
 import { KeyboardControlsManager } from '../managers/controls/keyboardControlsManager.js';
 import { PathfindingManager } from '../managers/pathfinding/pathfindingManager.js';
+import { PathFlowManager } from '../managers/pathfinding/PathFlowManager.js';
 import { BehaviorManager } from '../managers/behaviors/BehaviorManager.js';
 import { SceneOperationsManager } from '../managers/scene/sceneOperationsManager.js';
 import { AnimationManager } from '../managers/scene/animationManager.js';
@@ -140,6 +141,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);

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

@@ -64,10 +64,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 () {
@@ -87,16 +96,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({
@@ -173,6 +226,7 @@ var PathData = /*#__PURE__*/function () {
         segments: this.segments.map(function (seg) {
           return _objectSpread2({}, seg);
         }),
+        flowAttributes: _objectSpread2({}, this.flowAttributes),
         createdAt: this.createdAt
       };
     }
@@ -233,10 +287,11 @@ 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;
     }
   }]);
 }();
 
-export { PathData, createPathfindingRequest };
+export { FLOW_ATTRIBUTE_KEYS, PathData, createPathfindingRequest };

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

@@ -98,7 +98,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];

package/dist/esm/src/index.js

@@ -1,7 +1,7 @@
 export { default as CentralPlant } from './core/centralPlant.js';
 export { default as sceneViewer } from './core/sceneViewer.js';
 export { findObjectByHardcodedUuid, generateUniqueComponentId, generateUuidFromName, getHardcodedUuid } from './utils/nameUtils.js';
-export { PathData, createPathfindingRequest } from './core/pathfindingData.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';
 export { SceneInitializationManager } from './managers/scene/sceneInitializationManager.js';
 export { SceneOperationsManager } from './managers/scene/sceneOperationsManager.js';
@@ -13,6 +13,7 @@ export { BehaviorManager } from './managers/behaviors/BehaviorManager.js';
 export { ComponentManager } from './managers/components/componentManager.js';
 export { AnimationManager } from './managers/scene/animationManager.js';
 export { PathfindingManager } from './managers/pathfinding/pathfindingManager.js';
+export { PathFlowManager } from './managers/pathfinding/PathFlowManager.js';
 export { SnapshotManager } from './managers/pathfinding/SnapshotManager.js';
 export { ComponentDataManager } from './managers/components/componentDataManager.js';
 export { createTransformControls } from './managers/controls/transformControlsManager.js';

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

@@ -0,0 +1,261 @@
+import { inherits as _inherits, createClass as _createClass, toConsumableArray as _toConsumableArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+import { FLOW_ATTRIBUTE_KEYS } from '../../core/pathfindingData.js';
+
+// ── 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);
+
+export { PathFlowManager };