@machinemetrics/io-adapter-lib 2.35.1 → 2.36.0

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [2.36.0]
+- Added if / else-if / else branch transform
+
 ## [2.35.1]
 - Fixed value-increase and value-decrease to not emit true when coming back from UNAVAILABLE
 - Behavior change: value-decrease does not emit true on start

package/lib/config/branchPreprocessor.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('./configError');
+
+const BRANCH_KEYS = ['if', 'else-if', 'else'];
+
+function isBranchKey(key) {
+  return BRANCH_KEYS.includes(key);
+}
+
+function getBranchKey(item) {
+  if (!_.isObject(item) || _.isArray(item)) {
+    return null;
+  }
+  const keys = _.keys(item);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const key = keys[0];
+  return isBranchKey(key) ? key : null;
+}
+
+/**
+ * Preprocesses a variable's transform list to collapse consecutive if/else-if/else
+ * into a single branch transform. The user-facing YAML syntax allows:
+ *
+ *   - if:
+ *     - condition: this == 1
+ *     - op1
+ *   - else-if:
+ *     - condition: this == 2
+ *     - op1
+ *   - else:
+ *     - op1
+ *
+ * This gets rewritten to:
+ *
+ *   - branch:
+ *     - if: [...]
+ *     - else-if: [...]
+ *     - else: [...]
+ */
+function preprocessBranchTransforms(transformList, sectionPath) {
+  if (!_.isArray(transformList)) {
+    return transformList;
+  }
+
+  const result = [];
+  let i = 0;
+
+  while (i < transformList.length) {
+    const key = getBranchKey(transformList[i]);
+
+    if (key !== 'if') {
+      result.push(transformList[i]);
+      i += 1;
+    } else {
+      const branchComponents = [];
+      let seenElse = false;
+
+      while (i < transformList.length) {
+        const currentKey = getBranchKey(transformList[i]);
+
+        if (currentKey === null) {
+          break;
+        }
+
+        if (currentKey === 'if') {
+          if (branchComponents.length > 0) {
+            break;
+          }
+          const item = transformList[i];
+          const body = item[currentKey];
+          const condition = body[0];
+          const chainTransforms = preprocessBranchTransforms(body.slice(1), `${sectionPath}.${i}.if`);
+          branchComponents.push({ [currentKey]: [condition, ...chainTransforms] });
+          i += 1;
+        } else if (currentKey === 'else-if') {
+          if (branchComponents.length === 0) {
+            throw new ConfigError('else-if must follow if or else-if')
+              .atPath(sectionPath);
+          }
+          if (seenElse) {
+            throw new ConfigError('else-if cannot follow else')
+              .atPath(sectionPath);
+          }
+          const item = transformList[i];
+          const body = item[currentKey];
+          const condition = body[0];
+          const chainTransforms = preprocessBranchTransforms(body.slice(1), `${sectionPath}.${i}.else-if`);
+          branchComponents.push({ [currentKey]: [condition, ...chainTransforms] });
+          i += 1;
+        } else if (currentKey === 'else') {
+          if (branchComponents.length === 0) {
+            throw new ConfigError('else must follow if or else-if')
+              .atPath(sectionPath);
+          }
+          if (seenElse) {
+            throw new ConfigError('only one else allowed per branch')
+              .atPath(sectionPath);
+          }
+          seenElse = true;
+          const item = transformList[i];
+          const body = item[currentKey];
+          const chainTransforms = preprocessBranchTransforms(body, `${sectionPath}.${i}.else`);
+          branchComponents.push({ [currentKey]: chainTransforms });
+          i += 1;
+        } else {
+          break;
+        }
+      }
+
+      result.push({ branch: branchComponents });
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  preprocessBranchTransforms,
+};

package/lib/config/engineConfigV2.js

@@ -3,6 +3,7 @@
 const _ = require('lodash');
 const ConfigError = require('./configError');
 const TransformConfigUtil = require('./transformConfigUtil');
+const { preprocessBranchTransforms } = require('./branchPreprocessor');
 
 class EngineConfig {
   constructor(expressionService, config = {}, device = {}) {
@@ -48,6 +49,10 @@ class EngineConfig {
       return variable;
     });
 
+    this.config.variables = _.mapValues(this.config.variables, (variable, name) => {
+      return preprocessBranchTransforms(variable, `variables.${name}`);
+    });
+
     _.each(this.getExpressions(this.config), name => expressionService.addExpression(name));
     _.each(this.getStringExpressions(this.config), name => expressionService.addStringExpression(name));
   }

package/lib/expressionService.js

@@ -259,7 +259,7 @@ class ExpressionService {
           if (tokens) {
             const first = tokens[0];
             if (first === 'this' || this.channelsLookup[first]) {
-              accum[first] = _.reduceRight(_.tail(tokens), (sub, item) => {
+              const nested = _.reduceRight(_.tail(tokens), (sub, item) => {
                 if (_.isNumber(item)) {
                   return [
                     ..._.times(Math.max(0, item - 1), () => 0),
@@ -268,6 +268,11 @@ class ExpressionService {
                 }
                 return { [item]: sub };
               }, 0);
+              if (_.isArray(nested) || _.isArray(accum[first])) {
+                accum[first] = nested;
+              } else {
+                accum[first] = _.merge(accum[first] || {}, nested);
+              }
             } else {
               accum[first] = 0;
             }

package/lib/transform/branch.js

@@ -0,0 +1,274 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+class BranchChain {
+  constructor(chain) {
+    this.chain = chain;
+    this.opResult = null;
+
+    const end = this.chain.chainEnd();
+    end.on('update', (value) => {
+      this.opResult = value;
+    });
+    end.on('unavailable', () => {
+      this.opResult = null;
+    });
+  }
+
+  update(context, value, time) {
+    this.chain.update(context, value, time);
+    return this.opResult;
+  }
+
+  probe(context, time) {
+    this.chain.probe(context, time);
+  }
+
+  probeOrForward(context, time) {
+    this.chain.probeOrForward(context, time);
+  }
+
+  setUnavailable(context, time) {
+    this.chain.setUnavailable(context, time);
+  }
+}
+
+/**
+ * Conditional branching transform. Evaluates conditions in sequence and runs the first
+ * matching branch's transform chain. Analogous to if/else-if/else.
+ *
+ * Config format (after preprocessing):
+ *   - branch:
+ *     - if:
+ *       - condition: this == 1 or x > y
+ *       - op1
+ *       - op2
+ *     - else-if:
+ *       - condition: this == 2
+ *       - op1
+ *     - else:
+ *       - op1
+ */
+class BranchFilter extends TransformState {
+  constructor({ engine, args: { conditions, branchChains, elseChain } }, builder) {
+    super();
+
+    this.engine = engine;
+    this.conditions = conditions;
+    this.branchChains = _.map(branchChains, (transforms) => {
+      const chain = builder.createTransformChain(engine, transforms);
+      return new BranchChain(chain);
+    });
+    this.elseChain = elseChain
+      ? new BranchChain(builder.createTransformChain(engine, elseChain))
+      : null;
+  }
+
+  static op = 'branch';
+
+  static create(args) {
+    return new BranchFilter(args, args.builder);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const components = defn.args;
+    if (!_.isArray(components)) {
+      configUtil.throwConfigError('branch must contain a list of if/else-if/else components', this.op);
+    }
+
+    const conditions = [];
+    const branchChains = [];
+    let elseChain = null;
+    let lastWasConditional = false;
+
+    components.forEach((comp, i) => {
+      if (!_.isObject(comp) || _.isArray(comp)) {
+        configUtil.throwConfigError('Invalid branch component', this.op);
+      }
+
+      const key = _.first(_.keys(comp));
+      const body = comp[key];
+
+      if (!_.isArray(body)) {
+        configUtil.throwConfigError(`${key} must contain a list of transforms`, this.op);
+      }
+
+      if (key === 'if' || key === 'else-if') {
+        if (body.length === 0) {
+          configUtil.throwConfigError(`${key} must have at least a condition`, this.op);
+        }
+
+        const first = body[0];
+        let conditionExpr = null;
+        if (_.isObject(first) && !_.isArray(first) && _.has(first, 'condition')) {
+          conditionExpr = first.condition;
+          if (_.isObject(conditionExpr) && _.has(conditionExpr, 'expression')) {
+            conditionExpr = conditionExpr.expression;
+          }
+          conditionExpr = conditionExpr.toString();
+        }
+
+        if (!conditionExpr) {
+          configUtil.throwConfigError(`${key} first element must be condition: <expression>`, this.op);
+        }
+
+        const compiledExpression = configUtil.compileExpression(conditionExpr, this.op, { this: 0 });
+        conditions.push({
+          expression: conditionExpr,
+          compiledExpression,
+          expressionSources: configUtil.expressionService.expressionTriggers(`${defn.path}.${i}.condition`),
+          hasThis: configUtil.expressionService.findName(conditionExpr, 'this'),
+          sourceCache: {},
+        });
+
+        const chainTransforms = body.slice(1);
+        const { transform } = configUtil.loadTransformList(chainTransforms, `${defn.path}.${i}.${key}`, false);
+        branchChains.push(transform);
+        lastWasConditional = true;
+      } else if (key === 'else') {
+        if (!lastWasConditional) {
+          configUtil.throwConfigError('else must follow if or else-if', this.op);
+        }
+        if (elseChain !== null) {
+          configUtil.throwConfigError('only one else allowed per branch', this.op);
+        }
+
+        const { transform } = configUtil.loadTransformList(body, `${defn.path}.${i}.else`, false);
+        elseChain = transform;
+        lastWasConditional = false;
+      } else {
+        configUtil.throwConfigError(`Unknown branch component: ${key}`, this.op);
+      }
+    });
+
+    defn.args = {
+      conditions,
+      branchChains,
+      elseChain,
+    };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    const { varName, index, attribute } = info;
+    const parts = [];
+
+    if (!_.isArray(body)) {
+      return [];
+    }
+
+    _.each(body, (comp, compIndex) => {
+      if (!_.isObject(comp) || _.isArray(comp)) {
+        return;
+      }
+
+      const key = _.first(_.keys(comp));
+      const compBody = comp[key];
+
+      if (key === 'if' || key === 'else-if') {
+        if (_.isArray(compBody) && compBody.length > 0) {
+          const first = compBody[0];
+          if (_.isObject(first) && _.has(first, 'condition')) {
+            const expr = first.condition?.toString?.() ?? first.condition;
+            if (expr) {
+              parts.push({
+                path: `variables.${varName}.${index}.${attribute}.${compIndex}.condition`,
+                expression: expr,
+              }, {
+                path: `variables.${varName}`,
+                expression: expr,
+              });
+            }
+          }
+        }
+      }
+
+      if (key === 'if' || key === 'else-if' || key === 'else') {
+        const chainTransforms = key === 'else'
+          ? compBody
+          : compBody.slice(1);
+        const normalized = _.map(chainTransforms, (t) => (_.isString(t) ? { [t]: [] } : t));
+        // Include key (if/else-if/else) so expression paths match loadTransformList (used by parseConfig)
+        const chainVarName = `${varName}.${index}.${attribute}.${compIndex}.${key}`;
+        const chainExprs = configUtil.getExpressionsFromChain(
+          normalized,
+          chainVarName,
+          [...(info.ancestorVars || []), varName]
+        );
+        parts.push(..._.flatten(chainExprs));
+      }
+    });
+
+    return parts;
+  }
+
+  supportsPendingChanges() {
+    const chains = [...this.branchChains, this.elseChain].filter(Boolean);
+    return _.some(chains, (c) => c.chain.chainSupportsPendingChange?.());
+  }
+
+  selectBranch(context, value, time) {
+    for (let i = 0; i < this.conditions.length; i += 1) {
+      const rule = this.conditions[i];
+
+      if (rule.hasThis) {
+        rule.sourceCache.this = value;
+      }
+
+      const unavailTerm = _.reduce(rule.expressionSources, (res, name) => {
+        const state = this.engine.getState(name);
+        if (state) {
+          rule.sourceCache[name] = state.value;
+        }
+        return res || !state || !state.available;
+      }, false);
+
+      if (unavailTerm) {
+        return -1;
+      }
+
+      try {
+        if (rule.compiledExpression.evaluate(rule.sourceCache)) {
+          return i;
+        }
+      } catch (err) {
+        this.recordError(context, err, time);
+      }
+    }
+
+    return this.elseChain !== null ? this.conditions.length : -1;
+  }
+
+  update(context, value, time) {
+    if (value === 'UNAVAILABLE') {
+      this.setUnavailable(context, time);
+    } else {
+      super.update(context, value, time);
+    }
+  }
+
+  filter(context, value, time) {
+    const branchIndex = this.selectBranch(context, value, time);
+
+    if (branchIndex < 0) {
+      this.commitValue(context, value, time);
+      return;
+    }
+
+    const chain = branchIndex < this.branchChains.length ? this.branchChains[branchIndex] : this.elseChain;
+
+    const result = chain.update(context, value, time);
+    if (result !== null && result !== undefined) {
+      this.commitValue(context, result, time);
+    } else {
+      this.setUnavailable(context, time);
+    }
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+  }
+}
+
+module.exports = BranchFilter;

package/lib/transform/index.js

@@ -2,6 +2,7 @@
 
 const AccumulateFilter = require('./accumulate');
 const AverageFilter = require('./average');
+const BranchFilter = require('./branch');
 const DebounceFilter = require('./debounce');
 const DownsampleFilter = require('./downsample');
 const EdgeFilter = require('./edge');
@@ -48,6 +49,7 @@ const WindowCountFilter = require('./windowCount');
 module.exports = {
   accumulate: AccumulateFilter,
   average: AverageFilter,
+  branch: BranchFilter,
   debounce: DebounceFilter,
   downsample: DownsampleFilter,
   edge: EdgeFilter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machinemetrics/io-adapter-lib",
-  "version": "2.35.1",
+  "version": "2.36.0",
   "description": "Configuration and engine implementation for MachineMetrics AdapterScripts and adapters",
   "main": "index.js",
   "license": "UNLICENSED",

package/test/configFiles/transform/branch.yml

@@ -0,0 +1,117 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+  - x
+  - y
+  - z
+  - obj
+variables:
+  branch1:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else-if:
+      - condition: this == 2
+      - expression: 200
+    - else:
+      - expression: 0
+  branch2simple:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 10
+    - else:
+      - expression: 0
+  branch3:
+    - source: counter
+    - if:
+      - condition: x > y
+      - expression: 1
+    - else-if:
+      - condition: x < y
+      - expression: -1
+    - else:
+      - expression: 0
+  ifOnly:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+  ifElseIf:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else-if:
+      - condition: this == 2
+      - expression: 200
+  twoElseIfs:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 10
+    - else-if:
+      - condition: this == 2
+      - expression: 20
+    - else-if:
+      - condition: this == 3
+      - expression: 30
+    - else:
+      - expression: 0
+  ifElseIfConsecutive:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else:
+      - expression: 2
+    - if:
+      - condition: counter == 2
+      - expression: 200
+  branchWithThis:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else:
+      - expression: this
+  branchUnavailable:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: x + 1
+    - else:
+      - expression: this
+  branchWithInnerVar:
+    - source: counter
+    - if:
+      - condition: obj.a > 5
+      - expression: obj.a
+    - else:
+      - expression: obj.b
+  nested:
+    - source: counter
+    - if:
+      - condition: this > 0
+      - if:
+        - condition: this > 2
+        - expression: z
+      - else:
+        - expression: y
+    - else:
+      - expression: x
+  nestedInnerVar:
+    - source: counter
+    - if:
+      - condition: this > 0
+      - if:
+        - condition: obj.a > obj.b
+        - expression: obj.a + obj.b
+      - else:
+        - expression: y
+    - else:
+      - expression: x

package/test/configFiles/transform/invalid-branch-else-only.yml

@@ -0,0 +1,11 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - else:
+      - expression: 0

package/test/configFiles/transform/invalid-branch-elseif-no-condition.yml

@@ -0,0 +1,14 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else-if:
+      - expression: 200

package/test/configFiles/transform/invalid-branch-elseif-only.yml

@@ -0,0 +1,12 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - else-if:
+      - condition: this == 1
+      - expression: 100

package/test/configFiles/transform/invalid-branch-if-no-condition.yml

@@ -0,0 +1,11 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - if:
+      - expression: 100

package/test/configFiles/transform/invalid-branch-unrelated-op.yml

@@ -0,0 +1,18 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - invert
+    - else-if:
+      - condition: this == 2
+      - expression: 200
+    - else:
+      - expression: 0

package/test/transform/branch-invalid.test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const expect = require('chai').expect;
+const ConfigError = require('../../lib/config/configError');
+const testUtils = require('../util/testUtils');
+
+describe('branch transform invalid config tests', function () {
+  it('rejects else by itself', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-else-only.yml');
+      expect.fail('Config with else by itself should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('else');
+    }
+  });
+
+  it('rejects else-if by itself', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-elseif-only.yml');
+      expect.fail('Config with else-if by itself should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('else-if');
+    }
+  });
+
+  it('rejects if without condition as first transform', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-if-no-condition.yml');
+      expect.fail('Config with if without condition should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('condition');
+    }
+  });
+
+  it('rejects else-if without condition as first transform', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-elseif-no-condition.yml');
+      expect.fail('Config with else-if without condition should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('condition');
+    }
+  });
+
+  it('rejects unrelated op between if/else-if/else', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-unrelated-op.yml');
+      expect.fail('Config with unrelated op between if/else-if/else should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.match(/else-if|else|Unsupported/);
+    }
+  });
+});

package/test/transform/branch.test.js

@@ -0,0 +1,357 @@
+'use strict';
+
+const expect = require('chai').expect;
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('branch transform tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/branch.yml');
+  });
+
+  it('selects if branch when condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch1, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [100, 0],
+    ]);
+  });
+
+  it('selects else-if branch when condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch1, source);
+
+    source.sendValue('counter', 2, 0);
+
+    engine.validateFilter([
+      [200, 0],
+    ]);
+  });
+
+  it('selects else branch when no condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch1, source);
+
+    source.sendValue('counter', 5, 0);
+
+    engine.validateFilter([
+      [0, 0],
+    ]);
+  });
+
+  it('evaluates constant expression in branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch2simple, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [10, 0],
+    ]);
+  });
+
+  it('uses external variables in conditions', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch3, source);
+
+    source.sendValue('x', 10, 0);
+    source.sendValue('y', 5, 0);
+    source.sendValue('counter', 0, 0);
+
+    engine.validateFilter([
+      [1, 0],
+    ]);
+  });
+
+  it('selects else-if when x < y', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch3, source);
+
+    source.sendValue('x', 5, 0);
+    source.sendValue('y', 10, 0);
+    source.sendValue('counter', 0, 0);
+
+    engine.validateFilter([
+      [-1, 0],
+    ]);
+  });
+
+  it('selects else when x == y', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch3, source);
+
+    source.sendValue('x', 5, 0);
+    source.sendValue('y', 5, 0);
+    source.sendValue('counter', 0, 0);
+
+    engine.validateFilter([
+      [0, 0],
+    ]);
+  });
+
+  it('if only: selects branch when condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifOnly, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [100, 0],
+    ]);
+  });
+
+  it('if only: passes through when condition does not match', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifOnly, source);
+
+    source.sendValue('counter', 5, 0);
+
+    engine.validateFilter([
+      [5, 0],
+    ]);
+  });
+
+  it('if/else-if without else: selects first branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIf, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [100, 0],
+    ]);
+  });
+
+  it('if/else-if without else: selects second branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIf, source);
+
+    source.sendValue('counter', 2, 0);
+
+    engine.validateFilter([
+      [200, 0],
+    ]);
+  });
+
+  it('if/else-if without else: passes through when neither matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIf, source);
+
+    source.sendValue('counter', 5, 0);
+
+    engine.validateFilter([
+      [5, 0],
+    ]);
+  });
+
+  it('two else-ifs: selects each branch correctly', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.twoElseIfs, source);
+
+    source.sendValue('counter', 1, 0);
+    source.sendValue('counter', 2, 1);
+    source.sendValue('counter', 3, 2);
+    source.sendValue('counter', 5, 3);
+
+    engine.validateFilter([[10, 0], [20, 1], [30, 2], [0, 3]]);
+  });
+
+  it('if/else/if: two consecutive branches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIfConsecutive, source);
+
+    source.sendValue('counter', 1, 0);
+    source.sendValue('counter', 2, 1);
+    source.sendValue('counter', 3, 2);
+
+    engine.validateFilter([[100, 0], [200, 1], [2, 2]]);
+  });
+
+  it('expression: this in else branch passes through input value', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branchWithThis, source);
+
+    source.sendValue('counter', 1, 0);
+    source.sendValue('counter', 5, 1);
+
+    engine.validateFilter([[100, 0], [5, 1]]);
+  });
+
+  it('unavailable in taken branch propagates; unavailable in not-taken branch has no effect', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    engine.addValueSource(source);
+
+    const filterUpdates = [];
+    const endFilter = engine.variablePool.branchUnavailable.chainEnd();
+    endFilter.on('update', (value, time) => {
+      filterUpdates.push({ time, value });
+    });
+    endFilter.on('unavailable', (time) => {
+      filterUpdates.push({ time, value: 'UNAVAILABLE' });
+    });
+
+    const expectFilter = (expected) => {
+      const ref = expected.map(([value, time]) => ({ time, value }));
+      expect(filterUpdates.length).to.eq(ref.length);
+      ref.forEach((r, i) => {
+        expect(filterUpdates[i].time).to.be.closeTo(r.time, 0.000001);
+        expect(filterUpdates[i].value).to.deep.eq(r.value);
+      });
+    };
+
+    source.sendValue('x', 10, 0);
+    source.sendValue('counter', 1, 0);
+    source.sendValue('x', 'UNAVAILABLE', 1);
+    source.sendValue('counter', 5, 2);
+    source.sendValue('x', 'UNAVAILABLE', 2);
+
+    expectFilter([['UNAVAILABLE', 0], [11, 0], ['UNAVAILABLE', 1], ['UNAVAILABLE', 1], [5, 2]]);
+  });
+
+  it('nested if/else inside branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.nested, source);
+
+    source.sendValue('x', 0, 0);
+    source.sendValue('y', 150, 0);
+    source.sendValue('z', 200, 0);
+
+    source.sendValue('counter', 0, 0);
+    source.sendValue('counter', 1, 1);
+    source.sendValue('counter', 2, 2);
+    source.sendValue('counter', 3, 3);
+
+    engine.validateFilter([[0, 0], [150, 1], [150, 2], [200, 3]]);
+  });
+
+  it('nested branch re-evaluates when expression variable in taken path updates', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.nested, source);
+
+    source.sendValue('x', 0, 0);
+    source.sendValue('y', 150, 0);
+    source.sendValue('z', 200, 0);
+
+    source.sendValue('counter', 0, 0);
+    source.sendValue('x', 1, 1);
+    source.sendValue('counter', 1, 2);
+    source.sendValue('y', 151, 3);
+    source.sendValue('counter', 3, 4);
+    source.sendValue('z', 201, 5);
+
+    engine.validateFilter([[0, 0], [1, 1], [150, 2], [151, 3], [200, 4], [201, 5]]);
+  });
+
+  it('branchWithInnerVar selects branch by obj.a and emits obj.a or obj.b', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branchWithInnerVar, source);
+
+    source.sendValue('obj', { a: 10, b: 1 }, 0);
+    source.sendValue('counter', 1, 0);
+    source.sendValue('obj', { a: 3, b: 2 }, 1);
+    source.sendValue('counter', 2, 1);
+
+    engine.validateFilter([[10, 0], [2, 1]]);
+  });
+
+  it('nestedInnerVar selects nested branches by this and obj.a, obj.b', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.nestedInnerVar, source);
+
+    source.sendValue('x', 0, 0);
+    source.sendValue('y', 150, 0);
+    source.sendValue('obj', { a: 10, b: 5 }, 0);
+
+    source.sendValue('counter', 0, 0);
+    source.sendValue('counter', 1, 1);
+    source.sendValue('obj', { a: 3, b: 8 }, 2);
+    source.sendValue('counter', 2, 2);
+
+    engine.validateFilter([[0, 0], [15, 1], [150, 2]]);
+  });
+});