updates

additional_nodes/recirculation-pump.js

@@ -3,12 +3,13 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         var node = this;
 
+        let name = config.name;
         let F2 = parseFloat(config.F2);
         const inlet_F2 = parseInt(config.inlet);
 
         node.on('input', function(msg, send, done) {
             switch (msg.topic) {
-                case "Fluent": {
+                case "Fluent":
                     // conserve volume flow debit
                     let F_in = msg.payload.F;
                     let F1 = Math.max(F_in - F2, 0);
@@ -23,7 +24,6 @@ module.exports = function(RED) {
 
                     send([msg_F1, msg_F2]);
                     break;
-                }
                 case "clock":
                     break;
                 default:

additional_nodes/settling-basin.js

@@ -3,12 +3,13 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         var node = this;
 
+        let name = config.name;
         let TS_set = parseFloat(config.TS_set);
         const inlet_sludge = parseInt(config.inlet);
 
         node.on('input', function(msg, send, done) {
             switch (msg.topic) {
-                case "Fluent": {
+                case "Fluent":
                     // conserve volume flow debit
                     let F_in = msg.payload.F;
                     let C_in = msg.payload.C;
@@ -40,7 +41,6 @@ module.exports = function(RED) {
 
                     send([msg_F1, msg_F2]);
                     break;
-                }
                 case "clock":
                     break;
                 default:

examples/README.md

@@ -0,0 +1,8 @@
+# reactor Example Flows
+
+Import-ready Node-RED examples for reactor.
+
+## Files
+- basic.flow.json
+- integration.flow.json
+- edge.flow.json

examples/basic.flow.json

@@ -0,0 +1,6 @@
+[
+  {"id":"reactor_basic_tab","type":"tab","label":"reactor basic","disabled":false,"info":"reactor basic example"},
+  {"id":"reactor_basic_node","type":"reactor","z":"reactor_basic_tab","name":"reactor basic","x":420,"y":180,"wires":[["reactor_basic_dbg"]]},
+  {"id":"reactor_basic_inj","type":"inject","z":"reactor_basic_tab","name":"basic trigger","props":[{"p":"topic","vt":"str"},{"p":"payload","vt":"str"}],"topic":"ping","payload":"1","payloadType":"str","x":160,"y":180,"wires":[["reactor_basic_node"]]},
+  {"id":"reactor_basic_dbg","type":"debug","z":"reactor_basic_tab","name":"reactor basic debug","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","x":660,"y":180,"wires":[]}
+]

examples/edge.flow.json

@@ -0,0 +1,6 @@
+[
+  {"id":"reactor_edge_tab","type":"tab","label":"reactor edge","disabled":false,"info":"reactor edge example"},
+  {"id":"reactor_edge_node","type":"reactor","z":"reactor_edge_tab","name":"reactor edge","x":420,"y":180,"wires":[["reactor_edge_dbg"]]},
+  {"id":"reactor_edge_inj","type":"inject","z":"reactor_edge_tab","name":"unknown topic","props":[{"p":"topic","vt":"str"},{"p":"payload","vt":"str"}],"topic":"doesNotExist","payload":"x","payloadType":"str","x":170,"y":180,"wires":[["reactor_edge_node"]]},
+  {"id":"reactor_edge_dbg","type":"debug","z":"reactor_edge_tab","name":"reactor edge debug","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","x":660,"y":180,"wires":[]}
+]

examples/integration.flow.json

@@ -0,0 +1,6 @@
+[
+  {"id":"reactor_int_tab","type":"tab","label":"reactor integration","disabled":false,"info":"reactor integration example"},
+  {"id":"reactor_int_node","type":"reactor","z":"reactor_int_tab","name":"reactor integration","x":420,"y":180,"wires":[["reactor_int_dbg"]]},
+  {"id":"reactor_int_inj","type":"inject","z":"reactor_int_tab","name":"registerChild","props":[{"p":"topic","vt":"str"},{"p":"payload","vt":"str"}],"topic":"registerChild","payload":"example-child-id","payloadType":"str","x":170,"y":180,"wires":[["reactor_int_node"]]},
+  {"id":"reactor_int_dbg","type":"debug","z":"reactor_int_tab","name":"reactor integration debug","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","x":680,"y":180,"wires":[]}
+]

package.json

@@ -17,7 +17,7 @@
   "author": "P.R. van der Wilt",
   "main": "reactor.js",
   "scripts": {
-    "test": "node reactor.js"
+    "test": "node --test test/basic/*.test.js test/integration/*.test.js test/edge/*.test.js"
   },
   "node-red": {
     "nodes": {

reactor.html

@@ -1,9 +1,19 @@
+<!--
+| S88-niveau             | Primair (blokkleur) | Tekstkleur |
+| ---------------------- | ------------------- | ---------- |
+| **Area**               | `#0f52a5`           | wit        |
+| **Process Cell**       | `#0c99d9`           | wit        |
+| **Unit**               | `#50a8d9`           | zwart      |
+| **Equipment (Module)** | `#86bbdd`           | zwart      |
+| **Control Module**     | `#a9daee`           | zwart      |
+
+-->
 <script src="/reactor/menu.js"></script>
 
 <script type="text/javascript">
     RED.nodes.registerType("reactor", {
-        category: "WWTP",
+        category: "EVOLV",
-        color: "#c4cce0",
+        color: "#50a8d9",
         defaults: {
             name: { value: "" },
             reactor_type: { value: "CSTR", required: true },
@@ -29,6 +39,7 @@
             X_TS_init: { value: 125.0009, required: true },
 
             timeStep: { value: 1, required: true },
+            speedUpFactor: { value: 1 },
 
             enableLog: { value: false },
             logLevel: { value: "error" },
@@ -39,7 +50,7 @@
         outputs: 3,
         inputLabels: ["input"],
         outputLabels: ["process", "dbase", "parent"],
-        icon: "font-awesome/fa-recycle",
+        icon: "font-awesome/fa-flask",
         label: function() {
             return this.name || "Reactor";
         },
@@ -105,6 +116,10 @@
                 type:"num",
                 types:["num"]
             })
+            $("#node-input-speedUpFactor").typedInput({
+                type:"num",
+                types:["num"]
+            })
             // Set initial visibility on dialog open
             const initialType = $("#node-input-reactor_type").typedInput("value");
             if (initialType === "CSTR") {
@@ -120,8 +135,8 @@
             }
 
             // save position field
-            if (window.EVOLV?.nodes?.measurement?.positionMenu?.saveEditor) {
+            if (window.EVOLV?.nodes?.reactor?.positionMenu?.saveEditor) {
-                window.EVOLV.nodes.rotatingMachine.positionMenu.saveEditor(this);
+                window.EVOLV.nodes.reactor.positionMenu.saveEditor(this);
             }
 
             let volume = parseFloat($("#node-input-volume").typedInput("value"));
@@ -233,6 +248,10 @@
         <label for="node-input-timeStep"><i class="fa fa-tag"></i> Time step [s]</label>
         <input type="text" id="node-input-timeStep" placeholder="s">
     </div>
+    <div class="form-row">
+        <label for="node-input-speedUpFactor"><i class="fa fa-tag"></i> Speed-up factor</label>
+        <input type="text" id="node-input-speedUpFactor" placeholder="1 = real-time">
+    </div>
 
     <!-- Logger fields injected here -->
 	<div id="logger-fields-placeholder"></div>

src/nodeClass.js

@@ -1,5 +1,4 @@
 const { Reactor_CSTR, Reactor_PFR } = require('./specificClass.js');
-const { configManager } = require('generalFunctions');
 
 
 class nodeClass {
@@ -31,36 +30,42 @@ class nodeClass {
      */
     _attachInputHandler() {
         this.node.on('input', (msg, send, done) => {
-
+            try {
-            switch (msg.topic) {
+                switch (msg.topic) {
-                case "clock":
+                    case "clock":
-                    this.source.updateState(msg.timestamp);
+                        this.source.updateState(msg.timestamp);
-                    send([msg, null, null]);
+                        send([msg, null, null]);
-                    break;
+                        break;
-                case "Fluent":
+                    case "Fluent":
-                    this.source.setInfluent = msg;
+                        this.source.setInfluent = msg;
-                    break;
+                        break;
-                case "OTR":
+                    case "OTR":
-                    this.source.setOTR = msg;
+                        this.source.setOTR = msg;
-                    break;
+                        break;
-                case "Temperature":
+                    case "Temperature":
-                    this.source.setTemperature = msg;
+                        this.source.setTemperature = msg;
-                    break;
+                        break;
-                case "Dispersion":
+                    case "Dispersion":
-                    this.source.setDispersion = msg;
+                        this.source.setDispersion = msg;
-                    break;
+                        break;
-                case 'registerChild': {
+                    case 'registerChild': {
-                    // Register this node as a parent of the child node
+                        const childId = msg.payload;
-                    const childId = msg.payload;
+                        const childObj = this.RED.nodes.getNode(childId);
-                    const childObj = this.RED.nodes.getNode(childId);
+                        if (!childObj || !childObj.source) {
-                    this.source.childRegistrationUtils.registerChild(childObj.source, msg.positionVsParent);
+                            this.source?.logger?.warn(`registerChild skipped: missing child/source for id=${childId}`);
-                    break;
+                            break;
+                        }
+                        this.source.childRegistrationUtils.registerChild(childObj.source, msg.positionVsParent);
+                        break;
+                    }
+                    default:
+                        this.source?.logger?.warn(`Unknown topic: ${msg.topic}`);
                 }
-                default:
+            } catch (error) {
-                    console.log("Unknown topic: " + msg.topic);
+                this.source?.logger?.error(`Input handler failure: ${error.message}`);
             }
 
-            if (done) {
+            if (typeof done === 'function') {
                 done();
             }
         });
@@ -71,10 +76,20 @@ class nodeClass {
      * @param {object} uiConfig Config set in UI in node-red
      */
     _loadConfig(uiConfig) {
-        const cfgMgr = new configManager();
+        this.config = {
-
+            general: {
-        // Build config: base sections + reactor-specific domain config
+                name: uiConfig.name || this.name,
-        this.config = cfgMgr.buildConfig('reactor', uiConfig, this.node.id, {
+                id: this.node.id,
+                unit: null,
+                logging: {
+                    enabled: uiConfig.enableLog,
+                    logLevel: uiConfig.logLevel
+                }
+            },
+            functionality: {
+                positionVsParent: uiConfig.positionVsParent || 'atEquipment', // Default to 'atEquipment' if not specified
+                softwareType: "reactor" // should be set in config manager
+            },
             reactor_type: uiConfig.reactor_type,
             volume: parseFloat(uiConfig.volume),
             length: parseFloat(uiConfig.length),
@@ -97,8 +112,9 @@ class nodeClass {
                 parseFloat(uiConfig.X_A_init),
                 parseFloat(uiConfig.X_TS_init)
             ],
-            timeStep: parseFloat(uiConfig.timeStep)
+            timeStep: parseFloat(uiConfig.timeStep),
-        });
+            speedUpFactor: Number(uiConfig.speedUpFactor) || 1
+        }
     }
 
     /**
@@ -129,7 +145,8 @@ class nodeClass {
                 new_reactor = new Reactor_PFR(this.config);
                 break;
             default:
-                console.warn("Unknown reactor type: " + this.config.reactor_type);
+                this.node.warn("Unknown reactor type: " + this.config.reactor_type + ". Falling back to CSTR.");
+                new_reactor = new Reactor_CSTR(this.config);
         }
 
         this.source = new_reactor; // protect from reassignment
@@ -143,15 +160,19 @@ class nodeClass {
     }
 
     _tick(){
+        const gridProfile = this.source.getGridProfile;
+        if (gridProfile) {
+            this.node.send([{ topic: "GridProfile", payload: gridProfile }, null, null]);
+        }
         this.node.send([this.source.getEffluent, null, null]);
     }
 
     _attachCloseHandler() {
         this.node.on('close', (done) => {
             clearInterval(this._tickInterval);
-            done();
+            if (typeof done === 'function') done();
         });
     }
 }
 
-module.exports = nodeClass;
+module.exports = nodeClass;

src/reaction_modules/asm3_class Koch.js

@@ -19,7 +19,7 @@ class ASM3 {
       nu_NO:    0.5,  // anoxic reduction factor        [-]
       K_O:      0.2,  // saturation constant S_0        [g O2 m-3]
       K_NO:     0.5,  // saturation constant S_NO       [g NO3-N m-3]
-      K_S:      10.0, // saturation constant S_s        [g COD m-3]
+      K_S:      10.,  // saturation constant S_s        [g COD m-3]
       K_STO:    0.1,  // saturation constant X_STO      [g X_STO g-1 X_H]
       mu_H_max: 3.,   // maximum specific growth rate   [d-1]
       K_NH:     0.01, // saturation constant S_NH3      [g NH3-N m-3]
@@ -171,7 +171,7 @@ class ASM3 {
   compute_rates(state, T = 20) {
     // state: S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS
     const rates = Array(12);
-    const [S_O, , S_S, S_NH, , S_NO, S_HCO, , X_S, X_H, X_STO, X_A] = state;
+    const [S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS] = state;
     const { k_H, K_X, k_STO, nu_NO, K_O, K_NO, K_S, K_STO, mu_H_max, K_NH, K_HCO, b_H_O, b_H_NO, b_STO_O, b_STO_NO, mu_A_max, K_A_NH, K_A_O, K_A_HCO, b_A_O, b_A_NO } = this.kin_params;
     const { theta_H, theta_STO, theta_mu_H, theta_b_H_O, theta_b_H_NO, theta_b_STO_O, theta_b_STO_NO, theta_mu_A, theta_b_A_O, theta_b_A_NO } = this.temp_params;
 

src/reaction_modules/asm3_class.js

@@ -171,7 +171,7 @@ class ASM3 {
   compute_rates(state, T = 20) {
     // state: S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS
     const rates = Array(12);
-    const [S_O, , S_S, S_NH, , S_NO, S_HCO, , X_S, X_H, X_STO, X_A] = state;
+    const [S_O, S_I, S_S, S_NH, S_N2, S_NO, S_HCO, X_I, X_S, X_H, X_STO, X_A, X_TS] = state;
     const { k_H, K_X, k_STO, nu_NO, K_O, K_NO, K_S, K_STO, mu_H_max, K_NH, K_HCO, b_H_O, b_H_NO, b_STO_O, b_STO_NO, mu_A_max, K_A_NH, K_A_O, K_A_HCO, b_A_O, b_A_NO } = this.kin_params;
     const { theta_H, theta_STO, theta_mu_H, theta_b_H_O, theta_b_H_NO, theta_b_STO_O, theta_b_STO_NO, theta_mu_A, theta_b_A_O, theta_b_A_NO } = this.temp_params;
 

src/specificClass.js

@@ -1,7 +1,7 @@
 const ASM3 = require('./reaction_modules/asm3_class.js');
 const { create, all, isArray } = require('mathjs');
 const { assertNoNaN } = require('./utils.js');
-const { childRegistrationUtils, logger, MeasurementContainer, POSITIONS } = require('generalFunctions');
+const { childRegistrationUtils, logger, MeasurementContainer } = require('generalFunctions');
 const EventEmitter = require('events');
 
 const mathConfig = {
@@ -41,7 +41,7 @@ class Reactor {
 
     this.currentTime = Date.now(); // milliseconds since epoch [ms]
     this.timeStep = 1 / (24*60*60) * this.config.timeStep; // time step in seconds, converted to days.
-    this.speedUpFactor = 60; // speed up factor for simulation, 60 means 1 minute per simulated second
+    this.speedUpFactor = config.speedUpFactor ?? 1; // speed up factor for simulation
   }
 
   /**
@@ -62,6 +62,24 @@ class Reactor {
     this.OTR = input.payload;
   }
 
+  /**
+   * Setter for reactor temperature [C].
+   * Accepts either a direct numeric payload or { value } object payload.
+   * @param {object} input - Input object (msg)
+   */
+  set setTemperature(input) {
+    const payload = input?.payload;
+    const rawValue = (payload && typeof payload === 'object' && payload.value !== undefined)
+      ? payload.value
+      : payload;
+    const parsedValue = Number(rawValue);
+    if (!Number.isFinite(parsedValue)) {
+      this.logger.warn(`Invalid temperature input: ${rawValue}`);
+      return;
+    }
+    this.temperature = parsedValue;
+  }
+
   /**
    * Getter for effluent data.
    * @returns {object} Effluent data object (msg), defaults to inlet 0.
@@ -73,6 +91,8 @@ class Reactor {
     return { topic: "Fluent", payload: { inlet: 0, F: math.sum(this.Fs), C: this.state }, timestamp: this.currentTime };
   }
 
+  get getGridProfile() { return null; }
+
   /**
    * Calculate the oxygen transfer rate (OTR) based on the dissolved oxygen concentration and temperature.
    * @param {number} S_O - Dissolved oxygen concentration [g O2 m-3].
@@ -126,6 +146,7 @@ class Reactor {
       position = measurement.config.functionality.positionVsParent;
     }
     const measurementType = measurement.config.asset.type;
+    const key = `${measurementType}_${position}`;
     const eventName = `${measurementType}.measured.${position}`;
 
     // Register event listener for measurement updates
@@ -159,11 +180,11 @@ class Reactor {
   }
 
   
-  _updateMeasurement(measurementType, value, position, _context) {
+  _updateMeasurement(measurementType, value, position, context) {
     this.logger.debug(`---------------------- updating ${measurementType} ------------------ `);
     switch (measurementType) {
       case "temperature":
-        if (position == POSITIONS.AT_EQUIPMENT) {
+        if (position == "atEquipment") {
           this.temperature = value;
         }
         break;
@@ -256,6 +277,18 @@ class Reactor_PFR extends Reactor {
     assertNoNaN(this.D2_op, "Second derivative operator");
   }
 
+  get getGridProfile() {
+    return {
+      grid: this.state.map(row => row.slice()),
+      n_x: this.n_x,
+      d_x: this.d_x,
+      length: this.length,
+      species: ['S_O','S_I','S_S','S_NH','S_N2','S_NO','S_HCO',
+                'X_I','X_S','X_H','X_STO','X_A','X_TS'],
+      timestamp: this.currentTime
+    };
+  }
+
   /**
    * Setter for axial dispersion.
    * @param {object} input - Input object (msg) containing payload with dispersion value [m2 d-1].
@@ -319,15 +352,22 @@ class Reactor_PFR extends Reactor {
     return stateNew;
   }
 
-  _updateMeasurement(measurementType, value, position, _context) {
+  _updateMeasurement(measurementType, value, position, context) {
     switch(measurementType) {
-      case "quantity (oxygen)": {
+      case "quantity (oxygen)":
-        let grid_pos = Math.round(position / this.config.length * this.n_x);
+        if (!Number.isFinite(position) || !Number.isFinite(value) || this.config.length <= 0) {
-        this.state[grid_pos][S_O_INDEX] = value; // naive approach for reconciling measurements and simulation
+          this.logger.warn(`Ignoring oxygen measurement update with invalid data (position=${position}, value=${value}).`);
+          break;
+        }
+        {
+          // Clamp sensor-derived position to valid PFR grid bounds.
+          const rawIndex = Math.round(position / this.config.length * this.n_x);
+          const grid_pos = Math.max(0, Math.min(this.n_x - 1, rawIndex));
+          this.state[grid_pos][S_O_INDEX] = value; // reconcile measured oxygen concentration into nearest grid cell
+        }
         break;
-      }
       default:
-        super._updateMeasurement(measurementType, value, position, _context);
+        super._updateMeasurement(measurementType, value, position, context);
     }
   }
 
@@ -416,4 +456,4 @@ module.exports = { Reactor_CSTR, Reactor_PFR };
 // while (N < 5000) {
 //     console.log(Reactor.tick(0.001));
 //     N += 1;
-// }
+// }

test/README.md

@@ -0,0 +1,12 @@
+# reactor Test Suite Layout
+
+Required EVOLV layout:
+- basic/
+- integration/
+- edge/
+- helpers/
+
+Baseline structure tests:
+- basic/structure-module-load.basic.test.js
+- integration/structure-examples.integration.test.js
+- edge/structure-examples-node-type.edge.test.js

test/basic/constructor.basic.test.js

@@ -0,0 +1,55 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { Reactor_CSTR, Reactor_PFR } = require('../../src/specificClass');
+const { makeUiConfig, makeReactorConfig, makeNodeStub } = require('../helpers/factories');
+
+test('_loadConfig coerces numeric fields and builds initial state vector', () => {
+  const inst = Object.create(NodeClass.prototype);
+  inst.node = { id: 'n-reactor-1' };
+  inst.name = 'reactor';
+
+  inst._loadConfig(
+    makeUiConfig({
+      volume: '12.5',
+      length: '9',
+      resolution_L: '7',
+      alpha: '0.5',
+      n_inlets: '3',
+      timeStep: '2',
+      S_O_init: '1.1',
+    }),
+  );
+
+  assert.equal(inst.config.volume, 12.5);
+  assert.equal(inst.config.length, 9);
+  assert.equal(inst.config.resolution_L, 7);
+  assert.equal(inst.config.alpha, 0.5);
+  assert.equal(inst.config.n_inlets, 3);
+  assert.equal(inst.config.timeStep, 2);
+  assert.equal(inst.config.initialState.length, 13);
+  assert.equal(inst.config.initialState[0], 1.1);
+});
+
+test('_setupClass selects Reactor_CSTR when configured as CSTR', () => {
+  const inst = Object.create(NodeClass.prototype);
+  inst.node = makeNodeStub();
+  inst.config = makeReactorConfig({ reactor_type: 'CSTR' });
+
+  inst._setupClass();
+
+  assert.ok(inst.source instanceof Reactor_CSTR);
+  assert.equal(inst.node.source, inst.source);
+});
+
+test('_setupClass selects Reactor_PFR when configured as PFR', () => {
+  const inst = Object.create(NodeClass.prototype);
+  inst.node = makeNodeStub();
+  inst.config = makeReactorConfig({ reactor_type: 'PFR', length: 10, resolution_L: 5 });
+
+  inst._setupClass();
+
+  assert.ok(inst.source instanceof Reactor_PFR);
+  assert.equal(inst.node.source, inst.source);
+});

test/basic/cstr-tick.basic.test.js

@@ -0,0 +1,42 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_CSTR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+const NUM_SPECIES = 13;
+
+test('Reactor_CSTR tick clips negative concentrations to zero', () => {
+  const reactor = new Reactor_CSTR(
+    makeReactorConfig({
+      reactor_type: 'CSTR',
+      volume: 1,
+      n_inlets: 1,
+      kla: NaN,
+      S_O_init: 0.1,
+      S_I_init: 0.1,
+      S_S_init: 0.1,
+      S_NH_init: 0.1,
+      S_N2_init: 0.1,
+      S_NO_init: 0.1,
+      S_HCO_init: 0.1,
+      X_I_init: 0.1,
+      X_S_init: 0.1,
+      X_H_init: 0.1,
+      X_STO_init: 0.1,
+      X_A_init: 0.1,
+      X_TS_init: 0.1,
+    }),
+  );
+
+  reactor.asm = {
+    compute_dC: () => Array(NUM_SPECIES).fill(0),
+  };
+  reactor.Fs[0] = 1;
+  reactor.Cs_in[0] = Array(NUM_SPECIES).fill(0);
+
+  reactor.tick(1);
+
+  assert.equal(reactor.state.every((v) => Number.isFinite(v) && v >= 0), true);
+  assert.equal(reactor.state.every((v) => v === 0), true);
+});

test/basic/effluent-shape.basic.test.js

@@ -0,0 +1,38 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_CSTR, Reactor_PFR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+test('CSTR getEffluent returns flat concentration vector', () => {
+  const reactor = new Reactor_CSTR(makeReactorConfig({ reactor_type: 'CSTR', n_inlets: 1 }));
+  reactor.state = Array.from({ length: 13 }, (_, i) => i + 1);
+  reactor.Fs[0] = 5;
+
+  const effluent = reactor.getEffluent;
+
+  assert.equal(effluent.topic, 'Fluent');
+  assert.equal(effluent.payload.inlet, 0);
+  assert.equal(effluent.payload.F, 5);
+  assert.deepEqual(effluent.payload.C, reactor.state);
+});
+
+test('PFR getEffluent returns last slice concentration vector', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', n_inlets: 1, length: 10, resolution_L: 4 }),
+  );
+
+  reactor.state = [
+    Array(13).fill(10),
+    Array(13).fill(20),
+    Array(13).fill(30),
+    Array(13).fill(40),
+  ];
+  reactor.Fs[0] = 7;
+
+  const effluent = reactor.getEffluent;
+
+  assert.equal(effluent.topic, 'Fluent');
+  assert.equal(effluent.payload.F, 7);
+  assert.deepEqual(effluent.payload.C, Array(13).fill(40));
+});

test/basic/grid-profile.basic.test.js

@@ -0,0 +1,45 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_CSTR, Reactor_PFR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+test('CSTR getGridProfile returns null', () => {
+  const reactor = new Reactor_CSTR(makeReactorConfig({ reactor_type: 'CSTR' }));
+  assert.equal(reactor.getGridProfile, null);
+});
+
+test('PFR getGridProfile returns state matrix with correct dimensions', () => {
+  const n_x = 8;
+  const length = 40;
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', resolution_L: n_x, length }),
+  );
+
+  const profile = reactor.getGridProfile;
+  assert.notEqual(profile, null);
+  assert.equal(profile.n_x, n_x);
+  assert.equal(profile.d_x, length / n_x);
+  assert.equal(profile.length, length);
+  assert.equal(profile.grid.length, n_x, 'grid should have n_x rows');
+  assert.equal(profile.grid[0].length, 13, 'each row should have 13 species');
+  assert.ok(Array.isArray(profile.species), 'species list should be an array');
+  assert.equal(profile.species.length, 13);
+  assert.equal(profile.species[3], 'S_NH');
+  assert.equal(typeof profile.timestamp, 'number');
+});
+
+test('PFR getGridProfile is mutation-safe', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', resolution_L: 5, length: 10 }),
+  );
+
+  const profile = reactor.getGridProfile;
+  const originalValue = reactor.state[0][3]; // S_NH at cell 0
+
+  // Mutate the returned grid
+  profile.grid[0][3] = 999;
+
+  // Reactor internal state should be unchanged
+  assert.equal(reactor.state[0][3], originalValue, 'mutating grid copy must not affect reactor state');
+});

test/basic/input-routing.basic.test.js

@@ -0,0 +1,77 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { makeNodeStub, makeREDStub } = require('../helpers/factories');
+
+test('_attachInputHandler routes supported topics to source methods/setters', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+  const calls = [];
+
+  const source = {
+    updateState(timestamp) {
+      calls.push(['clock', timestamp]);
+    },
+    childRegistrationUtils: {
+      registerChild(childSource, position) {
+        calls.push(['registerChild', childSource, position]);
+      },
+    },
+  };
+
+  Object.defineProperty(source, 'setInfluent', {
+    set(v) {
+      calls.push(['Fluent', v]);
+    },
+  });
+
+  Object.defineProperty(source, 'setOTR', {
+    set(v) {
+      calls.push(['OTR', v]);
+    },
+  });
+
+  Object.defineProperty(source, 'setTemperature', {
+    set(v) {
+      calls.push(['Temperature', v]);
+    },
+  });
+
+  Object.defineProperty(source, 'setDispersion', {
+    set(v) {
+      calls.push(['Dispersion', v]);
+    },
+  });
+
+  inst.node = node;
+  inst.RED = makeREDStub({
+    childA: {
+      source: { id: 'child-source-A' },
+    },
+  });
+  inst.source = source;
+
+  inst._attachInputHandler();
+
+  const onInput = node._handlers.input;
+  const sent = [];
+  let doneCount = 0;
+
+  onInput({ topic: 'clock', timestamp: 1000 }, (msg) => sent.push(msg), () => doneCount++);
+  onInput({ topic: 'Fluent', payload: { inlet: 0, F: 10, C: [] } }, () => {}, () => doneCount++);
+  onInput({ topic: 'OTR', payload: 3.5 }, () => {}, () => doneCount++);
+  onInput({ topic: 'Temperature', payload: 18.2 }, () => {}, () => doneCount++);
+  onInput({ topic: 'Dispersion', payload: 0.2 }, () => {}, () => doneCount++);
+  onInput({ topic: 'registerChild', payload: 'childA', positionVsParent: 'upstream' }, () => {}, () => doneCount++);
+
+  assert.equal(doneCount, 6);
+  assert.equal(sent.length, 1);
+  assert.equal(Array.isArray(sent[0]), true);
+  assert.deepEqual(calls[0], ['clock', 1000]);
+  assert.equal(calls.some((x) => x[0] === 'Fluent'), true);
+  assert.equal(calls.some((x) => x[0] === 'OTR'), true);
+  assert.equal(calls.some((x) => x[0] === 'Temperature'), true);
+  assert.equal(calls.some((x) => x[0] === 'Dispersion'), true);
+  assert.deepEqual(calls.at(-1), ['registerChild', { id: 'child-source-A' }, 'upstream']);
+});

test/basic/pfr-operators.basic.test.js

@@ -0,0 +1,27 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_PFR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+test('Reactor_PFR derivative operators have expected dimensions and boundary rows', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({
+      reactor_type: 'PFR',
+      length: 12,
+      resolution_L: 6,
+      volume: 60,
+      n_inlets: 1,
+    }),
+  );
+
+  assert.equal(reactor.D_op.length, reactor.n_x);
+  assert.equal(reactor.D2_op.length, reactor.n_x);
+  assert.equal(reactor.D_op.every((row) => row.length === reactor.n_x), true);
+  assert.equal(reactor.D2_op.every((row) => row.length === reactor.n_x), true);
+
+  assert.deepEqual(reactor.D_op[0], Array(reactor.n_x).fill(0));
+  assert.deepEqual(reactor.D_op[reactor.n_x - 1], Array(reactor.n_x).fill(0));
+  assert.deepEqual(reactor.D2_op[0], Array(reactor.n_x).fill(0));
+  assert.deepEqual(reactor.D2_op[reactor.n_x - 1], Array(reactor.n_x).fill(0));
+});

test/basic/register-child.basic.test.js

@@ -0,0 +1,39 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { makeNodeStub } = require('../helpers/factories');
+
+test('_registerChild emits delayed registration message on output 2', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+
+  inst.node = node;
+  inst.config = {
+    functionality: {
+      positionVsParent: 'downstream',
+    },
+  };
+
+  const originalSetTimeout = global.setTimeout;
+  const delays = [];
+
+  global.setTimeout = (fn, ms) => {
+    delays.push(ms);
+    fn();
+    return 1;
+  };
+
+  try {
+    inst._registerChild();
+  } finally {
+    global.setTimeout = originalSetTimeout;
+  }
+
+  assert.deepEqual(delays, [100]);
+  assert.equal(node._sent.length, 1);
+  assert.equal(Array.isArray(node._sent[0]), true);
+  assert.equal(node._sent[0][2].topic, 'registerChild');
+  assert.equal(node._sent[0][2].payload, node.id);
+  assert.equal(node._sent[0][2].positionVsParent, 'downstream');
+});

test/basic/speedup-factor.basic.test.js

@@ -0,0 +1,68 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_CSTR } = require('../../src/specificClass');
+const nodeClass = require('../../src/nodeClass');
+const { makeReactorConfig, makeUiConfig, makeNodeStub, makeREDStub } = require('../helpers/factories');
+
+/**
+ * Smoke tests for Fix 3: configurable speedUpFactor on Reactor.
+ */
+
+test('specificClass defaults speedUpFactor to 1 when not in config', () => {
+  const config = makeReactorConfig();
+  const reactor = new Reactor_CSTR(config);
+  assert.equal(reactor.speedUpFactor, 1, 'speedUpFactor should default to 1');
+});
+
+test('specificClass accepts speedUpFactor from config', () => {
+  const config = makeReactorConfig();
+  config.speedUpFactor = 10;
+  const reactor = new Reactor_CSTR(config);
+  assert.equal(reactor.speedUpFactor, 10, 'speedUpFactor should be read from config');
+});
+
+test('specificClass accepts speedUpFactor = 60 for accelerated simulation', () => {
+  const config = makeReactorConfig();
+  config.speedUpFactor = 60;
+  const reactor = new Reactor_CSTR(config);
+  assert.equal(reactor.speedUpFactor, 60, 'speedUpFactor=60 should be accepted');
+});
+
+test('nodeClass passes speedUpFactor from uiConfig to reactor config', () => {
+  const uiConfig = makeUiConfig({ speedUpFactor: 5 });
+  const node = makeNodeStub();
+  const RED = makeREDStub();
+
+  const nc = new nodeClass(uiConfig, RED, node, 'test-reactor');
+  assert.equal(nc.source.speedUpFactor, 5, 'nodeClass should pass speedUpFactor=5 to specificClass');
+});
+
+test('nodeClass defaults speedUpFactor to 1 when not in uiConfig', () => {
+  const uiConfig = makeUiConfig();
+  // Ensure speedUpFactor is not set
+  delete uiConfig.speedUpFactor;
+
+  const node = makeNodeStub();
+  const RED = makeREDStub();
+
+  const nc = new nodeClass(uiConfig, RED, node, 'test-reactor');
+  assert.equal(nc.source.speedUpFactor, 1, 'nodeClass should default speedUpFactor to 1');
+});
+
+test('updateState with speedUpFactor=1 advances roughly real-time', () => {
+  const config = makeReactorConfig();
+  config.speedUpFactor = 1;
+  config.n_inlets = 1;
+  const reactor = new Reactor_CSTR(config);
+
+  // Set a known start time
+  const t0 = reactor.currentTime;
+  // Advance by 2 seconds real time
+  reactor.updateState(t0 + 2000);
+
+  // With speedUpFactor=1, simulation should have advanced ~2 seconds worth
+  // (not 120 seconds like with the old hardcoded 60x factor)
+  const elapsed = reactor.currentTime - t0;
+  assert.ok(elapsed < 5000, `Elapsed ${elapsed}ms should be close to 2000ms, not 120000ms (old 60x factor)`);
+});

test/basic/structure-module-load.basic.test.js

@@ -0,0 +1,8 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+test('reactor module load smoke', () => {
+  assert.doesNotThrow(() => {
+    require('../../reactor.js');
+  });
+});

test/edge/invalid-reactor-type.edge.test.js

@@ -0,0 +1,15 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { makeNodeStub, makeUiConfig } = require('../helpers/factories');
+
+test('_setupClass with unknown reactor_type throws (known error-path behavior)', () => {
+  const inst = Object.create(NodeClass.prototype);
+  inst.node = makeNodeStub();
+  inst.config = makeUiConfig({ reactor_type: 'UNKNOWN_TYPE' });
+
+  assert.throws(() => {
+    inst._setupClass();
+  });
+});

test/edge/invalid-topic.edge.test.js

@@ -0,0 +1,30 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { makeNodeStub, makeREDStub } = require('../helpers/factories');
+
+test('unknown input topic does not throw and still calls done', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+
+  inst.node = node;
+  inst.RED = makeREDStub();
+  inst.source = {
+    childRegistrationUtils: {
+      registerChild() {},
+    },
+    updateState() {},
+  };
+
+  inst._attachInputHandler();
+
+  let doneCalled = 0;
+  assert.doesNotThrow(() => {
+    node._handlers.input({ topic: 'somethingUnknown', payload: 1 }, () => {}, () => {
+      doneCalled += 1;
+    });
+  });
+
+  assert.equal(doneCalled, 1);
+});

test/edge/missing-child.edge.test.js

@@ -0,0 +1,28 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { makeNodeStub, makeREDStub } = require('../helpers/factories');
+
+test('registerChild with unknown node id is ignored without throwing', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+
+  inst.node = node;
+  inst.RED = makeREDStub();
+  inst.source = {
+    childRegistrationUtils: {
+      registerChild() {},
+    },
+  };
+
+  inst._attachInputHandler();
+
+  assert.doesNotThrow(() => {
+    node._handlers.input(
+      { topic: 'registerChild', payload: 'missing-child', positionVsParent: 'upstream' },
+      () => {},
+      () => {},
+    );
+  });
+});

test/edge/pfr-measurement-grid.edge.test.js

@@ -0,0 +1,16 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_PFR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+test('oxygen measurement at exact reactor length is clamped to the last PFR grid index', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', length: 10, resolution_L: 5, n_inlets: 1 }),
+  );
+
+  assert.doesNotThrow(() => {
+    reactor._updateMeasurement('quantity (oxygen)', 2.5, 10, {});
+  });
+  assert.equal(reactor.state[reactor.n_x - 1][0], 2.5);
+});

test/edge/structure-examples-node-type.edge.test.js

@@ -0,0 +1,11 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const flow = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../examples/basic.flow.json'), 'utf8'));
+
+test('basic example includes node type reactor', () => {
+  const count = flow.filter((n) => n && n.type === 'reactor').length;
+  assert.equal(count >= 1, true);
+});

test/edge/zero-dispersion.edge.test.js

@@ -0,0 +1,27 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_PFR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+const DAY_MS = 1000 * 60 * 60 * 24;
+
+test('updateState warns when local Peclet number is too high at zero dispersion', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', length: 10, resolution_L: 5, volume: 50, n_inlets: 1 }),
+  );
+
+  const warnings = [];
+  reactor.logger.warn = (msg) => warnings.push(String(msg));
+
+  reactor.currentTime = 0;
+  reactor.timeStep = 1;
+  reactor.speedUpFactor = 1;
+  reactor.Fs[0] = 2;
+  reactor.D = 0;
+  reactor.tick = () => reactor.state;
+
+  reactor.updateState(DAY_MS);
+
+  assert.equal(warnings.some((w) => w.includes('Péclet number') || w.includes('Peclet number')), true);
+});

test/helpers/factories.js

@@ -0,0 +1,149 @@
+const EventEmitter = require('node:events');
+
+function makeUiConfig(overrides = {}) {
+  return {
+    name: 'reactor-test',
+    reactor_type: 'CSTR',
+    volume: 100,
+    length: 10,
+    resolution_L: 5,
+    alpha: 0,
+    n_inlets: 1,
+    kla: NaN,
+    S_O_init: 0,
+    S_I_init: 30,
+    S_S_init: 100,
+    S_NH_init: 16,
+    S_N2_init: 0,
+    S_NO_init: 0,
+    S_HCO_init: 5,
+    X_I_init: 25,
+    X_S_init: 75,
+    X_H_init: 30,
+    X_STO_init: 0,
+    X_A_init: 0.001,
+    X_TS_init: 125,
+    timeStep: 1,
+    enableLog: false,
+    logLevel: 'error',
+    positionVsParent: 'atEquipment',
+    ...overrides,
+  };
+}
+
+function makeReactorConfig(overrides = {}) {
+  const ui = makeUiConfig(overrides);
+  return {
+    general: {
+      id: 'reactor-node-1',
+      name: ui.name,
+      unit: null,
+      logging: {
+        enabled: ui.enableLog,
+        logLevel: ui.logLevel,
+      },
+    },
+    functionality: {
+      positionVsParent: ui.positionVsParent || 'atEquipment',
+      softwareType: 'reactor',
+    },
+    reactor_type: ui.reactor_type,
+    volume: Number(ui.volume),
+    length: Number(ui.length),
+    resolution_L: Number(ui.resolution_L),
+    alpha: Number(ui.alpha),
+    n_inlets: Number(ui.n_inlets),
+    kla: Number(ui.kla),
+    initialState: [
+      Number(ui.S_O_init),
+      Number(ui.S_I_init),
+      Number(ui.S_S_init),
+      Number(ui.S_NH_init),
+      Number(ui.S_N2_init),
+      Number(ui.S_NO_init),
+      Number(ui.S_HCO_init),
+      Number(ui.X_I_init),
+      Number(ui.X_S_init),
+      Number(ui.X_H_init),
+      Number(ui.X_STO_init),
+      Number(ui.X_A_init),
+      Number(ui.X_TS_init),
+    ],
+    timeStep: Number(ui.timeStep),
+  };
+}
+
+function makeNodeStub() {
+  const handlers = {};
+  const sent = [];
+  const warns = [];
+  const errors = [];
+  const statuses = [];
+
+  return {
+    id: 'reactor-node-1',
+    source: null,
+    on(event, cb) {
+      handlers[event] = cb;
+    },
+    send(msg) {
+      sent.push(msg);
+    },
+    warn(msg) {
+      warns.push(msg);
+    },
+    error(msg) {
+      errors.push(msg);
+    },
+    status(msg) {
+      statuses.push(msg);
+    },
+    _handlers: handlers,
+    _sent: sent,
+    _warns: warns,
+    _errors: errors,
+    _statuses: statuses,
+  };
+}
+
+function makeREDStub(nodeMap = {}) {
+  return {
+    nodes: {
+      getNode(id) {
+        return nodeMap[id] || null;
+      },
+      createNode() {},
+      registerType() {},
+    },
+    httpAdmin: {
+      get() {},
+    },
+  };
+}
+
+function makeMeasurementChild({
+  id = 'measurement-1',
+  name = 'temp-sensor-1',
+  distance = 'atEquipment',
+  positionVsParent = 'atEquipment',
+  type = 'temperature',
+} = {}) {
+  return {
+    config: {
+      general: { id, name },
+      functionality: { distance, positionVsParent, softwareType: 'measurement' },
+      asset: { type },
+    },
+    measurements: {
+      emitter: new EventEmitter(),
+    },
+  };
+}
+
+module.exports = {
+  makeUiConfig,
+  makeReactorConfig,
+  makeNodeStub,
+  makeREDStub,
+  makeMeasurementChild,
+};

test/integration/measurement-temperature.integration.test.js

@@ -0,0 +1,26 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_CSTR } = require('../../src/specificClass');
+const { makeReactorConfig, makeMeasurementChild } = require('../helpers/factories');
+
+test('measurement child temperature event updates reactor temperature', () => {
+  const reactor = new Reactor_CSTR(makeReactorConfig({ reactor_type: 'CSTR' }));
+
+  const measurement = makeMeasurementChild({
+    type: 'temperature',
+    distance: 'atEquipment',
+    positionVsParent: 'upstream',
+  });
+
+  reactor.registerChild(measurement, 'measurement');
+
+  measurement.measurements.emitter.emit('temperature.measured.atEquipment', {
+    childName: 'T-1',
+    value: 27.5,
+    unit: 'C',
+    timestamp: Date.now(),
+  });
+
+  assert.equal(reactor.temperature, 27.5);
+});

test/integration/otr-kla.integration.test.js

@@ -0,0 +1,85 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_CSTR, Reactor_PFR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+const NUM_SPECIES = 13;
+
+test('CSTR uses external OTR when kla is NaN', () => {
+  const reactor = new Reactor_CSTR(
+    makeReactorConfig({ reactor_type: 'CSTR', kla: NaN, n_inlets: 1 }),
+  );
+
+  reactor.asm = {
+    compute_dC: () => Array(NUM_SPECIES).fill(0),
+  };
+  reactor.Fs[0] = 0;
+  reactor.OTR = 4;
+  reactor.state = Array(NUM_SPECIES).fill(0);
+
+  reactor.tick(1);
+
+  assert.equal(reactor.state[0], 4);
+});
+
+test('CSTR uses kla-based oxygen transfer when kla is finite', () => {
+  const reactor = new Reactor_CSTR(
+    makeReactorConfig({ reactor_type: 'CSTR', kla: 2, n_inlets: 1 }),
+  );
+
+  reactor.asm = {
+    compute_dC: () => Array(NUM_SPECIES).fill(0),
+  };
+  reactor.Fs[0] = 0;
+  reactor.OTR = 1;
+  reactor.state = Array(NUM_SPECIES).fill(0);
+
+  const expected = reactor._calcOTR(0, reactor.temperature);
+  reactor.tick(1);
+
+  assert.ok(Math.abs(reactor.state[0] - expected) < 1e-9);
+});
+
+test('PFR uses external OTR branch when kla is NaN', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', kla: NaN, n_inlets: 1, length: 8, resolution_L: 6, volume: 40 }),
+  );
+
+  reactor.asm = {
+    compute_dC: () => Array(NUM_SPECIES).fill(0),
+  };
+  reactor.Fs[0] = 0;
+  reactor.D = 0;
+  reactor.OTR = 3;
+  reactor.state = Array.from({ length: reactor.n_x }, () => Array(NUM_SPECIES).fill(0));
+
+  reactor.tick(1);
+
+  assert.equal(reactor.state[1][0], 4.5);
+  assert.equal(reactor.state[2][0], 4.5);
+  assert.equal(reactor.state[3][0], 4.5);
+  assert.equal(reactor.state[4][0], 4.5);
+});
+
+test('PFR uses kla-based transfer branch when kla is finite', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', kla: 1, n_inlets: 1, length: 8, resolution_L: 6, volume: 40 }),
+  );
+
+  reactor.asm = {
+    compute_dC: () => Array(NUM_SPECIES).fill(0),
+  };
+  reactor.Fs[0] = 0;
+  reactor.D = 0;
+  reactor.OTR = 0;
+  reactor.state = Array.from({ length: reactor.n_x }, () => Array(NUM_SPECIES).fill(0));
+
+  const expected = reactor._calcOTR(0, reactor.temperature) * (reactor.n_x / (reactor.n_x - 2));
+  reactor.tick(1);
+
+  assert.ok(Math.abs(reactor.state[1][0] - expected) < 1e-9);
+  assert.ok(Math.abs(reactor.state[2][0] - expected) < 1e-9);
+  assert.ok(Math.abs(reactor.state[3][0] - expected) < 1e-9);
+  assert.ok(Math.abs(reactor.state[4][0] - expected) < 1e-9);
+});

test/integration/pfr-boundary.integration.test.js

@@ -0,0 +1,35 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_PFR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+test('_applyBoundaryConditions enforces Danckwerts inlet and Neumann outlet for flowing case', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', n_inlets: 1, length: 10, resolution_L: 5, volume: 50, alpha: 0.2 }),
+  );
+
+  reactor.Fs[0] = 2;
+  reactor.Cs_in[0] = Array(13).fill(9);
+  reactor.D = 1;
+
+  const state = Array.from({ length: reactor.n_x }, (_, i) => Array(13).fill(i));
+  reactor._applyBoundaryConditions(state);
+
+  assert.deepEqual(state[reactor.n_x - 1], state[reactor.n_x - 2]);
+  assert.equal(state[0].every((v) => Number.isFinite(v)), true);
+});
+
+test('_applyBoundaryConditions copies first interior slice when no flow is present', () => {
+  const reactor = new Reactor_PFR(
+    makeReactorConfig({ reactor_type: 'PFR', n_inlets: 1, length: 10, resolution_L: 5, volume: 50 }),
+  );
+
+  reactor.Fs[0] = 0;
+  const state = Array.from({ length: reactor.n_x }, (_, i) => Array(13).fill(i + 10));
+
+  reactor._applyBoundaryConditions(state);
+
+  assert.deepEqual(state[0], state[1]);
+  assert.deepEqual(state[reactor.n_x - 1], state[reactor.n_x - 2]);
+});

test/integration/structure-examples.integration.test.js

@@ -0,0 +1,23 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const dir = path.resolve(__dirname, '../../examples');
+
+function loadJson(file) {
+  return JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+}
+
+test('examples package exists for reactor', () => {
+  for (const file of ['README.md', 'basic.flow.json', 'integration.flow.json', 'edge.flow.json']) {
+    assert.equal(fs.existsSync(path.join(dir, file)), true, file + ' missing');
+  }
+});
+
+test('example flows are parseable arrays for reactor', () => {
+  for (const file of ['basic.flow.json', 'integration.flow.json', 'edge.flow.json']) {
+    const parsed = loadJson(file);
+    assert.equal(Array.isArray(parsed), true);
+  }
+});

test/integration/tick-loop.integration.test.js

@@ -0,0 +1,89 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const NodeClass = require('../../src/nodeClass');
+const { makeNodeStub } = require('../helpers/factories');
+
+test('_tick emits source effluent on process output', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+
+  inst.node = node;
+  inst.source = {
+    get getEffluent() {
+      return { topic: 'Fluent', payload: { inlet: 0, F: 1, C: [] }, timestamp: 1 };
+    },
+  };
+
+  inst._tick();
+
+  assert.equal(node._sent.length, 1);
+  assert.equal(node._sent[0][0].topic, 'Fluent');
+  assert.equal(node._sent[0][1], null);
+  assert.equal(node._sent[0][2], null);
+});
+
+test('_startTickLoop schedules periodic tick after startup delay', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const delays = [];
+  const intervals = [];
+  let tickCount = 0;
+
+  inst._tick = () => {
+    tickCount += 1;
+  };
+
+  const originalSetTimeout = global.setTimeout;
+  const originalSetInterval = global.setInterval;
+
+  global.setTimeout = (fn, ms) => {
+    delays.push(ms);
+    fn();
+    return 10;
+  };
+
+  global.setInterval = (fn, ms) => {
+    intervals.push(ms);
+    fn();
+    return 22;
+  };
+
+  try {
+    inst._startTickLoop();
+  } finally {
+    global.setTimeout = originalSetTimeout;
+    global.setInterval = originalSetInterval;
+  }
+
+  assert.deepEqual(delays, [1000]);
+  assert.deepEqual(intervals, [1000]);
+  assert.equal(inst._tickInterval, 22);
+  assert.equal(tickCount, 1);
+});
+
+test('_attachCloseHandler clears tick interval and calls done callback', () => {
+  const inst = Object.create(NodeClass.prototype);
+  const node = makeNodeStub();
+  inst.node = node;
+  inst._tickInterval = 55;
+
+  const cleared = [];
+  const originalClearInterval = global.clearInterval;
+  global.clearInterval = (id) => {
+    cleared.push(id);
+  };
+
+  let doneCalled = 0;
+
+  try {
+    inst._attachCloseHandler();
+    node._handlers.close(() => {
+      doneCalled += 1;
+    });
+  } finally {
+    global.clearInterval = originalClearInterval;
+  }
+
+  assert.deepEqual(cleared, [55]);
+  assert.equal(doneCalled, 1);
+});

test/integration/upstream-reactor.integration.test.js

@@ -0,0 +1,48 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { Reactor_CSTR } = require('../../src/specificClass');
+const { makeReactorConfig } = require('../helpers/factories');
+
+const DAY_MS = 1000 * 60 * 60 * 24;
+
+test('registering upstream reactor subscribes to upstream stateChange events', () => {
+  const downstream = new Reactor_CSTR(makeReactorConfig({ reactor_type: 'CSTR' }));
+  const upstream = new Reactor_CSTR(makeReactorConfig({ reactor_type: 'CSTR' }));
+
+  let calledWith = null;
+  downstream.updateState = (timestamp) => {
+    calledWith = timestamp;
+  };
+
+  downstream.registerChild(upstream, 'reactor');
+  upstream.emitter.emit('stateChange', 12345);
+
+  assert.equal(downstream.upstreamReactor, upstream);
+  assert.equal(calledWith, 12345);
+});
+
+test('updateState pulls influent from upstream reactor effluent when linked', () => {
+  const downstream = new Reactor_CSTR(makeReactorConfig({ reactor_type: 'CSTR', n_inlets: 1, timeStep: 1 }));
+  const upstream = new Reactor_CSTR(makeReactorConfig({ reactor_type: 'CSTR', n_inlets: 1 }));
+
+  upstream.Fs[0] = 3;
+  upstream.state = Array(13).fill(11);
+
+  downstream.upstreamReactor = upstream;
+  downstream.currentTime = 0;
+  downstream.timeStep = 1;
+  downstream.speedUpFactor = 1;
+
+  let ticks = 0;
+  downstream.tick = () => {
+    ticks += 1;
+    return downstream.state;
+  };
+
+  downstream.updateState(DAY_MS);
+
+  assert.equal(ticks, 1);
+  assert.equal(downstream.Fs[0], 3);
+  assert.deepEqual(downstream.Cs_in[0], Array(13).fill(11));
+});