@2112-lab/central-plant 0.3.58 → 0.3.59

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

@@ -0,0 +1,725 @@
+import { createClass as _createClass, toConsumableArray as _toConsumableArray, slicedToArray as _slicedToArray, createForOfIteratorHelper as _createForOfIteratorHelper, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * @file stateEngine.js
+ * @description Portable State Engine core — registry, desired/effective resolution,
+ * plant (and later group) gates, change notifications. No Vue/Three.js.
+ *
+ * Phase 1 scaffold per STATE_ENGINE_FRAMEWORK_0.3.md / milestones doc.
+ */
+
+/**
+ * @typedef {'desired' | 'effective'} StateLayer
+ */
+
+/**
+ * Build a scoped registry address.
+ * @param {string} scope - e.g. "plant", "group:chiller-loop-a", "pump-001"
+ * @param {string} attribute
+ * @returns {string}
+ */
+function makeAddress(scope, attribute) {
+  return "".concat(scope, "::").concat(attribute);
+}
+
+/**
+ * Shallow equality for registry values (boolean, number, string, null).
+ * @param {*} a
+ * @param {*} b
+ * @returns {boolean}
+ */
+function valuesEqual(a, b) {
+  return Object.is(a, b);
+}
+
+/**
+ * Safe-off value for a gated operational attribute: 0 for numbers, false for
+ * booleans, otherwise the value unchanged.
+ * @param {*} desired
+ * @returns {*}
+ */
+function offValue(desired) {
+  if (typeof desired === 'number') return 0;
+  if (typeof desired === 'boolean') return false;
+  return desired;
+}
+
+/**
+ * Central Plant State Engine (logic only).
+ *
+ * Desired values are stored in the registry. Effective values are computed
+ * from gates (plant / groups / object) without erasing desired.
+ */
+var StateEngine = /*#__PURE__*/function () {
+  /**
+   * @param {object} [options]
+   * @param {number} [options.maxChainDepth=8] - Ripple hop limit (Phase 3)
+   */
+  function StateEngine() {
+    var _options$maxChainDept, _options$gatedOperati;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, StateEngine);
+    /** @type {Map<string, *>} address → desired value */
+    this._desired = new Map();
+
+    /** @type {Map<string, Set<string>>} groupId → member object ids */
+    this._groupMembers = new Map();
+
+    /** @type {Map<string, *>} groupId → group desired power (and later other attrs) */
+    this._groupDesired = new Map();
+
+    /** @type {boolean} */
+    this._plantPowerDesired = true;
+
+    /** @type {Set<(change: { address: string, desired: *, effective: * }) => void>} */
+    this._listeners = new Set();
+
+    /** @type {number} */
+    this.maxChainDepth = (_options$maxChainDept = options.maxChainDepth) !== null && _options$maxChainDept !== void 0 ? _options$maxChainDept : 8;
+
+    /**
+     * Operational attributes that read a safe-off value when their object's
+     * power is not effectively on (Framework §6/§10: fan level 5 + plant off → 0).
+     * Passive/meta attributes stay ungated.
+     * @type {Set<string>}
+     */
+    this._gatedOperationalAttributes = new Set((_options$gatedOperati = options.gatedOperationalAttributes) !== null && _options$gatedOperati !== void 0 ? _options$gatedOperati : ['fan-level', 'rpm', 'level', 'speed']);
+
+    /** @type {Array<object>} declared chains (Phase 3) */
+    this._chains = [];
+
+    /** @type {boolean} */
+    this._batching = false;
+
+    /** @type {Map<string, { address: string, desired: *, effective: * }>} */
+    this._pendingNotifications = new Map();
+  }
+
+  // ─── Load / reset ─────────────────────────────────────────────────────────
+
+  /**
+   * Load plant, groups, and initial desired values from a scene-like declaration.
+   * @param {object} declaration
+   * @param {object} [declaration.plant]
+   * @param {object} [declaration.groups]
+   * @param {object} [declaration.stateRegistry]
+   * @param {Array<object>} [declaration.chains]
+   */
+  return _createClass(StateEngine, [{
+    key: "load",
+    value: function load() {
+      var _declaration$plant;
+      var declaration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this._desired.clear();
+      this._groupMembers.clear();
+      this._groupDesired.clear();
+      this._chains = Array.isArray(declaration.chains) ? _toConsumableArray(declaration.chains) : [];
+      var plantDefault = ((_declaration$plant = declaration.plant) === null || _declaration$plant === void 0 || (_declaration$plant = _declaration$plant.states) === null || _declaration$plant === void 0 || (_declaration$plant = _declaration$plant.power) === null || _declaration$plant === void 0 ? void 0 : _declaration$plant.default) !== undefined ? declaration.plant.states.power.default : true;
+      this._plantPowerDesired = Boolean(plantDefault);
+      this._desired.set(makeAddress('plant', 'power'), this._plantPowerDesired);
+      var groups = declaration.groups || {};
+      for (var _i = 0, _Object$entries = Object.entries(groups); _i < _Object$entries.length; _i++) {
+        var _group$states;
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          groupId = _Object$entries$_i[0],
+          group = _Object$entries$_i[1];
+        var members = Array.isArray(group.members) ? group.members : [];
+        this._groupMembers.set(groupId, new Set(members));
+        var groupPower = ((_group$states = group.states) === null || _group$states === void 0 || (_group$states = _group$states.power) === null || _group$states === void 0 ? void 0 : _group$states.default) !== undefined ? group.states.power.default : true;
+        this._groupDesired.set(groupId, Boolean(groupPower));
+        this._desired.set(makeAddress("group:".concat(groupId), 'power'), Boolean(groupPower));
+      }
+      var registry = declaration.stateRegistry || {};
+      for (var _i2 = 0, _Object$entries2 = Object.entries(registry); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          address = _Object$entries2$_i[0],
+          value = _Object$entries2$_i[1];
+        this._desired.set(address, value);
+        if (address === makeAddress('plant', 'power')) {
+          this._plantPowerDesired = Boolean(value);
+        }
+        var groupMatch = /^group:([^:]+)::power$/.exec(address);
+        if (groupMatch) {
+          this._groupDesired.set(groupMatch[1], Boolean(value));
+        }
+      }
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this._desired.clear();
+      this._groupMembers.clear();
+      this._groupDesired.clear();
+      this._chains = [];
+      this._plantPowerDesired = true;
+      this._pendingNotifications.clear();
+      this._batching = false;
+    }
+
+    // ─── Desired / effective ──────────────────────────────────────────────────
+
+    /**
+     * @param {string} address
+     * @returns {*}
+     */
+  }, {
+    key: "getDesired",
+    value: function getDesired(address) {
+      return this._desired.has(address) ? this._desired.get(address) : undefined;
+    }
+
+    /**
+     * Compute effective value for an address.
+     * Power-style gates: plant AND all containing groups AND object desired.
+     * Non-power attributes: return desired when power gates allow, else a safe off value.
+     *
+     * @param {string} address
+     * @returns {*}
+     */
+  }, {
+    key: "getEffective",
+    value: function getEffective(address) {
+      var desired = this.getDesired(address);
+      if (desired === undefined) return undefined;
+      if (address === makeAddress('plant', 'power')) {
+        return Boolean(desired);
+      }
+      var groupPowerMatch = /^group:([^:]+)::power$/.exec(address);
+      if (groupPowerMatch) {
+        return this._plantPowerDesired && Boolean(desired);
+      }
+      var objectPowerMatch = /^([^:]+)::power$/.exec(address);
+      if (objectPowerMatch && !address.startsWith('group:') && !address.startsWith('plant::')) {
+        var objectId = objectPowerMatch[1];
+        // Skip nested I/O addresses like pump-001::start-switch::mode
+        if (address.split('::').length !== 2) {
+          return desired;
+        }
+        return this._isPowerAllowedForObject(objectId) && Boolean(desired);
+      }
+
+      // Flow and other attrs: when tied to an object id prefix, gate on that object's power path
+      var parts = address.split('::');
+      if (parts.length === 2) {
+        var _parts = _slicedToArray(parts, 2),
+          _objectId = _parts[0],
+          attribute = _parts[1];
+        if (attribute === 'flow') {
+          var powerAllowed = this._isPowerAllowedForObject(_objectId);
+          if (!powerAllowed) return false;
+          return Boolean(desired);
+        }
+        // Operational values (fan level, rpm, …) collapse to a safe-off value when
+        // the object's power is not effectively on; restored when power returns (§6, §10).
+        if (this._gatedOperationalAttributes.has(attribute)) {
+          if (!this._isPowerAllowedForObject(_objectId)) return offValue(desired);
+          return desired;
+        }
+      }
+      return desired;
+    }
+
+    /**
+     * @param {string} objectId
+     * @returns {boolean}
+     */
+  }, {
+    key: "_isPowerAllowedForObject",
+    value: function _isPowerAllowedForObject(objectId) {
+      if (!this._plantPowerDesired) return false;
+      var _iterator = _createForOfIteratorHelper(this._groupMembers),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            groupId = _step$value[0],
+            members = _step$value[1];
+          if (members.has(objectId)) {
+            var groupOn = this._groupDesired.get(groupId);
+            if (!groupOn) return false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return true;
+    }
+
+    /**
+     * Groups that contain an object.
+     * @param {string} objectId
+     * @returns {string[]}
+     */
+  }, {
+    key: "getGroupsForObject",
+    value: function getGroupsForObject(objectId) {
+      var result = [];
+      var _iterator2 = _createForOfIteratorHelper(this._groupMembers),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            groupId = _step2$value[0],
+            members = _step2$value[1];
+          if (members.has(objectId)) result.push(groupId);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return result;
+    }
+
+    // ─── Writes ───────────────────────────────────────────────────────────────
+
+    /**
+     * Set a desired value through the single write door and run one bounded
+     * propagation pass: no-op stop, gate recompute, declared chains with depth
+     * and visited-set guards, then batched notifications (Framework §11, §12).
+     *
+     * @param {string} address
+     * @param {*} value
+     * @returns {boolean} true if the desired value changed
+     */
+  }, {
+    key: "setDesired",
+    value: function setDesired(address, value) {
+      this._beginBatch();
+      var ctx = {
+        visited: new Map()
+      };
+      var changed = this._writeHop(address, value, 0, ctx);
+      this._endBatch();
+      return changed;
+    }
+
+    /**
+     * One hop of a propagation pass: apply the write, then walk declared chains.
+     * @param {string} address
+     * @param {*} value
+     * @param {number} depth
+     * @param {{ visited: Map<string, *> }} ctx
+     * @returns {boolean} whether this hop changed the desired value
+     */
+  }, {
+    key: "_writeHop",
+    value: function _writeHop(address, value, depth, ctx) {
+      var result = this._applyWrite(address, value, ctx);
+      if (!result.changed) return false;
+      this._walkChains(result, depth, ctx);
+      return true;
+    }
+
+    /**
+     * Atomic write door: no-op stop (§11.1), visited-set cycle guard (§11.5),
+     * store desired, update gate mirrors, compute which effectives changed, and
+     * queue notifications for changed addresses only.
+     *
+     * @param {string} address
+     * @param {*} value
+     * @param {{ visited: Map<string, *> }} ctx
+     * @returns {{ changed: boolean, desiredChanged?: string, effectiveChanged?: Set<string> }}
+     */
+  }, {
+    key: "_applyWrite",
+    value: function _applyWrite(address, value, ctx) {
+      var previous = this.getDesired(address);
+      if (previous !== undefined && valuesEqual(previous, value)) {
+        return {
+          changed: false
+        }; // §11.1 no-op stop
+      }
+
+      // §11.5 visited-set: writing the same pair a different value this pass = cycle conflict
+      if (ctx.visited.has(address) && !valuesEqual(ctx.visited.get(address), value)) {
+        console.warn("[StateEngine] cycle conflict: ".concat(address, " rewritten to a different value in one pass; stopping branch"));
+        return {
+          changed: false
+        };
+      }
+      ctx.visited.set(address, value);
+
+      // Snapshot effective for every address this write might gate, before mutating.
+      var affected = this._affectedByWrite(address);
+      var before = new Map();
+      var _iterator3 = _createForOfIteratorHelper(affected),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var a = _step3.value;
+          before.set(a, this.getEffective(a));
+        }
+
+        // Store desired + keep plant/group gate mirrors in sync.
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      this._desired.set(address, value);
+      if (address === makeAddress('plant', 'power')) {
+        this._plantPowerDesired = Boolean(value);
+      }
+      var groupMatch = /^group:([^:]+)::power$/.exec(address);
+      if (groupMatch) {
+        this._groupDesired.set(groupMatch[1], Boolean(value));
+      }
+
+      // Which effectives actually changed (§11.4 dedupe: notify once, changed only).
+      var effectiveChanged = new Set();
+      var _iterator4 = _createForOfIteratorHelper(affected),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _a = _step4.value;
+          if (!valuesEqual(before.get(_a), this.getEffective(_a))) effectiveChanged.add(_a);
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      this._queueNotification(address); // desired changed
+      var _iterator5 = _createForOfIteratorHelper(effectiveChanged),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _a2 = _step5.value;
+          if (_a2 !== address) this._queueNotification(_a2);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return {
+        changed: true,
+        desiredChanged: address,
+        effectiveChanged: effectiveChanged
+      };
+    }
+
+    /**
+     * Addresses whose effective value a write to `address` could change: the
+     * address itself, plus gate dependents (all keys for plant power, member
+     * keys for group power).
+     * @param {string} address
+     * @returns {string[]}
+     */
+  }, {
+    key: "_affectedByWrite",
+    value: function _affectedByWrite(address) {
+      var affected = new Set([address]);
+      if (address === makeAddress('plant', 'power')) {
+        var _iterator6 = _createForOfIteratorHelper(this._desired.keys()),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var key = _step6.value;
+            affected.add(key);
+          }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+        return _toConsumableArray(affected);
+      }
+      var groupMatch = /^group:([^:]+)::power$/.exec(address);
+      if (groupMatch) {
+        var members = this._groupMembers.get(groupMatch[1]);
+        if (members) {
+          var _iterator7 = _createForOfIteratorHelper(members),
+            _step7;
+          try {
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var memberId = _step7.value;
+              var _iterator8 = _createForOfIteratorHelper(this._desired.keys()),
+                _step8;
+              try {
+                for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                  var _key = _step8.value;
+                  if (_key.startsWith("".concat(memberId, "::"))) affected.add(_key);
+                }
+              } catch (err) {
+                _iterator8.e(err);
+              } finally {
+                _iterator8.f();
+              }
+            }
+          } catch (err) {
+            _iterator7.e(err);
+          } finally {
+            _iterator7.f();
+          }
+        }
+      }
+      return _toConsumableArray(affected);
+    }
+
+    /**
+     * Walk declared chains triggered by this write (§10, §11.3). Desired-source
+     * chains fire when the trigger's desired changed; effective-source chains fire
+     * when the trigger's effective changed (so plant/group-off ripples through
+     * `pump effective → pipe flow`, §17). Only `copy` is supported.
+     *
+     * @param {{ desiredChanged?: string, effectiveChanged?: Set<string> }} result
+     * @param {number} depth
+     * @param {{ visited: Map<string, *> }} ctx
+     */
+  }, {
+    key: "_walkChains",
+    value: function _walkChains(result, depth, ctx) {
+      if (this._chains.length === 0) return;
+      var _iterator9 = _createForOfIteratorHelper(this._chains),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _result$effectiveChan;
+          var chain = _step9.value;
+          if (chain.action && chain.action !== 'copy') continue;
+          var trigger = makeAddress(chain.when.address, chain.when.attribute);
+          var useEffective = chain.when.source === 'effective';
+          var fires = useEffective ? (_result$effectiveChan = result.effectiveChanged) === null || _result$effectiveChan === void 0 ? void 0 : _result$effectiveChan.has(trigger) : result.desiredChanged === trigger;
+          if (!fires) continue;
+          if (depth + 1 > this.maxChainDepth) {
+            var _chain$id;
+            console.warn("[StateEngine] ripple depth limit (".concat(this.maxChainDepth, ") reached at chain ") + "\"".concat((_chain$id = chain.id) !== null && _chain$id !== void 0 ? _chain$id : '<unnamed>', "\" (").concat(trigger, " \u2192 ").concat(makeAddress(chain.set.address, chain.set.attribute), "); stopping path"));
+            continue;
+          }
+          var nextValue = useEffective ? this.getEffective(trigger) : this.getDesired(trigger);
+          var target = makeAddress(chain.set.address, chain.set.attribute);
+          this._writeHop(target, nextValue, depth + 1, ctx);
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+    }
+
+    // ─── Pipe lifecycle (Framework §9, §15) ─────────────────────────────────────
+
+    /**
+     * Register a pipe/path in the registry so its flow state exists and is tied to
+     * pipe lifecycle (no orphan keys). Keyed on the pipe/path id, never on segment
+     * declared/computed status (§9). No-op if already registered.
+     * @param {string} pipeId
+     * @param {object} [options]
+     * @param {boolean} [options.defaultFlow=false]
+     * @returns {string} the flow address
+     */
+  }, {
+    key: "registerPipe",
+    value: function registerPipe(pipeId) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var address = makeAddress(pipeId, 'flow');
+      if (!this._desired.has(address)) {
+        var _options$defaultFlow;
+        this._beginBatch();
+        this._desired.set(address, Boolean((_options$defaultFlow = options.defaultFlow) !== null && _options$defaultFlow !== void 0 ? _options$defaultFlow : false));
+        this._queueNotification(address);
+        this._endBatch();
+      }
+      return address;
+    }
+
+    /**
+     * Remove a pipe and all of its registry entries when the pipe is destroyed, so
+     * keys do not linger (§15). Emits a final notification (desired/effective
+     * undefined) per removed key.
+     * @param {string} pipeId
+     * @returns {number} number of registry keys removed
+     */
+  }, {
+    key: "unregisterPipe",
+    value: function unregisterPipe(pipeId) {
+      var prefix = "".concat(pipeId, "::");
+      var removed = _toConsumableArray(this._desired.keys()).filter(function (k) {
+        return k.startsWith(prefix);
+      });
+      if (removed.length === 0) return 0;
+      this._beginBatch();
+      var _iterator0 = _createForOfIteratorHelper(removed),
+        _step0;
+      try {
+        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+          var key = _step0.value;
+          this._desired.delete(key);
+        }
+      } catch (err) {
+        _iterator0.e(err);
+      } finally {
+        _iterator0.f();
+      }
+      var _iterator1 = _createForOfIteratorHelper(removed),
+        _step1;
+      try {
+        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+          var _key2 = _step1.value;
+          this._queueNotification(_key2);
+        }
+      } catch (err) {
+        _iterator1.e(err);
+      } finally {
+        _iterator1.f();
+      }
+      this._endBatch();
+      return removed.length;
+    }
+  }, {
+    key: "_beginBatch",
+    value: function _beginBatch() {
+      this._batching = true;
+      this._pendingNotifications.clear();
+    }
+  }, {
+    key: "_queueNotification",
+    value: function _queueNotification(address) {
+      var change = {
+        address: address,
+        desired: this.getDesired(address),
+        effective: this.getEffective(address)
+      };
+      if (this._batching) {
+        this._pendingNotifications.set(address, change);
+      } else {
+        this._emit(change);
+      }
+    }
+  }, {
+    key: "_endBatch",
+    value: function _endBatch() {
+      this._batching = false;
+      var changes = _toConsumableArray(this._pendingNotifications.values());
+      this._pendingNotifications.clear();
+      var _iterator10 = _createForOfIteratorHelper(changes),
+        _step10;
+      try {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var change = _step10.value;
+          this._emit(change);
+        }
+      } catch (err) {
+        _iterator10.e(err);
+      } finally {
+        _iterator10.f();
+      }
+    }
+  }, {
+    key: "_emit",
+    value: function _emit(change) {
+      var _iterator11 = _createForOfIteratorHelper(this._listeners),
+        _step11;
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var listener = _step11.value;
+          try {
+            listener(change);
+          } catch (err) {
+            console.error('[StateEngine] listener error:', err);
+          }
+        }
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+    }
+
+    /**
+     * @param {(change: { address: string, desired: *, effective: * }) => void} listener
+     * @returns {() => void} unsubscribe
+     */
+  }, {
+    key: "subscribe",
+    value: function subscribe(listener) {
+      var _this = this;
+      this._listeners.add(listener);
+      return function () {
+        return _this._listeners.delete(listener);
+      };
+    }
+
+    /**
+     * Snapshot of all desired values (for save / debug).
+     * @returns {Record<string, *>}
+     */
+  }, {
+    key: "toRegistry",
+    value: function toRegistry() {
+      var out = {};
+      var _iterator12 = _createForOfIteratorHelper(this._desired),
+        _step12;
+      try {
+        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+          var _step12$value = _slicedToArray(_step12.value, 2),
+            k = _step12$value[0],
+            v = _step12$value[1];
+          out[k] = v;
+        }
+      } catch (err) {
+        _iterator12.e(err);
+      } finally {
+        _iterator12.f();
+      }
+      return out;
+    }
+
+    /**
+     * Reconstruct the §17 scene declaration (plant / groups / chains /
+     * stateRegistry) from current engine state, for scene save. Round-trips with
+     * {@link StateEngine#load}.
+     * @returns {{ version: string, plant: object, groups: object, chains: object[], stateRegistry: Record<string, *> }}
+     */
+  }, {
+    key: "toDeclaration",
+    value: function toDeclaration() {
+      var groups = {};
+      var _iterator13 = _createForOfIteratorHelper(this._groupMembers),
+        _step13;
+      try {
+        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+          var _this$_groupDesired$g;
+          var _step13$value = _slicedToArray(_step13.value, 2),
+            groupId = _step13$value[0],
+            members = _step13$value[1];
+          groups[groupId] = {
+            members: _toConsumableArray(members),
+            states: {
+              power: {
+                type: 'Boolean',
+                default: (_this$_groupDesired$g = this._groupDesired.get(groupId)) !== null && _this$_groupDesired$g !== void 0 ? _this$_groupDesired$g : true,
+                gate: true
+              }
+            }
+          };
+        }
+      } catch (err) {
+        _iterator13.e(err);
+      } finally {
+        _iterator13.f();
+      }
+      return {
+        version: '3.0',
+        plant: {
+          states: {
+            power: {
+              type: 'Boolean',
+              default: this._plantPowerDesired,
+              gate: true
+            }
+          }
+        },
+        groups: groups,
+        chains: _toConsumableArray(this._chains),
+        stateRegistry: this.toRegistry()
+      };
+    }
+  }]);
+}();
+
+export { StateEngine, StateEngine as default, makeAddress, offValue, valuesEqual };