fix(rm): force-emit ctrl every tick (static alwaysEmitFields)

Realized control position is constant in steady state, so delta compression
emitted it ~once and the Grafana "% Control" line went invisible. Exempt
`ctrl` from delta compression so the pump's movement always traces.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/curves/curveNormalizer.js

@@ -1,39 +1,24 @@
-const { convert } = require('generalFunctions');
-
-/**
- * Strict numeric unit conversion. Mirrors specificClass._convertUnitValue
- * so the curve normalizer is testable without a Machine instance.
- */
-function convertUnitValue(value, fromUnit, toUnit, contextLabel = 'unit conversion') {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric)) {
-    throw new Error(`${contextLabel}: value '${value}' is not finite`);
-  }
-  if (!fromUnit || !toUnit || fromUnit === toUnit) return numeric;
-  return convert(numeric).from(fromUnit).to(toUnit);
-}
-
 /**
  * Convert one curve section (nq or np) from supplied units to canonical
- * units. Logs a warning when the per-pressure median y jumps by more than
- * 3x relative to the previous pressure level — that almost always means the
- * curve file is corrupt (mixed units, swapped rows) and the predict module
- * would otherwise silently produce nonsense values.
+ * units using the host UnitPolicy. Logs a warning when the per-pressure
+ * median y jumps by more than 3x relative to the previous pressure level —
+ * that almost always means the curve file is corrupt (mixed units, swapped
+ * rows) and the predict module would otherwise silently produce nonsense.
  */
-function normalizeCurveSection(section, fromYUnit, toYUnit, fromPressureUnit, toPressureUnit, sectionName, logger) {
+function normalizeCurveSection(section, unitPolicy, fromYUnit, toYUnit, fromPressureUnit, toPressureUnit, sectionName, logger) {
   const normalized = {};
   let prevMedianY = null;
 
   for (const [pressureKey, pair] of Object.entries(section || {})) {
-    const canonicalPressure = convertUnitValue(
+    const canonicalPressure = unitPolicy.convert(
       Number(pressureKey),
       fromPressureUnit,
       toPressureUnit,
-      `${sectionName} pressure axis`
+      `${sectionName} pressure axis`,
     );
     const xArray = Array.isArray(pair?.x) ? pair.x.map(Number) : [];
     const yArray = Array.isArray(pair?.y)
-      ? pair.y.map((v) => convertUnitValue(v, fromYUnit, toYUnit, `${sectionName} output`))
+      ? pair.y.map((v) => unitPolicy.convert(v, fromYUnit, toYUnit, `${sectionName} output`))
       : [];
     if (!xArray.length || !yArray.length || xArray.length !== yArray.length) {
       throw new Error(`Invalid ${sectionName} section at pressure '${pressureKey}'.`);
@@ -74,21 +59,23 @@ function normalizeMachineCurve(rawCurve, unitPolicy, logger) {
   return {
     nq: normalizeCurveSection(
       rawCurve.nq,
+      unitPolicy,
       curveUnits.flow,
       canonicalFlow,
       curveUnits.pressure,
       canonicalPressure,
       'nq',
-      logger
+      logger,
     ),
     np: normalizeCurveSection(
       rawCurve.np,
+      unitPolicy,
       curveUnits.power,
       canonicalPower,
       curveUnits.pressure,
       canonicalPressure,
       'np',
-      logger
+      logger,
     ),
   };
 }
@@ -114,4 +101,4 @@ function readCanonical(unitPolicy, type) {
   return (unitPolicy.canonical || {})[type] || null;
 }
 
-module.exports = { normalizeMachineCurve, normalizeCurveSection, convertUnitValue };
+module.exports = { normalizeMachineCurve, normalizeCurveSection };

src/display/workingCurves.js

@@ -79,6 +79,12 @@ function buildQHCurve(predictors, ctrlPct, options = {}) {
   if (!pf.inputCurve || typeof pf.inputCurve !== 'object') {
     return { error: NO_CURVE_ERROR, points: [] };
   }
+  const policy = options.unitPolicy || predictors.unitPolicy;
+  if (!policy) {
+    return { error: 'No unitPolicy available for Q-axis conversion', points: [] };
+  }
+  const flowFrom = policy.canonical?.flow || policy.canonical?.('flow');
+  const flowTo = policy.output?.flow || policy.output?.('flow');
   const x = Number.isFinite(+ctrlPct) ? +ctrlPct : (pf.currentX ?? 0);
   const RHO = 999.1;   // kg/m³ — water at ~15 °C
   const G = 9.80665;   // m/s²
@@ -103,7 +109,8 @@ function buildQHCurve(predictors, ctrlPct, options = {}) {
     for (const p of pressures) {
       pf.fDimension = p;
       const QM3s = pf.y(x);
-      points.push({ Q: QM3s * 3600, H: p / (RHO * G), dpPa: p });
+      const Q = policy.convert(QM3s, flowFrom, flowTo, 'buildQHCurve Q-axis');
+      points.push({ Q, H: p / (RHO * G), dpPa: p });
     }
   } finally {
     pf.fDimension = originalF;

src/flow/flowController.js

@@ -50,7 +50,7 @@ class FlowController {
           return await host.executeSequence(parameter);
 
         case 'flowmovement': {
-          const canonicalFlowSetpoint = host._convertUnitValue(
+          const canonicalFlowSetpoint = host.unitPolicy.convert(
             parameter,
             host.unitPolicy.output.flow,
             host.unitPolicy.canonical.flow,

src/nodeClass.js

@@ -11,6 +11,10 @@ class nodeClass extends BaseNodeAdapter {
   static commands = commands;
   static tickInterval = null;
   static statusInterval = 1000;
+  // Realized control position holds constant in steady state, so delta
+  // compression would emit it ~once and the Grafana "% Control" line goes
+  // invisible. Force it every tick so the pump's movement always traces.
+  static alwaysEmitFields = ['ctrl'];
 
   buildDomainConfig(uiConfig) {
     _rejectLegacyAssetFields(uiConfig);

src/specificClass.js

@@ -229,10 +229,18 @@ class Machine extends BaseDomain {
     this.measurements.type('temperature').variant('measured').position('atEquipment').value(15, Date.now(), tu);
     this.measurements.type('atmPressure').variant('measured').position('atEquipment').value(101325, Date.now(), 'Pa');
     const fu = this.unitPolicy.canonical.flow;
+    const pu = this.unitPolicy.canonical.power;
     const fmin = this.predictFlow ? this.predictFlow.currentFxyYMin : 0;
     const fmax = this.predictFlow ? this.predictFlow.currentFxyYMax : 0;
     this.measurements.type('flow').variant('predicted').position('max').value(fmax, Date.now(), fu);
     this.measurements.type('flow').variant('predicted').position('min').value(fmin, Date.now(), fu);
+    // Seed the operating-point series at boot so telemetry always carries them
+    // (0 while idle, real values once calcFlow/calcPower run when operational).
+    // Without this an idle-from-boot machine never emits these keys — the
+    // dashboard can't even show the off/0 state. Mirrors max/min above.
+    this.measurements.type('flow').variant('predicted').position('downstream').value(0, Date.now(), fu);
+    this.measurements.type('flow').variant('predicted').position('atEquipment').value(0, Date.now(), fu);
+    this.measurements.type('power').variant('predicted').position('atEquipment').value(0, Date.now(), pu);
   }
 
   _callMeasurementHandler(measurementType, value, position, context = {}) {
@@ -247,12 +255,6 @@ class Machine extends BaseDomain {
     if (!this.isUnitValidForType(type, u)) throw new Error(`Unsupported unit '${u}' for ${type} measurement.`);
     return u;
   }
-  _convertUnitValue(value, from, to, ctx = 'unit conversion') {
-    const n = Number(value);
-    if (!Number.isFinite(n)) throw new Error(`${ctx}: value '${value}' is not finite`);
-    if (!from || !to || from === to) return n;
-    return convert(n).from(from).to(to);
-  }
   _measurementPositionForMetric(metricId) { return metricId === 'power' ? 'atEquipment' : 'downstream'; }
   _resolveProcessRangeForMetric(metricId, predicted, measured) {
     let processMin = NaN; let processMax = NaN;

test/basic/curveNormalizer.basic.test.js

@@ -5,7 +5,6 @@ const { UnitPolicy } = require('generalFunctions');
 const {
   normalizeMachineCurve,
   normalizeCurveSection,
-  convertUnitValue,
 } = require('../../src/curves/curveNormalizer');
 
 function makePolicy() {
@@ -50,39 +49,33 @@ test('normalizeMachineCurve: converts pressure mbar -> Pa and flow m3/h -> m3/s'
 });
 
 test('normalizeCurveSection: warns on cross-pressure median > 3x jump', () => {
+  const policy = makePolicy();
   const logger = captureLogger();
   const section = {
     1000: { x: [0, 50, 100], y: [0, 5, 10] },     // median 5
     1100: { x: [0, 50, 100], y: [0, 50, 100] },   // median 50 (10x jump)
   };
-  normalizeCurveSection(section, 'm3/h', 'm3/h', 'mbar', 'mbar', 'nq', logger);
+  normalizeCurveSection(section, policy, 'm3/h', 'm3/h', 'mbar', 'mbar', 'nq', logger);
   const hit = logger.warns.find((w) => /Curve anomaly/.test(w));
   assert.ok(hit, `expected a Curve anomaly warning, got: ${JSON.stringify(logger.warns)}`);
   assert.match(hit, /pressure 1100/);
 });
 
 test('normalizeCurveSection: does not warn on smooth progressions', () => {
+  const policy = makePolicy();
   const logger = captureLogger();
   const section = {
     1000: { x: [0, 50, 100], y: [0, 5, 10] },
     1100: { x: [0, 50, 100], y: [0, 6, 11] },
   };
-  normalizeCurveSection(section, 'm3/h', 'm3/h', 'mbar', 'mbar', 'nq', logger);
+  normalizeCurveSection(section, policy, 'm3/h', 'm3/h', 'mbar', 'mbar', 'nq', logger);
   assert.equal(logger.warns.filter((w) => /Curve anomaly/.test(w)).length, 0);
 });
 
 test('normalizeCurveSection: throws when x/y length mismatch', () => {
+  const policy = makePolicy();
   assert.throws(
-    () => normalizeCurveSection({ 1000: { x: [0, 50], y: [0, 5, 10] } }, 'm3/h', 'm3/s', 'mbar', 'Pa', 'nq', null),
+    () => normalizeCurveSection({ 1000: { x: [0, 50], y: [0, 5, 10] } }, policy, 'm3/h', 'm3/s', 'mbar', 'Pa', 'nq', null),
     /Invalid nq section/
   );
 });
-
-test('convertUnitValue: identity when units match or missing', () => {
-  assert.equal(convertUnitValue(42, 'm3/h', 'm3/h'), 42);
-  assert.equal(convertUnitValue(42, null, null), 42);
-});
-
-test('convertUnitValue: throws on non-finite input', () => {
-  assert.throws(() => convertUnitValue('not-a-number', 'm3/h', 'm3/s', 'test'), /not finite/);
-});

test/basic/flowController.basic.test.js

@@ -27,6 +27,10 @@ function makeHost({
     unitPolicy: {
       canonical: { flow: 'm3/s' },
       output:    { flow: 'm3/h' },
+      convert: (val, from, to, label) => {
+        host.calls.convertUnit.push({ val, from, to, label });
+        return val * 1000; // pretend m3/h -> m3/s factor
+      },
     },
     isValidActionForMode: (action) => allowedActions.has(action),
     isValidSourceForMode: () => allowedSources,
@@ -38,10 +42,6 @@ function makeHost({
       return { moved: sp };
     },
     calcCtrl: (canonicalFlow) => { host.calls.calcCtrl.push(canonicalFlow); return canonicalFlow / 2; },
-    _convertUnitValue: (val, from, to, label) => {
-      host.calls.convertUnit.push({ val, from, to, label });
-      return val * 1000; // pretend m3/h -> m3/s factor
-    },
   };
   return host;
 }

test/edge/output-format.edge.test.js

@@ -36,6 +36,31 @@ test('getOutput contains all required fields in idle state', () => {
   assert.ok('pressureDriftFlags' in output);
 });
 
+test('getOutput seeds operating-point flow/power telemetry at boot (idle = 0, not absent)', () => {
+  // Regression: an idle-from-boot machine must still emit the operating-point
+  // series so dashboards can show the off/0 state. These keys are otherwise
+  // only written once the pump runs (calcFlow/calcPower) or on a state
+  // transition, leaving them absent in telemetry for a pump that never starts.
+  const machine = new Machine(makeMachineConfig(), makeStateConfig());
+  const output = machine.getOutput();
+
+  const hasPrefix = (p) => Object.keys(output).some((k) => k.startsWith(p));
+  const valueFor = (p) => output[Object.keys(output).find((k) => k.startsWith(p))];
+
+  for (const prefix of [
+    'flow.predicted.downstream',
+    'flow.predicted.atequipment',
+    'power.predicted.atequipment',
+  ]) {
+    assert.ok(hasPrefix(prefix), `${prefix}.* must be present at boot (idle)`);
+    assert.equal(valueFor(prefix), 0, `${prefix}.* should be 0 while idle`);
+  }
+
+  // The envelope keys remain present too.
+  assert.ok(hasPrefix('flow.predicted.max'));
+  assert.ok(hasPrefix('flow.predicted.min'));
+});
+
 test('getOutput flow drift fields appear after sufficient measured flow samples', async () => {
   const machine = new Machine(makeMachineConfig(), makeStateConfig());