@_unit/unit 1.0.0

package/lib/Class/Graph/index.js

@@ -0,0 +1,3447 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = void 0;
+const bundle_1 = require("../../bundle");
+const spec_1 = require("../../client/spec");
+const method_1 = require("../../component/method");
+const SELF_1 = require("../../constant/SELF");
+const STRING_1 = require("../../constant/STRING");
+const MergeNotFoundError_1 = require("../../exception/MergeNotFoundError");
+const UnitNotFoundError_1 = require("../../exception/UnitNotFoundError");
+const Pin_1 = require("../../Pin");
+const Primitive_1 = require("../../Primitive");
+const cloneUnit_1 = require("../../spec/cloneUnit");
+const emptyIO_1 = require("../../spec/emptyIO");
+const fromId_1 = require("../../spec/fromId");
+const spec_2 = require("../../spec/reducers/spec");
+const stringify_1 = require("../../spec/stringify");
+const unitFromSpec_1 = require("../../spec/unitFromSpec");
+const util_1 = require("../../spec/util");
+const f_1 = require("../../system/core/object/DeepGet/f");
+const f_2 = require("../../system/core/object/ForEachKeyValue/f");
+const f_3 = require("../../system/f/object/DeepMerge/f");
+const isObjNotNull_1 = require("../../system/f/object/DeepMerge/isObjNotNull");
+const f_4 = require("../../system/f/object/Keys/f");
+const IOOf_1 = require("../../types/IOOf");
+const array_1 = require("../../util/array");
+const callAll_1 = require("../../util/call/callAll");
+const object_1 = require("../../util/object");
+const Element_1 = require("../Element");
+const Merge_1 = require("../Merge");
+const WaitAll_1 = require("../WaitAll");
+class Graph extends Primitive_1.Primitive {
+    constructor(spec = {
+        name: STRING_1.UNTITLED,
+        inputs: {},
+        outputs: {},
+        units: {},
+        merges: {},
+        component: {},
+        specs: {},
+    }, branch = {}, system, id) {
+        var _a;
+        super({
+            i: [],
+            o: [],
+        }, {}, system, id !== null && id !== void 0 ? id : spec.id);
+        this.__ = ['U', 'C', 'G', 'EE'];
+        this._element = false;
+        this._unit = {};
+        this._merge = {};
+        this._pipedFrom = {};
+        this._pipedTo = {};
+        this._errUnitIds = [];
+        this._pin = {};
+        this._unitPins = {};
+        this._exposedPin = {};
+        this._exposedMerge = {};
+        this._exposedEmptySubPin = {};
+        this._unit_err_count = {};
+        this._mergeToSelfUnit = {};
+        this._selfUniToMerge = {};
+        this._pinToMerge = {};
+        this._branch = {};
+        this._mergePinCount = {};
+        this._unitToMerge = {};
+        this._unitToMergeCount = {};
+        // E
+        this._children = [];
+        this._getExposedSubPinNodeId = (type, pin) => {
+            const { unitId, pinId, mergeId } = pin;
+            if (mergeId) {
+                return (0, util_1.getMergePinNodeId)(mergeId, type);
+            }
+            else {
+                return (0, util_1.getPinNodeId)(unitId, type, pinId);
+            }
+        };
+        this._ensureMergePin = (type, mergeId, propagate = false) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, type);
+            if (!this._pin[mergePinNodeId]) {
+                const oppositeType = (0, util_1.opposite)(type);
+                const mergePin = new Pin_1.Pin();
+                this._pin[mergePinNodeId] = mergePin;
+                this._setBranch(mergeId, oppositeType, mergePinNodeId, propagate);
+            }
+        };
+        this._memEnsureMergePin = (type, mergeId) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, type);
+            if (!this._pin[mergePinNodeId]) {
+                const oppositeType = (0, util_1.opposite)(type);
+                const mergePin = new Pin_1.Pin();
+                this._pin[mergePinNodeId] = mergePin;
+                this._memSetBranch(mergeId, oppositeType, mergePinNodeId);
+            }
+        };
+        this._removeMergeOutput = (mergeId) => {
+            this._simRemoveMergeOutput(mergeId);
+            this._memRemoveMergeOutput(mergeId);
+        };
+        this._memRemoveMergeOutput = (mergeId) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, 'output');
+            if (this._pin[mergePinNodeId]) {
+                this._memRemoveBranch(mergeId, 'input', mergePinNodeId);
+                delete this._pin[mergePinNodeId];
+            }
+        };
+        this._simRemoveMergeOutput = (mergeId) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, 'output');
+            if (this._pin[mergePinNodeId]) {
+                this._simRemoveBranch(mergeId, 'input', mergePinNodeId);
+            }
+        };
+        this._plugPinToMerge = (type, name, subPinId, mergeId, opt) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, type);
+            this._ensureMergePin(type, mergeId);
+            const subPin = this._pin[mergePinNodeId];
+            this._setExposedSubPin(type, name, subPinId, subPin, opt);
+        };
+        this._memPlugPinToMerge = (type, name, subPinId, mergeId) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, type);
+            this._ensureMergePin(type, mergeId);
+            const subPin = this._pin[mergePinNodeId];
+            this._memSetExposedSubPin(type, name, subPinId, subPin);
+        };
+        this._simPlugPinToMerge = (type, name, subPinId, mergeId, propagate = true) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, type);
+            this._ensureMergePin(type, mergeId, propagate);
+            const subPin = this._pin[mergePinNodeId];
+            this._simSetExposedSubPin(type, name, subPinId, subPin, propagate);
+        };
+        this._simUnplugPinFromMerge = (type, name, subPinId, mergeId) => {
+            this._simRemoveExposedSubPin(type, name, subPinId);
+        };
+        this._simUnplugPinFromUnitPin = (type, pinId, subPinId, _unitId, _pinId) => {
+            this._simRemoveExposedSubPin(type, pinId, subPinId);
+        };
+        this._plugPinToUnitPin = (type, name, subPinId, unitId, pinId, opt) => {
+            this._memPlugPinToUnitPin(type, name, subPinId, unitId, pinId);
+            this._simPlugPinToUnitPin(type, name, subPinId, unitId, pinId);
+        };
+        this._memPlugPinToUnitPin = (type, name, subPinId, unitId, pinId) => {
+            const subPin = this.getUnitPin(unitId, type, pinId);
+            this._memSetExposedSubPin(type, name, subPinId, subPin);
+        };
+        this._simPlugPinToUnitPin = (type, name, subPinId, unitId, pinId, propagate = true) => {
+            const subPin = this.getUnitPin(unitId, type, pinId);
+            this._simSetExposedSubPin(type, name, subPinId, subPin, propagate);
+        };
+        this._takeErr = () => {
+            if (this._errUnitIds.length > 0) {
+                const errUnitId = this._errUnitIds[0];
+                const errUnit = this._unit[errUnitId];
+                errUnit.takeErr();
+            }
+        };
+        this._nextErr = () => {
+            if (this._errUnitIds.length > 0) {
+                const errUnitId = this._errUnitIds[0];
+                const errUnit = this.refUnit(errUnitId);
+                const err = errUnit.getErr();
+                this.err(err);
+            }
+            else {
+                this.takeErr();
+            }
+        };
+        this._destroy = () => {
+            (0, f_2.default)(this._unit, (u) => u.destroy());
+            (0, f_2.default)(this._merge, (m) => m.destroy());
+        };
+        this._reset = () => {
+            // TODO
+        };
+        this.getSpec = () => {
+            return this._spec;
+        };
+        this.getComponentSpec = () => {
+            return this._spec.component;
+        };
+        this.refUnits = () => {
+            return this._unit;
+        };
+        this.refMergePin = (mergeId, type) => {
+            const mergePinNodeId = (0, util_1.getMergePinNodeId)(mergeId, type);
+            return this._pin[mergePinNodeId];
+        };
+        this.exposeOutputSets = (outputs) => {
+            (0, f_2.default)(outputs, this.exposeOutputSet);
+        };
+        this._exposeOutputSets = (outputs) => {
+            (0, f_2.default)(outputs, this._exposeOutputSet);
+        };
+        this.exposeOutputSet = (input, pinId) => {
+            this.exposePinSet('output', pinId, input);
+        };
+        this._exposeOutputSet = (input, pinId) => {
+            this._exposePinSet('output', pinId, input);
+        };
+        this.exposeOutput = (subPinId, pinSpec, id) => {
+            this.exposePin('output', id, subPinId, pinSpec);
+        };
+        this.coverOutputSet = (id) => {
+            this.coverPinSet('output', id);
+        };
+        this.coverOutput = (subPinId, id) => {
+            this.coverPin('output', id, subPinId);
+        };
+        this.plugOutput = (subPinId, subPin, id) => {
+            this.plugPin('input', id, subPinId, subPin);
+        };
+        this.unplugOutput = (subPinId, id) => {
+            this.unplugPin('output', id, subPinId);
+        };
+        this._unplugOutput = (subPinId, id) => {
+            this._unplugPin('output', id, subPinId);
+        };
+        this.exposeInputSets = (inputs) => {
+            (0, f_2.default)(inputs, this.exposeInputSet);
+        };
+        this._exposeInputSets = (inputs) => {
+            (0, f_2.default)(inputs, this._exposeInputSet);
+        };
+        this._initInputSets = (inputs) => {
+            (0, object_1.forEachObjKV)(inputs, this._initPinSet.bind(this, 'input'));
+        };
+        this._initOutputSets = (outputs) => {
+            (0, object_1.forEachObjKV)(outputs, this._initPinSet.bind(this, 'output'));
+        };
+        this.exposeInputSet = (input, pinId) => {
+            this.exposePinSet('input', pinId, input);
+        };
+        this._exposeInputSet = (input, pinId) => {
+            this._exposePinSet('input', pinId, input);
+        };
+        this.exposePinSet = (type, pinId, pinSpec, emit = true, exposedPin = new Pin_1.Pin(), exposedMerge = new Merge_1.default(this.__system), propagate = true) => {
+            // console.log('Graph', 'exposePinSet', type, pinId, pinSpec)
+            this._exposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge, propagate);
+            emit && this.emit('expose_pin_set', type, pinId, pinSpec);
+            emit && this.emit('leaf_expose_pin_set', [], type, pinId, pinSpec);
+        };
+        this._exposePinSet = (type, pinId, pinSpec, exposedPin = new Pin_1.Pin(), exposedMerge = new Merge_1.default(this.__system), propagate = true) => {
+            // console.log('Graph', '_exposePinSet', type, pinId, pinSpec)
+            this._fork();
+            this._specExposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge);
+            this._memExposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge);
+            this._simExposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge, propagate);
+        };
+        this._initPinSet = (type, pinId, pinSpec, exposedPin = new Pin_1.Pin(), exposedMerge = new Merge_1.default(this.__system), propagate = true) => {
+            // console.log('Graph', '_initPinSet', type, pinId, pinSpec)
+            this._memExposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge);
+            this._simExposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge, propagate);
+        };
+        this._specExposePinSet = (type, pinId, pinSpec, exposedPin = new Pin_1.Pin(), exposedMerge = new Merge_1.default(this.__system), propagate = true) => {
+            // console.log(
+            //   'Graph',
+            //   '_specExposePinSet',
+            //   this._spec.name,
+            //   type,
+            //   pinId,
+            //   pinSpec
+            // )
+            this._spec[`${type}s`] = this._spec[`${type}s`] || {};
+            this._spec[`${type}s`][pinId] = (0, object_1.clone)(pinSpec);
+            const { plug } = pinSpec;
+            (0, f_2.default)(plug, (subPinSpec, subPinId) => {
+                this._specExposePin(type, pinId, subPinId, subPinSpec);
+            });
+        };
+        this.memExposePinSet = (type, pinId, pinSpec, exposedPin, exposedMerge) => {
+            this._memExposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge);
+        };
+        this._memExposePinSet = (type, pinId, pinSpec, exposedPin, exposedMerge) => {
+            // console.log('Graph', '_memExposePinSet', type, pinId, pinSpec)
+            const { plug } = pinSpec;
+            const exposedNodeId = (0, util_1.getExposedPinId)(pinId, type);
+            this._exposedPin[exposedNodeId] = exposedPin;
+            this._exposedMerge[exposedNodeId] = exposedMerge;
+            (0, f_2.default)(plug, (subPinSpec, subPinId) => {
+                this._memExposePin(type, pinId, subPinId, subPinSpec);
+            });
+        };
+        this.exposePin = (type, pinId, subPinId, subPinSpec, emit = true) => {
+            this._exposePin(type, pinId, subPinId, subPinSpec);
+            emit && this.emit('expose_pin', type, pinId, subPinId, subPinSpec);
+        };
+        this._exposePin = (type, pinId, subPinId, subPinSpec) => {
+            this._specExposePin(type, pinId, subPinId, subPinSpec);
+            this._memExposePin(type, pinId, subPinId, subPinSpec);
+            this._simExposePin(type, pinId, subPinId, subPinSpec);
+        };
+        this._specExposePin = (type, pinId, subPinId, subPinSpec) => {
+            this._specPlugPin(type, pinId, subPinId, subPinSpec);
+        };
+        this._memExposePin = (type, pinId, subPinId, subPinSpec) => {
+            this._memPlugPin(type, pinId, subPinId, subPinSpec);
+        };
+        this._simExposePin = (type, pinId, subPinId, subPinSpec, propagate = true) => {
+            // console.log(
+            //   'Graph',
+            //   '_simExposePin',
+            //   type,
+            //   pinId,
+            //   subPinId,
+            //   subPinSpec,
+            //   propagate
+            // )
+            const { unitId, pinId: _pinId, mergeId } = subPinSpec;
+            if (mergeId || (unitId && _pinId)) {
+                this._simPlugPin(type, pinId, subPinId, subPinSpec, propagate);
+            }
+            else {
+                //
+            }
+        };
+        this.exposeInput = (subPinId, pinSpec, pinId, emit = true) => {
+            this.exposePin('input', pinId, subPinId, pinSpec, emit);
+        };
+        this.coverInputSet = (id) => {
+            this.coverPinSet('input', id);
+        };
+        this.coverInput = (subPinId, id) => {
+            this.coverPin('input', id, subPinId);
+        };
+        this.coverPinSet = (type, id, emit = true) => {
+            const pinSpec = this.getExposedPinSpec(type, id);
+            this._coverPinSet(type, id);
+            emit && this.emit('cover_pin_set', type, id, pinSpec);
+            emit && this.emit('leaf_cover_pin_set', [], type, id, pinSpec);
+        };
+        this._coverPinSet = (type, id) => {
+            this._fork();
+            this._simCoverPinSet(type, id);
+            this._memCoverPinSet(type, id);
+            this._specCoverPinSet(type, id);
+        };
+        this._memCoverPinSet = (type, pinId) => {
+            const pinSpec = this.getExposedPinSpec(type, pinId);
+            const { plug } = pinSpec;
+            const exposedNodeId = (0, util_1.getExposedPinId)(pinId, type);
+            (0, f_2.default)(plug, (subPinSpec, subPinId) => {
+                this._memCoverPin(type, pinId, subPinId);
+            });
+            delete this._exposedPin[exposedNodeId];
+            delete this._exposedMerge[exposedNodeId];
+        };
+        this._specCoverPinSet = (type, pinId) => {
+            const pinSpec = this.getExposedPinSpec(type, pinId);
+            const { plug } = pinSpec;
+            (0, f_2.default)(plug, (subPinSpec, subPinId) => {
+                this._specCoverPin(type, pinId, subPinId);
+            });
+            delete this._spec[`${type}s`][pinId];
+        };
+        this._simCoverPinSet = (type, pinId) => {
+            const pinSpec = this.getExposedPinSpec(type, pinId);
+            const { plug } = pinSpec;
+            (0, f_2.default)(plug, (subPinSpec, subPinId) => {
+                this._simCoverPin(type, pinId, subPinId);
+            });
+            this.removePin(type, pinId);
+        };
+        this._specSetPinRef = (type, pinId, ref) => {
+            (0, object_1.pathSet)(this._spec, [`${type}s`, pinId, 'ref'], ref);
+        };
+        this._memPlugPin = (type, pinId, subPinId, subPinSpec) => {
+            const { mergeId, unitId: _unitId, pinId: _pinId } = subPinSpec;
+            let ref = false;
+            if (_unitId && _pinId) {
+                if (this.isUnitRefPin(_unitId, type, _pinId) || _pinId === SELF_1.SELF) {
+                    ref = true;
+                }
+            }
+            else if (mergeId) {
+                const merge = this.getMergeSpec(mergeId);
+                (0, util_1.forEachPinOnMerge)(merge, (unitId, type, pinId) => {
+                    const unit = this.refUnit(unitId);
+                    if (unit.hasRefPinNamed(type, pinId)) {
+                        ref = true;
+                    }
+                });
+                if (this._mergeToSelfUnit[mergeId]) {
+                    ref = true;
+                }
+            }
+            // RETURN
+            this.setPinRef(type, pinId, ref);
+            (0, object_1.pathSet)(this._spec, [`${type}s`, pinId, 'plug', subPinId], subPinSpec);
+        };
+        this._specPlugPin = (type, pinId, subPinId, subPinSpec) => {
+            const { mergeId, unitId: _unitId, pinId: _pinId } = subPinSpec;
+            let ref = false;
+            if (_unitId && _pinId) {
+                if (this.isUnitRefPin(_unitId, type, _pinId) || _pinId === SELF_1.SELF) {
+                    ref = true;
+                }
+            }
+            else if (mergeId) {
+                const merge = this.getMergeSpec(mergeId);
+                (0, util_1.forEachPinOnMerge)(merge, (unitId, type, pinId) => {
+                    const unit = this.refUnit(unitId);
+                    if (unit.isPinRef(type, pinId)) {
+                        ref = true;
+                    }
+                });
+                if (this._mergeToSelfUnit[mergeId]) {
+                    ref = true;
+                }
+            }
+            this._specSetPinRef(type, pinId, ref);
+            (0, object_1.pathSet)(this._spec, [`${type}s`, pinId, 'plug', subPinId], subPinSpec);
+        };
+        this.plugPin = (type, pinId, subPinId, subPinSpec) => {
+            // console.log('Graph', 'plugPin', pinId, subPinId, subPinSpec)
+            this._plugPin(type, pinId, subPinId, subPinSpec);
+            this.emit('plug_pin', type, pinId, subPinId, subPinSpec);
+        };
+        this._plugPin = (type, pinId, subPinId, subPinSpec) => {
+            // console.log('Graph', '_plugPin', pinId, subPinId, subPinSpec)
+            const { mergeId, unitId, pinId: _pinId } = subPinSpec;
+            const pinSpec = this.getExposedPinSpec(type, pinId);
+            this._specPlugPin(type, pinId, subPinId, subPinSpec);
+            this._memPlugPin(type, pinId, subPinId, subPinSpec);
+            const { ref } = pinSpec;
+            const opt = { ref: !!ref };
+            if (mergeId) {
+                this._plugPinToMerge(type, pinId, subPinId, mergeId, opt);
+            }
+            else if (unitId && _pinId) {
+                this._plugPinToUnitPin(type, pinId, subPinId, unitId, _pinId, opt);
+            }
+            else {
+                throw new Error('invalid sub pin spec');
+            }
+        };
+        this._simPlugPin = (type, pinId, subPinId, subPinSpec, propagate = true) => {
+            // console.log('Graph', '_simPlugPin', pinId, subPinId, subPinSpec)
+            const { mergeId, unitId, pinId: _pinId } = subPinSpec;
+            if (mergeId) {
+                this._simPlugPinToMerge(type, pinId, subPinId, mergeId, propagate);
+            }
+            else {
+                this._simPlugPinToUnitPin(type, pinId, subPinId, unitId, _pinId, propagate);
+            }
+        };
+        this.plugInput = (subPinId, subPin, id) => {
+            this.plugPin('input', id, subPinId, subPin);
+        };
+        this.unplugInput = (subPinId, id) => {
+            this.unplugPin('input', id, subPinId);
+        };
+        this._unplugInput = (subPinId, id) => {
+            this._unplugPin('input', id, subPinId);
+        };
+        this.coverPin = (type, pinId, subPinId, emit = true) => {
+            const subPinSpec = this.getSubPinSpec(type, pinId, subPinId);
+            this._coverPin(type, pinId, subPinId);
+            emit && this.emit('cover_pin', type, pinId, subPinId, subPinSpec);
+        };
+        this._coverPin = (type, id, subPinId) => {
+            this._simCoverPin(type, id, subPinId);
+            this._memCoverPin(type, id, subPinId);
+            this._specCoverPin(type, id, subPinId);
+        };
+        this._specCoverPin = (type, id, subPinId) => {
+            delete this._spec[`${type}s`][id]['plug'][subPinId];
+        };
+        this._memCoverPin = (type, id, subPinId) => {
+            this.emit('before_cover_pin', type, id, subPinId);
+            const pinSpec = this._spec[`${type}s`][id];
+            const subPinSpec = pinSpec['plug'][subPinId];
+            const { mergeId } = subPinSpec;
+            if (type === 'output') {
+                if (mergeId) {
+                    this._memRemoveMergeOutput(mergeId);
+                }
+            }
+        };
+        this._simCoverPin = (type, id, subPinId) => {
+            const subPinSpec = this.getSubPinSpec(type, id, subPinId);
+            const { mergeId, unitId, pinId } = subPinSpec;
+            if (type === 'output') {
+                if (mergeId) {
+                    this._simRemoveMergeOutput(mergeId);
+                }
+            }
+            if (mergeId || (unitId && pinId)) {
+                this._simRemoveExposedSubPin(type, id, subPinId);
+            }
+        };
+        this.getSubPinSpec = (type, pinId, subPinId) => {
+            var _a, _b, _c;
+            return (_c = (_b = (_a = this._spec[`${type}s`]) === null || _a === void 0 ? void 0 : _a[pinId]) === null || _b === void 0 ? void 0 : _b['plug']) === null || _c === void 0 ? void 0 : _c[subPinId];
+        };
+        this.unplugPin = (type, pinId, subPinId) => {
+            // console.log('Graph', 'unplugPin', pinId, subPinId)
+            this._unplugPin(type, pinId, subPinId);
+            this.emit('unplug_pin', type, pinId, subPinId);
+        };
+        this._unplugPin = (type, pinId, subPinId) => {
+            // console.log('Graph', 'unplugPin', pinId, subPinId)
+            this._memPlugEmptyPin(type, pinId, subPinId);
+            this._specUnplugPin(type, pinId, subPinId);
+            this._simUnplugPin(type, pinId, subPinId);
+            this._memUnplugPin(type, pinId, subPinId);
+        };
+        this._specUnplugPin = (type, pinId, subPinId) => {
+            // console.log('Graph', '_specUnplugPin', type, pinId, subPinId)
+            this._spec[`${type}s`][pinId].plug[subPinId] = {};
+        };
+        this._memUnplugPin = (type, pinId, subPinId) => {
+            const subPinSpec = this.getSubPinSpec(type, pinId, subPinId);
+            const isOutput = type === 'output';
+            if (isOutput) {
+                const { mergeId } = subPinSpec;
+                if (mergeId) {
+                    this._memRemoveMergeOutput(mergeId);
+                }
+            }
+        };
+        this._memPlugEmptyPin = (type, pinId, subPinId) => {
+            const emptySubPinId = `${pinId}/${subPinId}`;
+            const emptySubPin = new Pin_1.Pin();
+            this._exposedEmptySubPin[emptySubPinId] = emptySubPin;
+            this._memSetExposedSubPin(type, pinId, subPinId, emptySubPin);
+        };
+        this._simUnplugPin = (type, pinId, subPinId) => {
+            // console.log('Graph', '_simUnplugPin', pinId, subPinId)
+            this.__simUnplugPin(type, pinId, subPinId);
+            this._simPlugEmptyPin(type, pinId, subPinId);
+        };
+        this.__simUnplugPin = (type, pinId, subPinId) => {
+            const subPinSpec = this.getSubPinSpec(type, pinId, subPinId);
+            const { mergeId: _mergeId, unitId: _unitId, pinId: _pinId } = subPinSpec;
+            const isOutput = type === 'output';
+            if (isOutput) {
+                if (_mergeId) {
+                    this._simRemoveMergeOutput(_mergeId);
+                }
+            }
+            const pin = this.getPin(type, pinId);
+            const isRef = this.hasRefPinNamed(type, pinId);
+            if (_mergeId) {
+                this._simUnplugPinFromMerge(type, pinId, subPinId, _mergeId);
+            }
+            else if (_unitId && _pinId) {
+                this._simUnplugPinFromUnitPin(type, pinId, subPinId, _unitId, _pinId);
+            }
+            if (isOutput) {
+                if (isRef) {
+                    pin.take();
+                }
+            }
+        };
+        this._simPlugEmptyPin = (type, pinId, subPinId, propagate = true) => {
+            const emptySubPinId = `${pinId}/${subPinId}`;
+            const emptySubPin = this._exposedEmptySubPin[emptySubPinId];
+            this._simSetExposedSubPin(type, pinId, subPinId, emptySubPin, propagate);
+        };
+        this._memUnplugInput = (pinId, subPinId) => {
+            return this._memUnplugPin('input', pinId, subPinId);
+        };
+        this._memUnplugOutput = (pinId, subPinId) => {
+            return this._memUnplugPin('output', pinId, subPinId);
+        };
+        this._simUnplugInput = (pinId, subPinId) => {
+            return this._simUnplugPin('input', pinId, subPinId);
+        };
+        this._simUnplugOutput = (pinId, subPinId) => {
+            return this._simUnplugPin('output', pinId, subPinId);
+        };
+        this.getExposedInputPin = (id) => {
+            const exposedInputId = (0, util_1.getExposedPinId)(id, 'input');
+            return this._exposedPin[exposedInputId];
+        };
+        this.getExposedOutputPin = (id) => {
+            const exposedOutputId = (0, util_1.getExposedPinId)(id, 'output');
+            return this._exposedPin[exposedOutputId];
+        };
+        this._getUnitOuterSpec = (unitId) => {
+            const outerSpec = {
+                merges: {
+                    input: {},
+                    output: {},
+                },
+                exposed: {
+                    input: {},
+                    output: {},
+                },
+            };
+            const unitToMerge = this._unitToMerge[unitId] || new Set();
+            const unitToMergeCount = this._unitToMergeCount[unitId] || 0;
+            for (const mergeId of unitToMerge) {
+                const unitMergeCount = unitToMergeCount[mergeId];
+                this._forEachUnitPinOnMerge(unitId, mergeId, (type, pinId) => {
+                    const mergePinCount = this.getMergePinCount(mergeId);
+                    if (mergePinCount - unitMergeCount < 2) {
+                        const merge = this.getMergeSpec(mergeId);
+                        const otherUnitId = (0, object_1.getObjSingleKey)((0, object_1.omit)(merge, unitId));
+                        const otherUnitMerge = merge[otherUnitId];
+                        let otherUnitPinType;
+                        let otherUnitPinId;
+                        if (otherUnitMerge.input) {
+                            otherUnitPinType = 'input';
+                            otherUnitPinId = (0, object_1.getObjSingleKey)(otherUnitMerge.input);
+                        }
+                        else {
+                            otherUnitPinType = 'output';
+                            otherUnitPinId = (0, object_1.getObjSingleKey)(otherUnitMerge.output);
+                        }
+                        (0, object_1.pathSet)(outerSpec.merges, [type, pinId], {
+                            mergeId,
+                            otherPin: {
+                                unitId: otherUnitId,
+                                type: otherUnitPinType,
+                                pinId: otherUnitPinId,
+                            },
+                        });
+                    }
+                    else {
+                        (0, object_1.pathSet)(outerSpec.merges, [type, pinId], { mergeId, otherPin: null });
+                    }
+                });
+            }
+            // TODO exposed
+            return outerSpec;
+        };
+        this.getGraphPinData = () => {
+            const state = {};
+            (0, f_2.default)(this._unit, (unit, unitId) => {
+                const unitPinData = unit.getPinData();
+                state[unitId] = unitPinData;
+            });
+            return state;
+        };
+        this.getGraphMergeInputData = () => {
+            const state = {};
+            (0, f_2.default)(this._merge, (merge, mergeId) => {
+                const mergeInputPinId = (0, util_1.getMergePinNodeId)(mergeId, 'input');
+                const mergeInputPin = this._pin[mergeInputPinId];
+                if (mergeInputPin) {
+                    const mergeInputData = mergeInputPin.peak();
+                    state[mergeId] = mergeInputData;
+                }
+            });
+            return state;
+        };
+        this.getGraphErr = () => {
+            const unit_err = {};
+            (0, f_2.default)(this._unit, (unit, unit_id) => {
+                const err = unit.getErr();
+                unit_err[unit_id] = err;
+            });
+            return unit_err;
+        };
+        this.getUnitInputData = (unitId) => {
+            const unit = this.refUnit(unitId);
+            const data = unit.getInputData();
+            return data;
+        };
+        this.addUnit = (unitId, unit, emit = true) => {
+            this._addUnit(unitId, unit);
+            emit && this.emit('add_unit', unitId, unit);
+            emit && this.emit('leaf_add_unit', unit, [unitId]);
+        };
+        this._addUnit = (unitId, unit) => {
+            this._fork();
+            if (this._unit[unitId]) {
+                throw new Error('duplicated unit id ' + unitId);
+            }
+            const bundleSpec = unit.getUnitBundleSpec(false);
+            this._specAddUnit(unitId, unit);
+            this._memAddUnit(unitId, unit);
+            this._simAddUnit(unitId, bundleSpec, unit);
+            return unit;
+        };
+        this.addUnitSpecs = (units) => {
+            this._addUnitSpecs(units);
+            // this.emit('add_units', units)
+        };
+        this._addUnitSpecs = (units) => {
+            (0, f_2.default)(units, (unit, unitId) => {
+                this._addUnitBundleSpec(unitId, { unit });
+            });
+        };
+        this.injectSubComponent = (unitId, unitSpec, unit) => {
+            this._specInjectSubComponent(unitId);
+            this._simInjectSubComponent(unitId, unitSpec, unit);
+        };
+        this._simInjectSubComponent = (unitId, unitSpec, unit) => {
+            const { classes } = this._system;
+            const { children = [] } = unitSpec;
+            for (const child of children) {
+                const { id } = child;
+                const ChildBundle = (0, fromId_1.fromId)(id, this._system.specs, classes);
+                unit.appendChild(ChildBundle);
+            }
+        };
+        this._injectSubComponent = (unitId, unitSpec, unit) => {
+            const { classes } = this._system;
+            const { children = [] } = unitSpec;
+            for (const child of children) {
+                const { id } = child;
+                const ChildBundle = (0, fromId_1.fromId)(id, this._system.specs, classes);
+                unit.appendChild(ChildBundle);
+                // TODO state
+            }
+            this._specInjectSubComponent(unitId);
+        };
+        this._specInjectSubComponent = (unitId) => {
+            // console.log('Graph', '_specInjectSubComponent', unitId)
+            (0, object_1.pathSet)(this._spec, ['component', 'subComponents', unitId], {
+                children: [],
+            });
+        };
+        this.componentAppend = (unitId, bundle) => {
+            this._specAppendRoot(unitId);
+            this.emit('component_append', unitId, bundle);
+        };
+        this._specAppendRoot = (unitId) => {
+            // console.log('Graph', '_specAppendRoot', unitId)
+            this._spec.component.children = this._spec.component.children || [];
+            this._spec.component.children.push(unitId);
+        };
+        this.componentRemove = (unitId) => {
+            this._specComponentRemoveChild(unitId);
+            this.emit('component_remove', unitId);
+        };
+        this._specComponentRemoveChild = (unitId) => {
+            const i = this._spec.component.children.indexOf(unitId);
+            this._spec.component.children.splice(i, 1);
+        };
+        this.removeSubComponent = (unitId) => {
+            // console.log('Graph', 'removeSubComponent', unitId)
+            this._specRemoveSubComponent(unitId);
+        };
+        this._specRemoveSubComponent = (unitId) => {
+            // console.log('Graph', '_specRemoveSubComponent', unitId)
+            const { subComponents } = this._spec.component;
+            const subComponent = subComponents[unitId];
+            const { children = [] } = subComponent;
+            for (const chlid_id of children) {
+                this._spec.component.children.push(chlid_id);
+            }
+            delete subComponents[unitId];
+        };
+        this._getSubComponentParentId = (unitId) => {
+            const component_spec = this._spec.component;
+            const { subComponents } = component_spec;
+            for (const subComponentId in subComponents) {
+                const sub_component = subComponents[subComponentId];
+                const { children = [] } = sub_component;
+                for (const childId of children) {
+                    if (childId === unitId) {
+                        return subComponentId;
+                    }
+                }
+            }
+            return null;
+        };
+        this._appendSubComponentChild = (subComponentId, childId, slot) => {
+            this._fork();
+            this._specSubComponentAppendChild(subComponentId, childId, slot);
+            this._simSubComponentAppendChild(subComponentId, childId, slot);
+        };
+        this._simRemoveSubComponentFromParent = (subComponentId) => {
+            // console.log('Graph', '_memSubComponentMoveChild', subComponentId)
+            const currentParentId = this._getSubComponentParentId(subComponentId);
+            if (currentParentId) {
+                this._simSubComponentRemoveChild(currentParentId, subComponentId);
+            }
+            else {
+                this._simRemoveRoot(subComponentId);
+            }
+        };
+        this._specRemoveSubComponentChild = (currentParentId, subComponentId) => {
+            const parentComponent = this._spec.component.subComponents[currentParentId];
+            const { children = [], childSlot = {} } = parentComponent;
+            const i = children.indexOf(subComponentId);
+            children.splice(i, 1);
+            delete childSlot[subComponentId];
+            parentComponent.children = children;
+            parentComponent.childSlot = childSlot;
+        };
+        this._specRemoveSubComponentFromParent = (subComponentId) => {
+            // console.log('Graph', '_specRemoveSubComponentFromParent', subComponentId)
+            const currentParentId = this._getSubComponentParentId(subComponentId);
+            if (currentParentId) {
+                this._specRemoveSubComponentChild(currentParentId, subComponentId);
+            }
+            else {
+                this._specRemoveRoot(subComponentId);
+            }
+        };
+        this._simSubComponentRemoveChild = (parentId, subComponentId) => {
+            const parentComponent = this.refUnit(parentId);
+            const subComponent = this.refUnit(subComponentId);
+            parentComponent.removeParentChild(subComponent);
+        };
+        this._specSubComponentAppendChild = (subComponentId, childId, slot) => {
+            // console.log(
+            //   'Graph',
+            //   '_specSubComponentAppendChild',
+            //   subComponentId,
+            //   childId
+            // )
+            const subComponent = this._spec.component.subComponents[subComponentId];
+            const { children = [], childSlot = {} } = subComponent;
+            children.push(childId);
+            childSlot[childId] = slot;
+            subComponent.children = children;
+            subComponent.childSlot = childSlot;
+        };
+        this._simSubComponentAppendChild = (subComponentId, childId, slotName) => {
+            const subComponentUnit = this.refUnit(subComponentId);
+            const childUnit = this.refUnit(childId);
+            subComponentUnit.registerParentRoot(childUnit, slotName);
+        };
+        this._unitUnlisten = {};
+        this.addUnitBundle = (unitId, unitBundle) => {
+            this._addUnitBundle(unitId, unitBundle);
+        };
+        this._addUnitBundle = (unitId, unitBundle) => { };
+        this._on_unit_element = (unitId, unitSpec, unit) => {
+            this.injectSubComponent(unitId, unitSpec, unit);
+        };
+        this._on_unit_not_element = (unitId) => {
+            this._specRemoveSubComponent(unitId);
+        };
+        this._simRemoveUnit = (unitId) => {
+            const unit = this.refUnit(unitId);
+            if (unit.hasErr()) {
+                this._removeErrUnit(unitId);
+            }
+            const exposedOutputId = this.getExposedOutput({
+                unitId,
+                pinId: SELF_1.SELF,
+            });
+            this._simUnplugUnit(unitId);
+            if (exposedOutputId) {
+                this.takeOutput(exposedOutputId);
+            }
+        };
+        this._specUnplugUnit = (unitId) => {
+            const { merges } = this._spec;
+            (0, util_1.forEachPinOnMerges)((0, object_1.clone)(merges), (mergeId, mergeUnitId, type, pinId) => {
+                const merge = (0, object_1.clone)(merges[mergeId]);
+                if (mergeUnitId === unitId) {
+                    delete merge[unitId];
+                    const mergePinCount = (0, util_1.getMergePinCount)(merge);
+                    if (mergePinCount < 2) {
+                        this._specRemoveMerge(mergeId);
+                    }
+                    else {
+                        this._specRemoveUnitFromMerge(unitId, mergeId);
+                    }
+                }
+            });
+            this._forEachSpecPinPlug((type, pinId, subPinId, subPinSpec) => {
+                if (subPinSpec.unitId === unitId) {
+                    this._specUnplugPin(type, pinId, subPinId);
+                }
+            });
+        };
+        this._simUnplugUnit = (unitId) => {
+            const unitToMerge = this._unitToMerge[unitId] || new Set();
+            const unitToMergeCount = this._unitToMergeCount[unitId] || {};
+            for (const mergeId of unitToMerge) {
+                const unitMergeCount = unitToMergeCount[mergeId];
+                const mergePinCount = this.getMergePinCount(mergeId);
+                if (mergePinCount - unitMergeCount < 2) {
+                    this._simRemoveMerge(mergeId);
+                }
+                else {
+                    this._simRemoveUnitFromMerge(unitId, mergeId);
+                }
+            }
+            this._forEachSpecPinPlug((type, pinId, subPinId, subPinSpec) => {
+                if (subPinSpec.unitId === unitId) {
+                    this.__simUnplugPin(type, pinId, subPinId);
+                }
+            });
+        };
+        this.addMerges = (merges) => {
+            (0, f_2.default)(merges, this.addMerge);
+        };
+        this._addMerges = (merges) => {
+            (0, f_2.default)(merges, this._addMerge);
+        };
+        this._initMerges = (merges) => {
+            (0, object_1.forEachObjKV)(merges, this._initMerge);
+        };
+        this._initMerge = (mergeId, mergeSpec) => {
+            const merge = this._createMerge(mergeId);
+            this._memAddMerge(mergeId, mergeSpec, merge);
+            this._simAddMerge(mergeId, mergeSpec, merge);
+        };
+        this.addMerge = (mergeSpec, mergeId, emit = true, propagate = true, merge) => {
+            // console.log('Graph', 'addMerge', mergeId, mergeSpec)
+            this._addMerge(mergeSpec, mergeId, merge, propagate);
+            emit && this.emit('add_merge', mergeId, mergeSpec);
+        };
+        this._createMerge = (mergeId) => {
+            const merge = new Merge_1.default(this._system);
+            const mergeInputPinId = (0, util_1.getMergePinNodeId)(mergeId, 'input');
+            const mergeInputPin = new Pin_1.Pin();
+            merge.addInput(mergeInputPinId, mergeInputPin);
+            return merge;
+        };
+        this._addMerge = (mergeSpec, mergeId, merge = null, propagate = true) => {
+            // console.log('Graph', '_addMerge', mergeId, mergeSpec, propagate)
+            this._fork();
+            merge = merge !== null && merge !== void 0 ? merge : this._createMerge(mergeId);
+            this._specAddMerge(mergeId, mergeSpec, merge);
+            this._memAddMerge(mergeId, mergeSpec, merge);
+            this._simAddMerge(mergeId, mergeSpec, merge, propagate);
+        };
+        this._specAddMerge = (mergeId, mergeSpec, merge) => {
+            // console.log('Graph', '_specAddMerge', mergeId, mergeSpec)
+            (0, object_1.pathSet)(this._spec, ['merges', mergeId], mergeSpec);
+            (0, f_2.default)(mergeSpec, ({ input, output }, unitId) => {
+                (0, f_2.default)(input || {}, (_, inputId) => {
+                    this._specAddPinToMerge(mergeId, unitId, 'input', inputId);
+                });
+                (0, f_2.default)(output || {}, (_, outputId) => {
+                    this._specAddPinToMerge(mergeId, unitId, 'output', outputId);
+                });
+            });
+        };
+        this._memAddMerge = (mergeId, mergeSpec, merge) => {
+            // console.log('Graph', '_memAddMerge', mergeId)
+            this.emit('before_add_merge', mergeId, mergeSpec, merge);
+            const mergeInputPinId = (0, util_1.getMergePinNodeId)(mergeId, 'input');
+            const mergeInputPin = merge.getInput(mergeInputPinId);
+            this._pin[mergeInputPinId] = mergeInputPin;
+            this._merge[mergeId] = merge;
+            (0, f_2.default)(mergeSpec, ({ input, output }, unitId) => {
+                (0, f_2.default)(input || {}, (_, inputId) => {
+                    this._memAddPinToMerge(mergeId, unitId, 'input', inputId);
+                });
+                (0, f_2.default)(output || {}, (_, outputId) => {
+                    this._memAddPinToMerge(mergeId, unitId, 'output', outputId);
+                });
+            });
+        };
+        this.addPinToMerge = (mergeId, unitId, type, pinId) => {
+            this._addPinToMerge(mergeId, unitId, type, pinId);
+            this.emit('add_pin_to_merge', mergeId, unitId, type, pinId);
+        };
+        this._addPinToMerge = (mergeId, unitId, type, pinId, propagate = true) => {
+            // console.log('Graph', '_addPinToMerge', mergeId, unitId, type, pinId, propagate)
+            this._validateMergeId(mergeId);
+            this._validateUnitId(unitId);
+            if (type === 'output' && pinId === SELF_1.SELF) {
+                this._mergeToSelfUnit[mergeId] = unitId;
+                this._selfUniToMerge[unitId] = mergeId;
+            }
+            this._spec = (0, spec_2.addPinToMerge)({ id: mergeId, unitId, type, pinId }, this._spec);
+            this._mergePinCount[mergeId] = this._mergePinCount[mergeId] || 0;
+            this._mergePinCount[mergeId]++;
+            this._unitToMerge[unitId] = this._unitToMerge[unitId] || new Set();
+            this._unitToMerge[unitId].add(mergeId);
+            this._unitToMergeCount[unitId] = this._unitToMergeCount[unitId] || {};
+            this._unitToMergeCount[unitId][mergeId] =
+                this._unitToMergeCount[unitId][mergeId] || 0;
+            this._unitToMergeCount[unitId][mergeId]++;
+            (0, f_2.default)((this._spec[`${type}s`] || {}), ({ plug }, id) => {
+                for (const subPinId in plug) {
+                    const subPinSpec = plug[subPinId];
+                    if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                        this._unplugPin(type, id, subPinId);
+                        this._plugPin(type, id, subPinId, { mergeId });
+                    }
+                }
+            });
+            const pinNodeId = (0, util_1.getPinNodeId)(unitId, type, pinId);
+            (0, object_1.pathSet)(this._pinToMerge, [unitId, type, pinId], mergeId);
+            this._setBranch(mergeId, type, pinNodeId, propagate);
+        };
+        this._simRemoveAllPlugsFromMerge = (mergeId) => {
+            // console.log('Graph', '_simRemoveAllPlugsFromMerge', mergeId, this._spec.outputs)
+            this._forEachSpecPinPlug((type, pinId, subPinId, subPinSpec) => {
+                if (subPinSpec.mergeId === mergeId) {
+                    this.__simUnplugPin(type, pinId, subPinId);
+                }
+            });
+        };
+        this.__simRemoveAllPlugsFromMerge = (mergeId) => {
+            this._forEachSpecPinPlug((type, pinId, subPinId, subPinSpec) => {
+                if (subPinSpec.mergeId === mergeId) {
+                    this.__simUnplugPin(type, pinId, subPinId);
+                }
+            });
+        };
+        this._forEachSpecPinPlug = (callback) => {
+            this._forEachSpecPinOfType('input', (pinId, subPinId, subPinSpec) => {
+                callback('input', pinId, subPinId, subPinSpec);
+            });
+            this._forEachSpecPinOfType('output', (pinId, subPinId, subPinSpec) => {
+                callback('output', pinId, subPinId, subPinSpec);
+            });
+        };
+        this._forEachSpecPinOfType = (type, callback) => {
+            (0, f_2.default)(this._spec[`${type}s`] || {}, ({ plug }, pinId) => {
+                for (const subPinId in plug) {
+                    const subPinSpec = plug[subPinId];
+                    callback(pinId, subPinId, subPinSpec);
+                }
+            });
+        };
+        this._simRemoveAllPinsFromMerge = (mergeId) => {
+            const merge = (0, object_1.clone)(this._spec.merges[mergeId]);
+            (0, f_2.default)(merge, ({ input, output }, unitId) => {
+                (0, f_2.default)(input || {}, (_, inputId) => {
+                    this._simRemovePinFromMerge(mergeId, unitId, 'input', inputId);
+                });
+                (0, f_2.default)(output || {}, (_, outputId) => {
+                    this._simRemovePinFromMerge(mergeId, unitId, 'output', outputId);
+                });
+            });
+        };
+        this._moveSubgraphInto__remove = (graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveSubgraphInto__',
+            //   graphId,
+            //   nodeIds,
+            //   nextIdMap,
+            //   nextPinIdMap,
+            //   nextMergePinId,
+            //   nextSubComponentParentMap,
+            //   nextSubComponentChildrenMap
+            // )
+            this._moveSubgraphInto__template(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph, this._moveUnitInto__remove, this._moveLinkPinInto__remove, this._moveMergeInto__remove, this._movePlugInto__remove);
+        };
+        this._movePlugInto__remove = (graphId, type, pinId, subPinId, subPinSpec, nextPlugSpec, nextPinIdMap, nextMergePinId, nextIdMap, graph) => {
+            // console.log('Graph', '_movePlugInto')
+            const plugCount = this.getPinPlugCount(type, pinId);
+            if (plugCount === 1) {
+                this._coverPinSet(type, pinId);
+            }
+            else {
+                this._coverPin(type, pinId, subPinId);
+            }
+        };
+        this._newMergeId = () => {
+            let i = 0;
+            let mergeId = `${i}`;
+            while (this.hasMerge(mergeId)) {
+                i++;
+                mergeId = `${i}`;
+            }
+            return mergeId;
+        };
+        this._movePlugInto__inject = (graphId, type, pinId, subPinId, subPinSpec, nextPlugSpec, nextPinIdMap, nextMergePinId, nextIdMap, graph) => {
+            // console.log('Graph', '_movePlugInto__inject')
+            const finalType = (0, object_1.pathOrDefault)(nextIdMap, ['plug', type, pinId, subPinId, 'type'], type);
+            if (!graph.hasPinNamed(finalType, pinId)) {
+                graph.exposePinSet(finalType, pinId, { plug: {} }, false);
+            }
+            const nextSubPinSpec = (0, object_1.pathOrDefault)(nextPlugSpec, [type, pinId, subPinId], {});
+            graph.exposePin(finalType, pinId, subPinId, nextSubPinSpec, false);
+        };
+        this._movePlugInto__reconnect = (graphId, type, pinId, subPinId, subPinSpec, nextPlugSpec, nextPinIdMap, nextMergePinId, nextIdMap, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_movePlugInto__reconnect',
+            //   graphId,
+            //   type,
+            //   pinId,
+            //   subPinId,
+            //   subPinSpec,
+            //   nextPlugSpec
+            // )
+            const oppositeType = (0, util_1.opposite)(type);
+            const nextPinId = (0, object_1.pathOrDefault)(nextPlugSpec, [type, pinId, subPinId, 'pinId'], pinId);
+            const finalType = (0, object_1.pathOrDefault)(nextIdMap, ['plug', type, pinId, subPinId, 'type'], type);
+            if (subPinSpec.unitId && subPinSpec.pinId) {
+                let nextMergeId = (0, object_1.pathOrDefault)(nextIdMap, ['link', subPinSpec.unitId, subPinSpec.type, pinId, 'mergeId'], null);
+                if (nextMergeId) {
+                    this._addPinToMerge(nextMergeId, graphId, finalType, nextPinId);
+                }
+                else {
+                    nextMergeId = (0, object_1.pathOrDefault)(nextIdMap, ['plug', type, pinId, subPinId, 'mergeId'], null);
+                    if (nextMergeId) {
+                        this._addMerge({
+                            [graphId]: {
+                                [finalType]: {
+                                    [nextPinId]: true,
+                                },
+                            },
+                            [subPinSpec.unitId]: {
+                                [type]: {
+                                    [subPinSpec.pinId]: true,
+                                },
+                            },
+                        }, nextMergeId, undefined, false);
+                    }
+                }
+            }
+            else if (subPinSpec.mergeId) {
+                const nextMergeId = (0, object_1.pathOrDefault)(nextMergePinId, ['merge', subPinSpec.mergeId, type], null);
+                if (nextMergeId) {
+                    this._addPinToMerge(nextMergeId, graphId, finalType, nextPinId, false);
+                }
+            }
+        };
+        this._moveUnitInto = (graphId, unitId, nextUnitId, ignoredPin, ignoredMerge, nextPinMap, nextSubComponentParent, nextSubComponentChildren, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveUnitInto',
+            //   graphId,
+            //   unitId,
+            //   nextUnitId,
+            //   ignoredPin,
+            //   ignoredMerge,
+            //   nextPinMap,
+            //   nextSubComponentParent,
+            //   nextSubComponentChildren
+            // )
+            const unit = this.refUnit(unitId);
+            graph.addUnit(nextUnitId, unit, false);
+            if (nextSubComponentParent) {
+                if (graph.hasUnit(nextSubComponentParent)) {
+                    this.removeRoot(nextUnitId);
+                    graph.moveSubComponent(nextSubComponentParent, nextUnitId, 'default');
+                }
+            }
+            if (nextSubComponentChildren) {
+                for (const nextSubComponentChildId of nextSubComponentChildren) {
+                    if (graph.hasUnit(nextSubComponentChildId)) {
+                        this.removeRoot(nextSubComponentChildId);
+                        graph.moveSubComponent(nextUnitId, nextSubComponentChildId, 'default');
+                    }
+                }
+            }
+            const movePinInto = (type, pinId) => {
+                if (!ignoredPin[type].has(pinId) && !unit.isPinIgnored(type, pinId)) {
+                    const { pinId: nextPinId, subPinId: nextSubPinId } = nextPinMap[type][pinId];
+                    const mergeId = (0, object_1.pathOrDefault)(this._pinToMerge, [unitId, type, pinId], null);
+                    const swapMergePin = mergeId && !ignoredMerge.has(mergeId);
+                    if (swapMergePin) {
+                        this._removePinFromMerge(mergeId, unitId, type, pinId, false);
+                    }
+                    if (graph.hasPinNamed(type, nextPinId)) {
+                        graph.exposePin(type, nextPinId, nextSubPinId, {
+                            unitId: nextUnitId,
+                            pinId,
+                        }, false);
+                    }
+                    else {
+                        const unitPin = unit.getPin(type, pinId);
+                        const unitPinData = unitPin.peak();
+                        const unitPinRef = unit.hasRefPinNamed(type, pinId);
+                        const nextExposedPin = new Pin_1.Pin({ data: unitPinData });
+                        const nextExposedMerge = new Merge_1.default(this._system);
+                        graph.exposePinSet(type, nextPinId, {
+                            plug: {
+                                '0': {
+                                    unitId: nextUnitId,
+                                    pinId,
+                                },
+                            },
+                            ref: unitPinRef,
+                        }, false, nextExposedPin, nextExposedMerge, false);
+                        if (swapMergePin) {
+                            this._addPinToMerge(mergeId, graphId, type, nextPinId, false);
+                        }
+                        (0, f_2.default)(this._spec[`${type}s`] || {}, ({ plug }, id) => {
+                            for (const subPinId in plug) {
+                                const subPinSpec = plug[subPinId];
+                                if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                                    this._unplugPin(type, id, subPinId);
+                                    this._plugPin(type, id, subPinId, {
+                                        unitId: graphId,
+                                        pinId: nextPinId,
+                                    });
+                                    break;
+                                }
+                            }
+                        });
+                    }
+                }
+            };
+            const inputs = unit.getInputNames();
+            for (const input_id of inputs) {
+                movePinInto('input', input_id);
+            }
+            const outputs = unit.getOutputNames();
+            for (const output_id of outputs) {
+                movePinInto('output', output_id);
+            }
+            this._memRemoveUnit(unitId);
+        };
+        this._moveUnitInto__remove = (graphId, unitId, unit, nextUnitId, ignoredPin, ignoredMerge, nextPinMap, nextSubComponentParent, nextSubComponentChildren, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveUnitInto',
+            //   graphId,
+            //   unitId,
+            //   nextUnitId,
+            //   ignoredPin,
+            //   ignoredMerge,
+            //   nextPinMap,
+            //   nextSubComponentParent,
+            //   nextSubComponentChildren
+            // )
+            if (nextSubComponentParent) {
+                if (graph.hasUnit(nextSubComponentParent)) {
+                    graph.removeRoot(nextUnitId);
+                }
+            }
+            if (nextSubComponentChildren) {
+                for (const nextSubComponentChildId of nextSubComponentChildren) {
+                    if (graph.hasUnit(nextSubComponentChildId)) {
+                        graph.removeRoot(nextSubComponentChildId);
+                    }
+                }
+            }
+            const movePinInto = (type, pinId) => {
+                // console.log('movePinInto', unitId, type, pinId)
+                if (!ignoredPin[type].has(pinId) && !unit.isPinIgnored(type, pinId)) {
+                    const nextPinId = (0, object_1.pathOrDefault)(nextPinMap, [type, pinId, 'pinId'], pinId);
+                    const mergeId = (0, object_1.pathOrDefault)(this._pinToMerge, [unitId, type, pinId], null);
+                    const swapMergePin = mergeId && !ignoredMerge.has(mergeId);
+                    if (swapMergePin) {
+                        const mergeToPin = {};
+                        (0, object_1.forEachObjKV)(pinToMerge, (unitId, value) => {
+                            (0, IOOf_1.forIOObjKV)(value, (type, pinId) => {
+                                (0, object_1.pathSet)(mergeToPin, [unitId, type, pinId], true);
+                            });
+                        });
+                        if ((0, util_1.getMergePinCount)(mergeToPin[mergeId]) > 1) {
+                            this._removePinFromMerge(mergeId, unitId, type, pinId, false);
+                        }
+                    }
+                    if (graph.hasPinNamed(type, nextPinId)) {
+                        //
+                    }
+                    else {
+                        (0, f_2.default)(this._spec[`${type}s`] || {}, ({ plug }, id) => {
+                            for (const subPinId in plug) {
+                                const subPinSpec = plug[subPinId];
+                                if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                                    this._unplugPin(type, id, subPinId);
+                                    break;
+                                }
+                            }
+                        });
+                    }
+                }
+            };
+            const inputs = unit.getInputNames();
+            for (const input_id of inputs) {
+                movePinInto('input', input_id);
+            }
+            const outputs = unit.getOutputNames();
+            for (const output_id of outputs) {
+                movePinInto('output', output_id);
+            }
+            this._removeUnit(unitId);
+        };
+        this._moveUnitInto__reconnect = (graphId, unitId, unit, nextUnitId, ignoredPin, ignoredMerge, nextPinMap, nextSubComponentParent, nextSubComponentChildren, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveUnitInto__reconnect',
+            //   graphId,
+            //   unitId,
+            //   nextUnitId,
+            //   ignoredPin,
+            //   ignoredMerge,
+            //   nextPinMap,
+            //   nextSubComponentParent,
+            //   nextSubComponentChildren
+            // )
+            const movePinInto = (type, pinId) => {
+                if (!ignoredPin[type].has(pinId) && !unit.isPinIgnored(type, pinId)) {
+                    const nextPinId = (0, object_1.pathOrDefault)(nextPinMap, [type, pinId, 'pinId'], pinId);
+                    const mergeId = (0, object_1.pathOrDefault)(pinToMerge, [unitId, type, pinId], null);
+                    const swapMergePin = mergeId && !ignoredMerge.has(mergeId);
+                    if (graph.hasPinNamed(type, nextPinId)) {
+                        //
+                    }
+                    else {
+                        if (swapMergePin) {
+                            const mergeToPin = {};
+                            (0, object_1.forEachObjKV)(pinToMerge, (unitId, value) => {
+                                (0, IOOf_1.forIOObjKV)(value, (type, pinId, mergeId) => {
+                                    (0, object_1.pathSet)(mergeToPin, [mergeId, unitId, type, pinId], true);
+                                });
+                            });
+                            const merge = mergeToPin[mergeId];
+                            if ((0, util_1.getMergePinCount)(merge) > 1) {
+                                if (!this.hasMerge(mergeId)) {
+                                    this._addMerge({}, mergeId);
+                                }
+                                this._addPinToMerge(mergeId, graphId, type, nextPinId, false);
+                            }
+                        }
+                        (0, f_2.default)(pinSpecs[type] || {}, ({ plug }, id) => {
+                            for (const subPinId in plug) {
+                                const subPinSpec = plug[subPinId];
+                                if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                                    this._plugPin(type, id, subPinId, {
+                                        unitId: graphId,
+                                        pinId: nextPinId,
+                                    });
+                                    break;
+                                }
+                            }
+                        });
+                    }
+                }
+            };
+            const inputs = unit.getInputNames();
+            for (const input_id of inputs) {
+                movePinInto('input', input_id);
+            }
+            const outputs = unit.getOutputNames();
+            for (const output_id of outputs) {
+                movePinInto('output', output_id);
+            }
+        };
+        this._moveUnitInto__inject = (graphId, unitId, unit, nextUnitId, ignoredPin, ignoredMerge, nextPinMap, nextSubComponentParent, nextSubComponentChildren, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveUnitInto',
+            //   graphId,
+            //   unitId,
+            //   nextUnitId,
+            //   ignoredPin,
+            //   ignoredMerge,
+            //   nextPinMap,
+            //   nextSubComponentParent,
+            //   nextSubComponentChildren
+            // )
+            graph.addUnit(nextUnitId, unit, false);
+            if (nextSubComponentParent) {
+                if (graph.hasUnit(nextSubComponentParent)) {
+                    graph.moveSubComponent(nextSubComponentParent, nextUnitId, 'default');
+                }
+            }
+            if (nextSubComponentChildren) {
+                for (const nextSubComponentChildId of nextSubComponentChildren) {
+                    if (graph.hasUnit(nextSubComponentChildId)) {
+                        graph.moveSubComponent(nextUnitId, nextSubComponentChildId, 'default');
+                    }
+                }
+            }
+            const movePinInto = (type, pinId) => {
+                if (!ignoredPin[type].has(pinId) && !unit.isPinIgnored(type, pinId)) {
+                    const { pinId: nextPinId, subPinId: nextSubPinId } = (0, object_1.pathOrDefault)(nextPinMap, [type, pinId], { pinId, subPinId: '0' });
+                    if (graph.hasPinNamed(type, nextPinId)) {
+                        graph.exposePin(type, nextPinId, nextSubPinId, {
+                            unitId: nextUnitId,
+                            pinId,
+                        }, false);
+                    }
+                    else {
+                        const unitPin = unit.getPin(type, pinId);
+                        const unitPinData = unitPin.peak();
+                        const unitPinRef = unit.hasRefPinNamed(type, pinId);
+                        const nextExposedPin = new Pin_1.Pin({ data: unitPinData });
+                        const nextExposedMerge = new Merge_1.default(this._system);
+                        graph.exposePinSet(type, nextPinId, {
+                            plug: {
+                                '0': {
+                                    unitId: nextUnitId,
+                                    pinId,
+                                },
+                            },
+                            ref: unitPinRef,
+                        }, false, nextExposedPin, nextExposedMerge, false);
+                    }
+                }
+            };
+            const inputs = unit.getInputNames();
+            for (const input_id of inputs) {
+                movePinInto('input', input_id);
+            }
+            const outputs = unit.getOutputNames();
+            for (const output_id of outputs) {
+                movePinInto('output', output_id);
+            }
+        };
+        this._getMergeUnitPinCount = (mergeId, unitId) => {
+            const merge = this.getMergeSpec(mergeId);
+            const mergeUnit = merge[unitId];
+            const count = (0, util_1.getMergeUnitPinCount)(mergeUnit);
+            return count;
+        };
+        this._moveLinkPinInto__remove = (graphId, unitId, type, pinId, oppositeMergeId, oppositePinId, subPinSpec = {}, ignoredUnit = new Set(), mergeIgnored, unitSpecs, units, mergeSpecs, merges, pinToMerge, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveLinkPinInto__remove',
+            //   graphId,
+            //   unitId,
+            //   type,
+            //   pinId,
+            //   oppositeMergeId,
+            //   oppositePinId,
+            //   subPinSpec
+            // )
+            //
+        };
+        this._moveLinkPinInto__inject = (graphId, unitId, type, pinId, oppositeMergeId, oppositePinId, subPinSpec = {}, ignoredUnit = new Set(), mergeIgnored, unitSpecs, units, mergeSpecs, merges, pinToMerge, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveLinkPinInto__inject',
+            //   graphId,
+            //   unitId,
+            //   type,
+            //   pinId,
+            //   oppositeMergeId,
+            //   oppositePinId,
+            //   subPinSpec
+            // )
+            if (graphId === unitId) {
+                //
+            }
+            else {
+                if (oppositeMergeId && oppositePinId) {
+                    const oppositeType = (0, util_1.opposite)(type);
+                    if (this.hasMerge(oppositeMergeId)) {
+                        //
+                    }
+                    else {
+                        const pin = this.getUnitPin(unitId, type, pinId);
+                        const exposedPin = new Pin_1.Pin({ data: pin.peak() });
+                        const exposedMerge = new Merge_1.default(this._system);
+                        if (graph.hasPinNamed(oppositeType, oppositePinId)) {
+                            //
+                        }
+                        else {
+                            const pinSpec = { plug: { '0': {} } };
+                            graph.exposePinSet(oppositeType, oppositePinId, pinSpec, false, exposedPin, exposedMerge, false);
+                        }
+                    }
+                }
+                else {
+                    //
+                }
+            }
+        };
+        this._moveLinkPinInto__reconnect = (graphId, unitId, type, pinId, oppositeMergeId, oppositePinId, subPinSpec = {}, ignoredUnit = new Set(), ignoredMerge, unitSpecs, units, mergeSpecs, merges, pinToMerge, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveLinkPinInto',
+            //   graphId,
+            //   unitId,
+            //   type,
+            //   pinId,
+            //   oppositeMergeId,
+            //   oppositePinId,
+            //   subPinSpec
+            // )
+            const localGraph = this.refGraph(graphId);
+            const mergeId = (0, object_1.pathOrDefault)(pinToMerge, [unitId, type, pinId], null);
+            if (graphId === unitId) {
+                if (mergeId) {
+                    const mergeSpec = mergeSpecs[mergeId];
+                    const mergeUnit = mergeSpec[unitId];
+                    const mergePinCount = (0, util_1.getMergePinCount)(mergeSpec);
+                    const unitMergePinCount = (0, util_1.getMergeUnitPinCount)(mergeUnit);
+                    if (mergePinCount - unitMergePinCount > 0) {
+                        //
+                    }
+                    else {
+                        localGraph.coverPinSet(type, pinId, false);
+                    }
+                }
+                else {
+                    localGraph.coverPinSet(type, pinId, false);
+                }
+            }
+            else {
+                if (oppositeMergeId && oppositePinId) {
+                    const oppositeType = (0, util_1.opposite)(type);
+                    if (this.hasMerge(oppositeMergeId)) {
+                        this._addPinToMerge(oppositeMergeId, unitId, type, pinId);
+                    }
+                    else {
+                        const merge = {
+                            [unitId]: {
+                                [type]: {
+                                    [pinId]: true,
+                                },
+                            },
+                            [graphId]: {
+                                [oppositeType]: {
+                                    [oppositePinId]: true,
+                                },
+                            },
+                        };
+                        this._addMerge(merge, oppositeMergeId, null, false);
+                    }
+                }
+                else {
+                    //
+                }
+            }
+        };
+        this._moveMergeInto = (graphId, mergeId, mergeSpec, nextInput, nextOutput, ignoredUnit = new Set(), ignoredMerge, nextExposedPin, graph, unitSpecs, units, mergeSpecs, merges, pinToMerge, pinSpecs) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveMergeInto',
+            //   graphId,
+            //   mergeId,
+            //   mergeSpec,
+            //   nextInput,
+            //   nextOutput,
+            //   ignoredUnit,
+            //   nextExposedPin
+            // )
+            this._moveMergeInto__remove(graphId, mergeId, mergeSpec, nextInput, nextOutput, ignoredUnit, ignoredMerge, nextExposedPin, graph, unitSpecs, units, mergeSpecs, pinToMerge, pinSpecs, merges);
+            this._moveMergeInto__inject(graphId, mergeId, mergeSpec, nextInput, nextOutput, ignoredUnit, ignoredMerge, nextExposedPin, unitSpecs, units, mergeSpecs, merges, pinToMerge, pinSpecs, graph);
+            this._moveMergeInto__reconnect(graphId, mergeId, mergeSpec, nextInput, nextOutput, ignoredUnit, ignoredMerge, nextExposedPin, unitSpecs, units, mergeSpecs, merges, pinToMerge, pinSpecs, graph);
+        };
+        this._moveMergeInto__remove = (graphId, mergeId, mergeSpec, nextInput, nextOutput, ignoredUnit = new Set(), mergeIgnored, nextExposedPin, graph, unitSpecs, units, mergeSpecs, pinToMerge, pinSpecs, merges) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveMergeInto__remove',
+            //   graphId,
+            //   mergeId,
+            //   mergeSpec,
+            //   nextInput,
+            //   nextOutput,
+            //   ignoredUnit,
+            //   nextExposedPin
+            // )
+            const moveLinkPinInto = (unitId, type, pinId) => {
+                if (ignoredUnit.has(unitId) || unitId === graphId) {
+                    return;
+                }
+                const isInput = type === 'input';
+                const { mergeId: nextMergeId, pinId: nextPinId, subPinSpec: nextSubPinSpec, } = isInput ? nextOutput : nextInput;
+                if (this.hasMerge(mergeId)) {
+                    this._removePinFromMerge(mergeId, unitId, type, pinId);
+                }
+                this._moveLinkPinInto__remove(graphId, unitId, type, pinId, nextMergeId, nextPinId, nextSubPinSpec, ignoredUnit, mergeIgnored, unitSpecs, units, mergeSpecs, merges, pinToMerge, graph);
+            };
+            (0, util_1.forEachPinOnMerge)(mergeSpec, moveLinkPinInto);
+            if (this.hasMerge(mergeId)) {
+                this._removeMerge(mergeId);
+            }
+        };
+        this._moveMergeInto__inject = (graphId, mergeId, mergeSpec, nextInput, nextOutput, ignoredUnit = new Set(), mergeIgnored, nextExposedPin, unitSpecs, units, mergeSpecs, merges, pinToMerge, pinSpecs, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveMergeInto',
+            //   graphId,
+            //   mergeId,
+            //   mergeSpec,
+            //   nextInput,
+            //   nextOutput,
+            //   ignoredUnit,
+            //   nextExposedPin
+            // )
+            let pinIntoCount = 0;
+            const localGraph = this.refGraph(graphId);
+            const nextMerge = {};
+            let allPinsAreGraphs = true;
+            const moveLinkPinInto = (unitId, type, pinId) => {
+                // if (ignoredUnit.has(unitId) || unitId === graphId) {
+                //   if (unitId === graphId) {
+                //     //
+                //   } else {
+                //     return
+                //   }
+                // }
+                if (ignoredUnit.has(unitId) || unitId === graphId) {
+                    if (unitId === graphId) {
+                        const pinSpec = localGraph.getExposedPinSpec(type, pinId);
+                        const { plug } = pinSpec;
+                        for (const subPinId in plug) {
+                            const subPin = plug[subPinId];
+                            if (subPin.unitId && subPin.pinId) {
+                                (0, object_1.pathSet)(nextMerge, [subPin.unitId, type, subPin.pinId], true);
+                            }
+                            else if (subPin.mergeId) {
+                                const mergeSpec = localGraph.getMergeSpec(subPin.mergeId);
+                                (0, util_1.forEachPinOnMerge)(mergeSpec, (unitId, type, pinId) => {
+                                    (0, object_1.pathSet)(nextMerge, [unitId, type, pinId], true);
+                                });
+                            }
+                        }
+                        pinIntoCount++;
+                    }
+                    else {
+                        allPinsAreGraphs = false;
+                        (0, object_1.pathSet)(nextMerge, [unitId, type, pinId], true);
+                        pinIntoCount++;
+                        return;
+                    }
+                }
+                const isInput = type === 'input';
+                const { mergeId: nextMergeId, pinId: nextPinId, subPinSpec: nextSubPinSpec, } = isInput ? nextOutput : nextInput;
+                this._moveLinkPinInto__inject(graphId, unitId, type, pinId, nextMergeId, nextPinId, nextSubPinSpec, ignoredUnit, mergeIgnored, unitSpecs, units, mergeSpecs, merges, pinToMerge, graph);
+            };
+            (0, util_1.forEachPinOnMerge)(mergeSpec, moveLinkPinInto);
+            if (pinIntoCount > 1) {
+                if (allPinsAreGraphs) {
+                    localGraph.addMerge(nextMerge, mergeId, null, false);
+                }
+                else {
+                    graph.addMerge(nextMerge, mergeId, null, false);
+                }
+            }
+            else {
+                // TODO
+                // AD HOC
+                // add identity
+            }
+        };
+        this._moveMergeInto__reconnect = (graphId, mergeId, mergeSpec, nextInput, nextOutput, ignoredUnit = new Set(), ignoredMerge, nextExposedPin, unitSpecs, units, mergeSpecs, merges, pinToMerge, pinSpecs, graph) => {
+            // console.log(
+            //   'Graph',
+            //   '_moveMergeInto__reconnect',
+            //   graphId,
+            //   mergeId,
+            //   mergeSpec,
+            //   nextInput,
+            //   nextOutput,
+            //   ignoredUnit,
+            //   nextExposedPin
+            // )
+            let pinIntoCount = 0;
+            const nextMerge = {};
+            const localGraph = this.refGraph(graphId);
+            const moveLinkPinInto = (unitId, type, pinId) => {
+                var _a;
+                if (ignoredUnit.has(unitId) || unitId === graphId) {
+                    if (unitId === graphId) {
+                        const pinSpec = localGraph.getExposedPinSpec(type, pinId);
+                        const { plug } = pinSpec;
+                        for (const subPinId in plug) {
+                            const subPin = plug[subPinId];
+                            if (subPin.unitId && subPin.pinId) {
+                                (0, object_1.pathSet)(nextMerge, [subPin.unitId, type, subPin.pinId], true);
+                            }
+                            else if (subPin.mergeId) {
+                                const mergeSpec = localGraph.getMergeSpec(subPin.mergeId);
+                                (0, util_1.forEachPinOnMerge)(mergeSpec, (unitId, type, pinId) => {
+                                    (0, object_1.pathSet)(nextMerge, [unitId, type, pinId], true);
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        (0, object_1.pathSet)(nextMerge, [unitId, type, pinId], true);
+                    }
+                    pinIntoCount++;
+                }
+                const isInput = type === 'input';
+                const { mergeId: nextMergeId, pinId: nextPinId, subPinSpec: nextSubPinSpec, } = (_a = (isInput ? nextOutput : nextInput)) !== null && _a !== void 0 ? _a : {};
+                this._moveLinkPinInto__reconnect(graphId, unitId, type, pinId, ignoredUnit.has(unitId) ? null : nextMergeId, ignoredUnit.has(unitId) ? null : nextPinId, ignoredUnit.has(unitId) ? null : nextSubPinSpec, ignoredUnit, ignoredMerge, unitSpecs, units, mergeSpecs, merges, pinToMerge, graph);
+            };
+            (0, util_1.forEachPinOnMerge)(mergeSpec, moveLinkPinInto);
+            if (nextInput) {
+                const { pinId, subPinSpec } = nextInput;
+                if (pinId && subPinSpec) {
+                    localGraph.exposePin('input', pinId, '0', subPinSpec, false);
+                }
+            }
+            if (nextOutput) {
+                const { pinId, subPinSpec } = nextOutput;
+                if (pinId && subPinSpec) {
+                    localGraph.exposePin('output', pinId, '0', subPinSpec);
+                }
+            }
+            (0, IOOf_1.forIO)(pinSpecs, (type, pinsSpec) => {
+                (0, object_1.forEachObjKV)(pinsSpec, (pinId, pinSpec) => {
+                    var _a;
+                    const { plug } = pinSpec;
+                    for (const subPinId in plug) {
+                        const subPin = plug[subPinId];
+                        if (subPin.mergeId === mergeId) {
+                            const isInput = type === 'input';
+                            const { mergeId: nextMergeId } = (_a = (isInput ? nextOutput : nextInput)) !== null && _a !== void 0 ? _a : {};
+                            if (this.hasPlug(type, pinId, subPinId)) {
+                                this._plugPin(type, pinId, subPinId, { mergeId: nextMergeId });
+                            }
+                        }
+                    }
+                });
+            });
+        };
+        this._isUnitComponent = (unitId) => {
+            const unit = this.refUnit(unitId);
+            const isComponent = unit instanceof Element_1.Element_ || (unit instanceof Graph && unit.isElement());
+            return isComponent;
+        };
+        this._root = [];
+        this._parent_root = [];
+        this._parent_children = [];
+        this._slot = {};
+        this._spec = spec;
+        this._specs = (_a = spec.specs) !== null && _a !== void 0 ? _a : {};
+        this._system = this.__system.boot({
+            specs: this._specs,
+        });
+        const { inputs = {}, outputs = {}, units = {}, merges = {}, component = {}, render = false, } = this._spec;
+        this._branch = branch;
+        this._initAddUnits(units);
+        this._initMerges(merges);
+        this._initInputSets(inputs);
+        this._initOutputSets(outputs);
+        this._initSetComponent(component);
+        this._element = render;
+        this.addListener('reset', this._reset);
+        this.addListener('play', this._play);
+        this.addListener('pause', this._pause);
+        this.addListener('destroy', this._destroy);
+        this.addListener('take_err', this._takeErr);
+        this.addListener('take_caught_err', this._takeErr);
+        const f_inputs = (0, object_1.filterObj)(inputs, ({ functional }) => !!functional);
+        const f_input_names = (0, f_4.keys)(f_inputs);
+        const waitAll = new WaitAll_1.WaitAll(this.__system);
+        this._waitAll = waitAll;
+        (0, array_1.forEach)(f_input_names, (name) => {
+            const inputPin = new Pin_1.Pin();
+            const outputPin = this.getExposedInputPin(name);
+            waitAll.addInput(name, inputPin);
+            waitAll.setOutput(name, outputPin);
+            this.setInput(name, inputPin, {});
+        });
+    }
+    _setBranch(mergeId, type, pinNodeId, emit) {
+        this._memSetBranch(mergeId, type, pinNodeId);
+        this._simSetBranch(mergeId, type, pinNodeId, emit);
+    }
+    _memSetBranch(mergeId, type, pinNodeId) {
+        if (type === 'input') {
+            this._pipedTo[pinNodeId] = mergeId;
+        }
+        else {
+            this._pipedFrom[pinNodeId] = mergeId;
+        }
+    }
+    _simSetBranch(mergeId, type, pinNodeId, propagate) {
+        // console.log('Graph', '_simSetBranch', mergeId, type, pinNodeId)
+        const merge = this._merge[mergeId];
+        if (type === 'input') {
+            const input = this._pin[pinNodeId];
+            merge.setOutput(pinNodeId, input, {}, propagate);
+        }
+        else {
+            const output = this._pin[pinNodeId];
+            merge.setInput(pinNodeId, output, {}, propagate);
+        }
+    }
+    _memRemoveBranch(mergeId, type, pinNodeId) {
+        if (type === 'input') {
+            delete this._pipedTo[pinNodeId];
+        }
+        else {
+            delete this._pipedFrom[pinNodeId];
+        }
+    }
+    _simRemoveBranch(mergeId, type, pinNodeId) {
+        // console.log('Graph', '_simRemoveBranch', mergeId, type, pinNodeId)
+        if (type === 'input') {
+            this._merge[mergeId].removeOutput(pinNodeId);
+        }
+        else {
+            this._merge[mergeId].removeInput(pinNodeId);
+        }
+    }
+    _removeBranch(mergeId, type, pinNodeId) {
+        this._simRemoveBranch(mergeId, type, pinNodeId);
+        this._memRemoveBranch(mergeId, type, pinNodeId);
+    }
+    setExposedSubPin(type, name, subPinId, subPin, opt) {
+        this._setExposedSubPin(type, name, subPinId, subPin, opt);
+        this.emit('set_exposed_sub_pin', type, name, subPinId, subPin, opt);
+    }
+    _setExposedSubPin(type, name, subPinId, subPin, opt) {
+        const oppositeType = (0, util_1.opposite)(type);
+        const exposedPinId = (0, util_1.getExposedPinId)(name, type);
+        const exposedMerge = this._exposedMerge[exposedPinId];
+        exposedMerge.setPin(subPinId, oppositeType, subPin, opt);
+    }
+    _memSetExposedSubPin(type, name, subPinId, subPin) {
+        // TODO
+    }
+    _simSetExposedSubPin(type, name, subPinId, subPin, propagate = true) {
+        // console.log('Graph', '_simSetExposedSubPin', type, name, subPinId, subPin, propagate)
+        const oppositeType = (0, util_1.opposite)(type);
+        const exposedPinId = (0, util_1.getExposedPinId)(name, type);
+        const exposedMerge = this._exposedMerge[exposedPinId];
+        exposedMerge.setPin(subPinId, oppositeType, subPin, {}, propagate);
+    }
+    _simRemoveExposedSubPin(type, name, subPinId) {
+        const oppositeType = (0, util_1.opposite)(type);
+        const exposedPinId = (0, util_1.getExposedPinId)(name, type);
+        const exposedMerge = this._exposedMerge[exposedPinId];
+        exposedMerge.removePin(oppositeType, subPinId);
+    }
+    _play() {
+        (0, f_2.default)(this._unit, (u) => u.play());
+        (0, array_1.forEach)(this._children, (c) => c.play());
+    }
+    _pause() {
+        (0, f_2.default)(this._unit, (u) => u.pause());
+        (0, array_1.forEach)(this._children, (c) => c.pause());
+    }
+    _removeErrUnit(unitId) {
+        // unit.takeErr()
+        const index = this._errUnitIds.indexOf(unitId);
+        this._errUnitIds.splice(index, 1);
+        if (index === 0) {
+            this._nextErr();
+        }
+    }
+    _validateMergeId(mergeId) {
+        if (!this._spec.merges[mergeId]) {
+            throw new MergeNotFoundError_1.MergeNotFoundError();
+        }
+    }
+    _validateUnitId(unitId) {
+        if (!this._spec.units[unitId]) {
+            throw new UnitNotFoundError_1.UnitNotFoundError();
+        }
+    }
+    isElement() {
+        return this._element;
+    }
+    setElement() {
+        this._element = true;
+        this.emit('element');
+    }
+    setNotElement() {
+        this._element = false;
+        this.emit('not_element');
+    }
+    getBundleSpec(deep = false) {
+        const { spec, specs } = (0, bundle_1.bundleSpec)((0, object_1.clone)(this._spec), this._system.specs);
+        let memory;
+        if (deep) {
+            memory = this.snapshot();
+            (0, object_1.forEachObjKV)(this._unit, (unitId, unit) => {
+                const unitMemory = unit.snapshot();
+                (0, object_1.pathSet)(spec, [unitId, 'memory'], unitMemory);
+            });
+        }
+        return { spec, specs };
+    }
+    getUnitBundleSpec() {
+        const { id } = this;
+        const { specs } = (0, bundle_1.bundleSpec)(this._spec, this._system.specs);
+        const memory = this.snapshot();
+        const inputPins = this.getInputs();
+        const outputPins = this.getOutputs();
+        const mapPins = (pins) => (0, object_1.mapObjKV)(pins, (name, pin) => {
+            const data = pin.peak();
+            return {
+                constant: pin.constant(),
+                ignored: pin.ignored(),
+                data: data === undefined ? undefined : (0, stringify_1.stringify)(data),
+            };
+        });
+        const input = mapPins(inputPins);
+        const output = mapPins(outputPins);
+        return { unit: { id, input, output, memory }, specs };
+    }
+    snapshotSelf() {
+        const state = { unit: {}, merge: {}, exposedMerge: {}, waitAll: null };
+        for (const unitId in this._unit) {
+            const unit = this._unit[unitId];
+            const unit_state = unit.snapshot();
+            state.unit[unitId] = unit_state;
+        }
+        for (const mergeId in this._merge) {
+            const merge = this._merge[mergeId];
+            const merge_state = merge.snapshot();
+            state.merge[mergeId] = merge_state;
+        }
+        for (const pinId in this._exposedMerge) {
+            const merge = this._exposedMerge[pinId];
+            const merge_state = merge.snapshot();
+            state.exposedMerge[pinId] = merge_state;
+        }
+        state.waitAll = this._waitAll.snapshot();
+        return state;
+    }
+    restoreSelf(state) {
+        super.restoreSelf(state);
+        for (const unitId in this._unit) {
+            const unit = this._unit[unitId];
+            const unit_state = state.unit[unitId];
+            unit.restore(unit_state);
+        }
+        for (const mergeId in this._merge) {
+            const merge = this._merge[mergeId];
+            const merge_state = state.merge[mergeId];
+            merge.restore(merge_state);
+        }
+        for (const exposedPinId in this._exposedMerge) {
+            const [type, pinId] = exposedPinId.split('/');
+            if (this.hasDataPinNamed(type, pinId)) {
+                const merge = this._exposedMerge[exposedPinId];
+                const merge_state = state.exposedMerge[exposedPinId];
+                merge.restore(merge_state);
+            }
+        }
+        this._waitAll.restore(state.waitAll);
+    }
+    getGraphUnitSpec(id) {
+        return this._spec.units[id];
+    }
+    isExposedOutput(pin) {
+        const outputs = this._spec.outputs || {};
+        const nodeId = this._getExposedSubPinNodeId('output', pin);
+        return (0, object_1.someObj)(outputs, ({ plug }) => {
+            return (0, object_1.someObj)(plug, (o) => this._getExposedSubPinNodeId('output', o) === nodeId);
+        });
+    }
+    getExposedOutput(pin) {
+        const outputs = this._spec.outputs || {};
+        const nodeId = this._getExposedSubPinNodeId('output', pin);
+        for (const outputId in outputs) {
+            const output = outputs[outputId];
+            const { plug } = output;
+            for (const subPinId in plug) {
+                const subPin = plug[subPinId];
+                if (this._getExposedSubPinNodeId('output', subPin) === nodeId) {
+                    return outputId;
+                }
+            }
+        }
+    }
+    _simExposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge, propagate = true) {
+        const { plug, ref } = pinSpec;
+        exposedMerge.setPin(pinId, type, exposedPin);
+        (0, f_2.default)(plug, (subPinSpec, subPinId) => {
+            this._simExposePin(type, pinId, subPinId, subPinSpec, propagate);
+        });
+        this.setPin(pinId, type, exposedPin, { ref });
+    }
+    setPinSetFunctional(type, name, functional) {
+        // TODO
+    }
+    setPinSetId(type, pinId, nextPinId) {
+        this._setPinSetId(type, pinId, nextPinId);
+        this.renamePin(type, pinId, nextPinId);
+    }
+    _setPinSetId(type, pinId, nextPinId) {
+        // console.log('Graph', '_setPinSetId', type, pinId, nextPinId)
+        const exposedPinId = (0, util_1.getExposedPinId)(pinId, type);
+        const nextExposedPinId = (0, util_1.getExposedPinId)(nextPinId, type);
+        const pinSpec = this._spec[`${type}s`][pinId];
+        delete this._spec[`${type}s`][pinId];
+        this._spec[`${type}s`][nextPinId] = pinSpec;
+        const exposedMerge = this._exposedMerge[exposedPinId];
+        delete this._exposedMerge[exposedPinId];
+        this._exposedMerge[nextExposedPinId] = exposedMerge;
+    }
+    isExposedInput(pin) {
+        const inputs = this._spec.inputs || {};
+        const pinNodeId = this._getExposedSubPinNodeId('input', pin);
+        return (0, object_1.someObj)(inputs, ({ plug }) => {
+            return (0, object_1.someObj)(plug, (i) => {
+                const exposedSubPinNodeId = this._getExposedSubPinNodeId('input', i);
+                return exposedSubPinNodeId === pinNodeId;
+            });
+        });
+    }
+    getExposedPinSpec(type, pinId) {
+        if (type === 'input') {
+            return this.getExposedInputSpec(pinId);
+        }
+        else {
+            return this.getExposedOutputSpec(pinId);
+        }
+    }
+    isExposedInputPinId(pinId) {
+        const inputs = this._spec.inputs || {};
+        return !!inputs[pinId];
+    }
+    isExposedOutputPinId(pinId) {
+        const outputs = this._spec.outputs || {};
+        return !!outputs[pinId];
+    }
+    getExposedInputSpec(pinId) {
+        const inputs = this._spec.inputs || {};
+        return inputs[pinId];
+    }
+    getExposedInputSpecs() {
+        const inputs = this._spec.inputs || {};
+        return inputs;
+    }
+    getExposedOutputSpec(pinId) {
+        const outputs = this._spec.outputs || {};
+        return outputs[pinId];
+    }
+    getExposedOutputSpecs() {
+        const outputs = this._spec.outputs || {};
+        return outputs;
+    }
+    hasUnit(id) {
+        return !!this._unit[id];
+    }
+    hasMerge(id) {
+        return !!this._merge[id];
+    }
+    hasPlug(type, pinId, subPinId) {
+        const pin = this.getSubPinSpec(type, pinId, subPinId);
+        return !!pin;
+    }
+    refUnit(id) {
+        if (!this._unit[id]) {
+            throw new Error('Cannot find unit');
+        }
+        return this._unit[id];
+    }
+    refGraph(id) {
+        const graph = this.refUnit(id);
+        return graph;
+    }
+    removeUnitGhost(unitId, nextUnitId, spec) {
+        const data = this._removeUnitGhost(unitId, nextUnitId, spec);
+        // TODO
+        // this.emit('remove_unit_ghost', unitId, nextUnitId, spec)
+        return data;
+    }
+    _removeUnitGhost(unitId, nextUnitId, spec) {
+        const { id: specId } = this._system.newSpec(spec);
+        const outerSpec = this._getUnitOuterSpec(unitId);
+        const unit = this._removeUnit(unitId);
+        this._addUnitBundleSpec(nextUnitId, { unit: { id: specId } });
+        (0, IOOf_1.forIOObjKV)(outerSpec.merges, (type, pinId, { mergeId, otherPin, exposedPin }) => {
+            if (otherPin) {
+                this._addMerge({
+                    [otherPin.unitId]: {
+                        [otherPin.type]: {
+                            [otherPin.pinId]: true,
+                        },
+                    },
+                    [nextUnitId]: {
+                        [type]: {
+                            [pinId]: true,
+                        },
+                    },
+                }, mergeId, null);
+            }
+            else {
+                this._addPinToMerge(mergeId, nextUnitId, type, pinId);
+            }
+            if (exposedPin) {
+                this._plugPin(exposedPin.type, exposedPin.pinId, exposedPin.subPinId, { mergeId });
+            }
+        });
+        (0, IOOf_1.forIOObjKV)(outerSpec.exposed, (type, pinId, outerPin) => {
+            this._plugPin(outerPin.type, outerPin.pinId, outerPin.subPinId, {
+                unitId: nextUnitId,
+                pinId,
+            });
+        });
+        const state = unit.snapshot();
+        return { spec_id: specId, state };
+    }
+    swapUnitGhost(unitId, nextUnitId, nextUnitBundle) {
+        // TODO merges and plugs
+        this._removeUnit(unitId);
+        this._addUnitBundleSpec(nextUnitId, nextUnitBundle);
+        const unit = this.refUnit(unitId);
+        const state = unit.snapshot();
+        const spec = (0, spec_1.emptySpec)({});
+        const { id: spec_id } = this._system.newSpec({});
+        return { spec_id, state };
+    }
+    getUnitByPath(path) {
+        let unit = this;
+        for (const id of path) {
+            unit = unit.refUnit(id);
+        }
+        return unit;
+    }
+    read() {
+        return this.getGraphState();
+    }
+    write(state) {
+        this.setGraphState(state);
+    }
+    setGraphState(state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const unit_id in state) {
+                const unit = this.refUnit(unit_id);
+                // TODO
+            }
+        });
+    }
+    getUnitState(unitId) {
+        const unit = this.refUnit(unitId);
+        // TODO
+        return null;
+    }
+    getGraphState() {
+        // TODO
+        const state = {};
+        return state;
+    }
+    getGraphChildren() {
+        const children = {};
+        for (const unitId in this._unit) {
+            const unit = this.refUnit(unitId);
+            if (unit instanceof Element_1.Element_ ||
+                (unit instanceof Graph && unit.isElement())) {
+                const unit_children = unit.refChildren();
+                if (unit_children !== undefined) {
+                    children[unitId] = unit_children;
+                }
+            }
+        }
+        return children;
+    }
+    getUnitPin(id, type, pinId) {
+        return this.refUnit(id).getPin(type, pinId);
+    }
+    getUnitPinData(id, type, pinId) {
+        return this.refUnit(id).getPinData();
+    }
+    getUnitInput(id, pinId) {
+        return this.refUnit(id).getInput(pinId);
+    }
+    getUnitOutput(id, pinId) {
+        return this.refUnit(id).getOutput(pinId);
+    }
+    setUnitErr(unitId, err) {
+        const unit = this.refUnit(unitId);
+        unit.err(err);
+    }
+    takeUnitErr(unitId) {
+        const unit = this.refUnit(unitId);
+        const err = unit.takeErr();
+        return err;
+    }
+    refMerges() {
+        return this._merge;
+    }
+    refPlugs() {
+        const plugs = {
+            input: {},
+            output: {},
+        };
+        this._forEachSpecPinPlug((type, pinId, subPinId, subPinSpec) => {
+            const oppositeType = (0, util_1.opposite)(type);
+            const exposedPinId = (0, util_1.getExposedPinId)(pinId, type);
+            const exposedMerge = this._exposedMerge[exposedPinId];
+            const plug = exposedMerge.getPin(oppositeType, subPinId);
+            (0, object_1.pathSet)(plugs, [type, pinId], plug);
+        });
+        return plugs;
+    }
+    refMerge(mergeId) {
+        return this._merge[mergeId];
+    }
+    refExposedMerges() {
+        return this._exposedMerge;
+    }
+    getUnitCount() {
+        return (0, f_4.keys)(this._unit).length;
+    }
+    getMergeCount() {
+        return (0, f_4.keys)(this._merge).length;
+    }
+    findMergeExposedSubPin(type, mergeId) {
+        let pinSpec = null;
+        this._forEachSpecPinOfType(type, (pinId, subPinId, subPinSpec) => {
+            const { mergeId } = subPinSpec;
+            if (subPinSpec.mergeId === mergeId) {
+                pinSpec = { pinId, subPinId };
+            }
+        });
+        return pinSpec;
+    }
+    getUnitsSpec() {
+        const { units } = this._spec;
+        return units;
+    }
+    getMergesSpec() {
+        const { merges = {} } = this._spec;
+        return merges;
+    }
+    getMergeSpec(mergeId) {
+        const { merges } = this._spec;
+        const merge = merges[mergeId];
+        return merge;
+    }
+    getMergeUnitCount(mergeId) {
+        const merge = this.getMergeSpec(mergeId);
+        return (0, f_4.keys)(merge).length;
+    }
+    getMergePinCount(mergeId) {
+        return this._mergePinCount[mergeId];
+    }
+    getPinPlugCount(type, pinId) {
+        const pinSpec = this.getExposedPinSpec(type, pinId);
+        const count = (0, object_1._keyCount)(pinSpec.plug || {});
+        return count;
+    }
+    _fork() {
+        var _a;
+        if (this._spec.system || ((_a = this.__system.specsCount[this.id]) !== null && _a !== void 0 ? _a : 0) > 1) {
+            // console.log('_fork', this._spec.name, this._spec.id)
+            const [id, spec] = this._system.forkSpec(this._spec);
+            this.id = id;
+            this._spec = spec;
+            this._system.registerUnit(this);
+            this.emit('fork', id);
+            this.emit('leaf_fork', id, []);
+        }
+    }
+    _initAddUnit(unitId, unit) {
+        const _unit = (0, unitFromSpec_1.unitFromBundleSpec)({ unit }, this._branch, this._system);
+        this._memAddUnit(unitId, _unit);
+        this._simAddUnit(unitId, unit, _unit);
+    }
+    _initAddUnits(units) {
+        (0, f_2.default)(units, (unit, unitId) => {
+            this._initAddUnit(unitId, unit);
+        });
+    }
+    addUnitSpec(unitId, unitSpec, emit = true) {
+        // console.log('Graph', 'addUnit', unitSpec, unitId)
+        const unit = (0, unitFromSpec_1.unitFromBundleSpec)(unitSpec, this._branch, this._system);
+        this.addUnit(unitId, unit, emit);
+        return unit;
+    }
+    _addUnitBundleSpec(unitId, unitBundle) {
+        // console.log('Graph', '_addUnitBundleSpec', unitId, unitBundle)
+        const unit = (0, unitFromSpec_1.unitFromBundleSpec)(unitBundle, this._branch, this._system);
+        this._addUnit(unitId, unit);
+        return unit;
+    }
+    _initAddUnitBundleSpecs(unitBundles) {
+        // console.log('Graph', '_initAddUnitBundleSpecs', unitId, unitBundle)
+        (0, object_1.forEachObjKV)(unitBundles, (unitId, unitBundle) => {
+            this._initAddUnitBundleSpec(unitId, unitBundle);
+        });
+    }
+    _initAddUnitBundleSpec(unitId, unitBundle) {
+        // console.log('Graph', '_initAddUnitBundleSpec', unitId, unitBundle)
+        const unit = (0, unitFromSpec_1.unitFromBundleSpec)(unitBundle, this._branch, this._system);
+        this._initAddUnit(unitId, unit);
+        return unit;
+    }
+    onUnitErr(unitId, err) {
+        const index = this._errUnitIds.indexOf(unitId);
+        if (index > -1) {
+            if (index === 0) {
+                this.err(err);
+            }
+        }
+        else {
+            this._errUnitIds.push(unitId);
+            if (this._errUnitIds.length === 1) {
+                this.err(err);
+            }
+        }
+    }
+    _specAddUnit(unitId, unit) {
+        // console.log('Graph', '_specAddUnit', unitId, unit)
+        const { unit: unitSpec } = unit.getUnitBundleSpec();
+        (0, object_1.pathSet)(this._spec, ['units', unitId], unitSpec);
+        if (unit instanceof Element_1.Element_ ||
+            (unit instanceof Graph && unit.isElement())) {
+            this._specInjectSubComponent(unitId);
+            this._specAppendRoot(unitId);
+        }
+    }
+    _memAddUnit(unitId, unit) {
+        // console.log('Graph', '_memAddUnit', unitId, unit)
+        this.emit('before_add_unit', unitId, unit);
+        const { unit: unitSpec } = unit.getUnitBundleSpec();
+        const all_unlisten = [];
+        unit.setParent(this);
+        this._unit[unitId] = unit;
+        const set_unit_pin = (type, pinId) => {
+            const pinNodeId = (0, util_1.getPinNodeId)(unitId, type, pinId);
+            const pin = unit.getPin(type, pinId);
+            this._pin[pinNodeId] = pin;
+            this._unitPins[pinNodeId] = pin;
+        };
+        const set_unit_input = (pinId) => {
+            set_unit_pin('input', pinId);
+        };
+        const set_unit_output = (pinId) => {
+            set_unit_pin('output', pinId);
+        };
+        const remove_unit_pin = (type, pinId) => {
+            const pinNodeId = (0, util_1.getPinNodeId)(unitId, type, pinId);
+            // RETURN
+            // const mergeId = this._pipedTo[pinNodeId]
+            // if (mergeId) {
+            //   this._removePinFromMerge(mergeId, unitId, type, pinId)
+            // }
+            delete this._pin[pinNodeId];
+            delete this._unitPins[pinNodeId];
+        };
+        const remove_unit_input = (pinId) => {
+            remove_unit_pin('input', pinId);
+        };
+        const remove_unit_output = (pinId) => {
+            remove_unit_pin('output', pinId);
+        };
+        const inputs = unit.getInputNames();
+        (0, array_1.forEach)(inputs, set_unit_input);
+        all_unlisten.push(unit.addListener('set_input', set_unit_input));
+        all_unlisten.push(unit.addListener('remove_input', remove_unit_input));
+        const outputs = unit.getOutputNames();
+        (0, array_1.forEach)(outputs, set_unit_output);
+        all_unlisten.push(unit.addListener('set_output', set_unit_output));
+        all_unlisten.push(unit.addListener('remove_output', remove_unit_output));
+        const selfPinNodeId = (0, util_1.getOutputNodeId)(unitId, SELF_1.SELF);
+        const selfPin = unit.getSelfPin();
+        this._pin[selfPinNodeId] = selfPin;
+        const on_unit_err = (err) => {
+            this.onUnitErr(unitId, err);
+        };
+        all_unlisten.push(unit.addListener('err', on_unit_err));
+        const on_unit_err_removed = () => {
+            const index = this._errUnitIds.indexOf(unitId);
+            if (index > -1) {
+                this._errUnitIds.splice(index, 1);
+                if (index === 0) {
+                    this.takeErr();
+                    this._nextErr();
+                }
+            }
+        };
+        all_unlisten.push(unit.prependListener('take_err', on_unit_err_removed));
+        all_unlisten.push(unit.prependListener('catch_err', on_unit_err_removed));
+        if (unit instanceof Graph) {
+            all_unlisten.push(unit.addListener('leaf_add_unit', (unit, path) => {
+                this.emit('leaf_add_unit', unit, [...path, unitId]);
+            }));
+            all_unlisten.push(unit.addListener('leaf_remove_unit', (unit, path) => {
+                this.emit('leaf_remove_unit', unit, [...path, unitId]);
+            }));
+            all_unlisten.push(unit.addListener('leaf_expose_pin_set', (path, type, pinId, pinSpec) => {
+                this.emit('leaf_expose_pin_set', [...path, unitId], type, pinId, pinSpec);
+            }));
+            all_unlisten.push(unit.addListener('leaf_cover_pin_set', (path, type, pinId) => {
+                const pinSpec = unit.getExposedPinSpec(type, pinId);
+                this.emit('leaf_cover_pin_set', [...path, unitId], type, pinId, pinSpec);
+            }));
+            all_unlisten.push(unit.addListener('leaf_inject_graph', (bundle, path) => {
+                this.emit('leaf_inject_graph', bundle, [...path, unitId]);
+            }));
+        }
+        if (unit instanceof Element_1.Element_) {
+            // this.injectSubComponent(unitId, unitSpec, unit)
+        }
+        if (unit instanceof Graph) {
+            if (unit.isElement()) {
+                // this.injectSubComponent(unitId, unitSpec, unit)
+                all_unlisten.push(unit.addListener('element', () => {
+                    this._on_unit_element(unitId, unitSpec, unit);
+                }));
+                all_unlisten.push(unit.addListener('not_element', () => {
+                    this._on_unit_not_element(unitId);
+                }));
+                all_unlisten.push(unit.addListener('leaf_append_child', ({ bundle, path }) => {
+                    this.emit('leaf_append_child', { bundle, path: [unitId, ...path] });
+                }));
+                all_unlisten.push(unit.addListener('leaf_insert_child', ({ bundle, path }) => {
+                    this.emit('leaf_append_child', { bundle, path: [unitId, ...path] });
+                }));
+                all_unlisten.push(unit.addListener('leaf_remove_child', ({ at, path }) => {
+                    this.emit('leaf_remove_child', { at, path: [unitId, ...path] });
+                }));
+            }
+        }
+        const unlisten = (0, callAll_1.callAll)(all_unlisten);
+        this._unitUnlisten[unitId] = unlisten;
+    }
+    _simAddUnit(unitId, unitSpec, unit) {
+        if (unit instanceof Element_1.Element_ ||
+            (unit instanceof Graph && unit.isElement())) {
+            this._simInjectSubComponent(unitId, unitSpec, unit);
+        }
+        if (unit.hasErr()) {
+            this.onUnitErr(unitId, unit.getErr());
+        }
+        if (!this._paused) {
+            unit.play();
+        }
+    }
+    removeUnit(unitId, emit = true) {
+        const unit = this._removeUnit(unitId);
+        emit && this.emit('remove_unit', unitId, unit);
+        emit && this.emit('leaf_remove_unit', unit, [unitId]);
+        return unit;
+    }
+    cloneUnit(unitId, newUnitId) {
+        const newUnit = this._cloneUnit(unitId, newUnitId);
+        this.emit('clone_unit', unitId, newUnitId);
+        return newUnit;
+    }
+    _cloneUnit(unitId, newUnitId) {
+        const unit = this.refUnit(unitId);
+        const newUnit = (0, cloneUnit_1.cloneUnit)(unit);
+        this._addUnit(newUnitId, newUnit);
+        if (!this._paused) {
+            newUnit.play();
+        }
+        return newUnit;
+    }
+    _moveUnit(id, unitId, inputId) {
+        const fromUnit = this.refUnit(id);
+        const isUnitComponent = this._isUnitComponent(id);
+        this._simRemoveUnit(id);
+        this._memRemoveUnit(id);
+        this._specRemoveUnit(id, isUnitComponent);
+        const toUnit = this.refUnit(unitId);
+        toUnit.push(inputId, fromUnit);
+    }
+    moveUnit(id, unitId, inputId) {
+        this._moveUnit(id, unitId, inputId);
+        this.emit('move_unit', id, unitId, inputId);
+    }
+    removeUnitFromMerge(unitId, mergeId) {
+        this._removeUnitFromMerge(unitId, mergeId);
+        this.emit('remove_unit_from_merge', unitId, mergeId);
+    }
+    _removeUnitFromMerges(unitId) {
+        this._simRemoveUnitFromMerges(unitId);
+        this._memRemoveUnitFromMerges(unitId);
+    }
+    _memRemoveUnitFromMerges(unitId) {
+        const merges = this._unitToMerge[unitId];
+        for (const mergeId of merges) {
+            this._memRemoveUnitFromMerge(unitId, mergeId);
+        }
+    }
+    _simRemoveUnitFromMerges(unitId) {
+        const merges = this._unitToMerge[unitId];
+        for (const mergeId of merges) {
+            this._simRemoveUnitFromMerge(unitId, mergeId);
+        }
+    }
+    _removeUnitFromMerge(unitId, mergeId) {
+        this._simRemoveUnitFromMerge(unitId, mergeId);
+        this._memRemoveUnitFromMerge(unitId, mergeId);
+    }
+    _memRemoveUnitFromMerge(unitId, mergeId) {
+        this._forEachUnitPinOnMerge(unitId, mergeId, (type, pinId) => {
+            this._memRemovePinFromMerge(mergeId, unitId, type, pinId);
+        });
+    }
+    _simRemoveUnitFromMerge(unitId, mergeId) {
+        this._forEachUnitPinOnMerge(unitId, mergeId, (type, pinId) => {
+            this._simRemovePinFromMerge(mergeId, unitId, type, pinId);
+        });
+    }
+    _specRemoveUnitFromMerge(unitId, mergeId) {
+        this._forEachUnitPinOnMerge(unitId, mergeId, (type, pinId) => {
+            this._specRemovePinFromMerge(mergeId, unitId, type, pinId);
+        });
+    }
+    _forEachUnitPinOnMerge(unitId, mergeId, callback) {
+        const merge = this.getMergeSpec(mergeId);
+        const mergeUnit = (0, object_1.clone)(merge[unitId]);
+        (0, IOOf_1.forIOObjKV)(mergeUnit, (type, pinId) => {
+            callback(type, pinId);
+        });
+    }
+    _removeUnit(unitId) {
+        this._fork();
+        const unit = this.refUnit(unitId);
+        const isComponent = this._isUnitComponent(unitId);
+        this._simRemoveUnit(unitId);
+        this._memRemoveUnit(unitId);
+        this._specRemoveUnit(unitId, isComponent);
+        return unit;
+    }
+    _specRemoveUnit(unitId, removeComponent) {
+        // console.log('Graph', '_specRemoveUnit', unitId, removeComponent)
+        if (removeComponent) {
+            this._specRemoveSubComponent(unitId);
+            this._specComponentRemoveChild(unitId);
+        }
+        this._specUnplugUnit(unitId);
+        delete this._spec.units[unitId];
+    }
+    _memRemoveUnit(unitId, removeFromMerge = true) {
+        this.emit('before_remove_unit', unitId);
+        const unit = this.refUnit(unitId);
+        const unlisten = this._unitUnlisten[unitId];
+        unlisten();
+        if (removeFromMerge) {
+            this._memUnplugUnit(unitId);
+        }
+        unit.setParent(null);
+        delete this._unitUnlisten[unitId];
+        delete this._pinToMerge[unitId];
+        delete this._unit[unitId];
+    }
+    _memUnplugUnit(unitId) {
+        const unitToMerge = (0, object_1.clone)(this._unitToMerge[unitId] || new Set());
+        const unitToMergeCount = (0, object_1.clone)(this._unitToMergeCount[unitId] || {});
+        for (const mergeId of unitToMerge) {
+            const unitMergeCount = unitToMergeCount[mergeId];
+            const mergePinCount = this.getMergePinCount(mergeId);
+            if (mergePinCount - unitMergeCount < 2) {
+                this._memRemoveMerge(mergeId);
+            }
+            else {
+                this._memRemoveUnitFromMerge(unitId, mergeId);
+            }
+        }
+    }
+    _simAddMerge(mergeId, mergeSpec, merge, propagate) {
+        (0, f_2.default)(mergeSpec, ({ input, output }, unitId) => {
+            (0, f_2.default)(input || {}, (_, inputId) => {
+                this._simAddPinToMerge(mergeId, unitId, 'input', inputId, propagate);
+            });
+            (0, f_2.default)(output || {}, (_, outputId) => {
+                this._simAddPinToMerge(mergeId, unitId, 'output', outputId, propagate);
+            });
+        });
+    }
+    _simAddPinToMerge(mergeId, unitId, type, pinId, propagate = true) {
+        (0, f_2.default)((this._spec[`${type}s`] || {}), ({ plug }, id) => {
+            for (const subPinId in plug) {
+                const subPinSpec = plug[subPinId];
+                if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                    if (type === 'output' && pinId === SELF_1.SELF) {
+                        continue;
+                    }
+                    this._simUnplugPin(type, id, subPinId);
+                    this._simPlugPin(type, id, subPinId, { mergeId });
+                }
+            }
+        });
+        const pinNodeId = (0, util_1.getPinNodeId)(unitId, type, pinId);
+        this._simSetBranch(mergeId, type, pinNodeId, propagate);
+    }
+    _specAddPinToMerge(mergeId, unitId, type, pinId) {
+        // console.log('Graph', '_specAddPinToMerge', mergeId, unitId, type, pinId)
+        (0, object_1.pathSet)(this._spec, ['merges', mergeId, unitId, type, pinId], true);
+        (0, f_2.default)((this._spec[`${type}s`] || {}), ({ plug }, id) => {
+            for (const subPinId in plug) {
+                const subPinSpec = plug[subPinId];
+                if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                    this._specUnplugPin(type, id, subPinId);
+                    this._specPlugPin(type, id, subPinId, { mergeId });
+                }
+            }
+        });
+    }
+    _memAddPinToMerge(mergeId, unitId, type, pinId) {
+        // console.log('Graph', '_memAddPinToMerge', mergeId, unitId, type, pinId)
+        if (type === 'output' && pinId === SELF_1.SELF) {
+            this._mergeToSelfUnit[mergeId] = unitId;
+            this._selfUniToMerge[unitId] = mergeId;
+        }
+        // TODO duplicated
+        this._mergePinCount[mergeId] = this._mergePinCount[mergeId] || 0;
+        this._mergePinCount[mergeId]++;
+        this._unitToMerge[unitId] = this._unitToMerge[unitId] || new Set();
+        this._unitToMerge[unitId].add(mergeId);
+        this._unitToMergeCount[unitId] = this._unitToMergeCount[unitId] || {};
+        this._unitToMergeCount[unitId][mergeId] =
+            this._unitToMergeCount[unitId][mergeId] || 0;
+        this._unitToMergeCount[unitId][mergeId]++;
+        (0, object_1.pathSet)(this._pinToMerge, [unitId, type, pinId], mergeId);
+        (0, f_2.default)((this._spec[`${type}s`] || {}), ({ plug }, id) => {
+            for (const subPinId in plug) {
+                const subPinSpec = plug[subPinId];
+                if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                    if (type === 'output' && pinId === SELF_1.SELF) {
+                        continue;
+                    }
+                    this._memUnplugPin(type, id, subPinId);
+                    this._memPlugPin(type, id, subPinId, { mergeId });
+                }
+            }
+        });
+        const pinNodeId = (0, util_1.getPinNodeId)(unitId, type, pinId);
+        this._memSetBranch(mergeId, type, pinNodeId);
+    }
+    _memRemoveMerge(mergeId) {
+        // console.log('Graph', '_memRemoveMerge', mergeId)
+        this.emit('before_remove_merge', mergeId);
+        this._memRemoveAllMergePlug(mergeId);
+        this._memRemoveAllMergePin(mergeId);
+        this._memRemoveAllMergeRef(mergeId);
+    }
+    _specRemoveMerge(mergeId) {
+        this._specRemoveAllMergePlug(mergeId);
+        this._specRemoveAllMergePin(mergeId);
+        this._specRemoveAllMergeRef(mergeId);
+    }
+    _memRemoveAllMergePlug(mergeId) {
+        this._forEachSpecPinPlug((type, id, subPinId, subPinSpec) => {
+            if (subPinSpec.mergeId === mergeId) {
+                this._memUnplugPin(type, id, subPinId);
+            }
+        });
+    }
+    _specRemoveAllMergePlug(mergeId) {
+        this._forEachSpecPinPlug((type, id, subPinId, subPinSpec) => {
+            if (subPinSpec.mergeId === mergeId) {
+                this._specUnplugPin(type, id, subPinId);
+            }
+        });
+    }
+    _memRemoveAllMergeRef(mergeId) {
+        const selfUnitId = this._mergeToSelfUnit[mergeId];
+        if (selfUnitId) {
+            delete this._mergeToSelfUnit[mergeId];
+            delete this._selfUniToMerge[selfUnitId];
+        }
+        delete this._merge[mergeId];
+        delete this._mergePinCount[mergeId];
+    }
+    _specRemoveAllMergeRef(mergeId) {
+        delete this._spec.merges[mergeId];
+    }
+    _memRemoveAllMergePin(mergeId) {
+        const merge = (0, object_1.clone)(this._spec.merges[mergeId]);
+        (0, f_2.default)(merge, ({ input, output }, unitId) => {
+            (0, f_2.default)(input || {}, (_, inputId) => {
+                this._memRemovePinFromMerge(mergeId, unitId, 'input', inputId);
+            });
+            (0, f_2.default)(output || {}, (_, outputId) => {
+                this._memRemovePinFromMerge(mergeId, unitId, 'output', outputId);
+            });
+        });
+    }
+    _specRemoveAllMergePin(mergeId) {
+        const merge = (0, object_1.clone)(this._spec.merges[mergeId]);
+        (0, f_2.default)(merge, ({ input, output }, unitId) => {
+            (0, f_2.default)(input || {}, (_, inputId) => {
+                this._specRemovePinFromMerge(mergeId, unitId, 'input', inputId);
+            });
+            (0, f_2.default)(output || {}, (_, outputId) => {
+                this._specRemovePinFromMerge(mergeId, unitId, 'output', outputId);
+            });
+        });
+    }
+    _memPostRemoveMerge(mergeId) {
+        this._forEachSpecPinPlug((type, pinId, subPinId, subPinSpec) => {
+            if (subPinSpec.mergeId === mergeId) {
+                this._memPlugEmptyPin(type, pinId, subPinId);
+            }
+        });
+    }
+    memIsUnitRefPin(unitId, type, pinId) {
+        const unit = this.refUnit(unitId);
+        const isRefPin = unit.hasRefPinNamed(type, pinId);
+        return isRefPin;
+    }
+    _getUnitSpec(unitId) {
+        const graphUnitSpec = this.getGraphUnitSpec(unitId);
+        const { id } = graphUnitSpec;
+        const unitSpec = this._system.getSpec(id);
+        return unitSpec;
+    }
+    isUnitRefPin(unitId, type, pinId) {
+        const unitSpec = this._getUnitSpec(unitId);
+        const isRefPin = (0, object_1.pathOrDefault)(unitSpec, [`${type}s`, pinId, 'ref'], false);
+        return isRefPin;
+    }
+    isUnitRefInput(unitId, name) {
+        const unit = this.refUnit(unitId);
+        const isRefPin = unit.hasRefInputNamed(name);
+        return isRefPin;
+    }
+    removeMerge(mergeId, emit = true) {
+        // console.log('Graph', 'removeMerge', mergeId)
+        this._removeMerge(mergeId);
+        emit && this.emit('remove_merge', mergeId);
+    }
+    _removeMerge(mergeId) {
+        // console.log('Graph', 'removeMerge', mergeId)
+        this._validateMergeId(mergeId);
+        this._simRemoveMerge(mergeId);
+        this._memRemoveMerge(mergeId);
+        this._specRemoveMerge(mergeId);
+        this._memPostRemoveMerge(mergeId);
+        this._simPostRemoveMerge(mergeId);
+    }
+    _simRemoveMerge(mergeId) {
+        // console.log('Graph', '_simRemoveMerge', mergeId)
+        this._simRemoveAllPlugsFromMerge(mergeId);
+        this._simRemoveAllPinsFromMerge(mergeId);
+    }
+    _simPostRemoveMerge(mergeId) {
+        this._forEachSpecPinPlug((type, pinId, subPinId, subPinSpec) => {
+            if (subPinSpec.mergeId === mergeId) {
+                this._simPlugEmptyPin(type, pinId, subPinId);
+            }
+        });
+    }
+    removePinFromMerge(mergeId, unitId, type, pinId) {
+        this._removePinFromMerge(mergeId, unitId, type, pinId, false);
+        this.emit('remove_pin_from_merge', mergeId, unitId, type, pinId);
+    }
+    _removePinFromMerge(mergeId, unitId, type, pinId, propagate = true) {
+        this._validateMergeId(mergeId);
+        this._validateUnitId(unitId);
+        this._simRemovePinFromMerge(mergeId, unitId, type, pinId, propagate);
+        this._memRemovePinFromMerge(mergeId, unitId, type, pinId);
+        this._specRemovePinFromMerge(mergeId, unitId, type, pinId);
+    }
+    _memRemovePinFromMerge(mergeId, unitId, type, pinId) {
+        // console.log('Graph', '_memRemovePinFromMerge', mergeId, unitId, type, pinId)
+        var _a, _b, _c, _d, _e, _f;
+        const pinNodeId = (0, util_1.getPinNodeId)(unitId, type, pinId);
+        this._memRemoveBranch(mergeId, type, pinNodeId);
+        if (type === 'input') {
+            //
+        }
+        else {
+            if (pinId === SELF_1.SELF) {
+                delete this._mergeToSelfUnit[mergeId];
+                delete this._selfUniToMerge[unitId];
+            }
+        }
+        this._mergePinCount[mergeId]--;
+        this._unitToMergeCount[unitId][mergeId]--;
+        if (this._unitToMergeCount[unitId][mergeId] === 0) {
+            delete this._unitToMergeCount[unitId][mergeId];
+            this._unitToMerge[unitId].delete(mergeId);
+        }
+        (_b = (_a = this._pinToMerge[unitId]) === null || _a === void 0 ? void 0 : _a[type]) === null || _b === void 0 ? true : delete _b[pinId];
+        if ((0, object_1.isEmptyObject)((_d = (_c = this._pinToMerge[unitId]) === null || _c === void 0 ? void 0 : _c[type]) !== null && _d !== void 0 ? _d : {})) {
+            (_e = this._pinToMerge[unitId]) === null || _e === void 0 ? true : delete _e[type];
+        }
+        if ((0, object_1.isEmptyObject)((_f = this._pinToMerge[unitId]) !== null && _f !== void 0 ? _f : {})) {
+            delete this._pinToMerge[unitId];
+        }
+    }
+    _specRemovePinFromMerge(mergeId, unitId, type, pinId) {
+        // console.log(
+        //   'Graph',
+        //   '_specRemovePinFromMerge',
+        //   mergeId,
+        //   unitId,
+        //   type,
+        //   pinId
+        // )
+        delete this._spec.merges[mergeId][unitId][type][pinId];
+        if ((0, object_1.isEmptyObject)(this._spec.merges[mergeId][unitId][type])) {
+            delete this._spec.merges[mergeId][unitId][type];
+        }
+        if ((0, object_1.isEmptyObject)(this._spec.merges[mergeId][unitId])) {
+            delete this._spec.merges[mergeId][unitId];
+        }
+    }
+    _simRemovePinFromMerge(mergeId, unitId, type, pinId, take = true) {
+        const pinNodeId = (0, util_1.getPinNodeId)(unitId, type, pinId);
+        this._simRemoveBranch(mergeId, type, pinNodeId);
+        if (take) {
+            if (type === 'input') {
+                if (this._mergeToSelfUnit[mergeId] ||
+                    this.isUnitRefInput(unitId, pinId)) {
+                    const pin = this._pin[pinNodeId];
+                    pin.take();
+                }
+            }
+            else {
+                if (pinId === SELF_1.SELF) {
+                    const merge = this._merge[mergeId];
+                    (0, f_2.default)(merge.getOutputs(), (pin, name) => {
+                        merge.takeOutput(name);
+                    });
+                }
+            }
+        }
+    }
+    mergeMerges(mergeIds) {
+        this._mergeMerges(mergeIds);
+        this.emit('merge_merges', mergeIds);
+    }
+    _mergeMerges(mergeIds) {
+        const firstMergeId = mergeIds[0];
+        (0, array_1.forEach)(mergeIds.splice(1), (mergeId) => {
+            const mergeSpec = (0, object_1.clone)(this._spec.merges[mergeId]);
+            (0, util_1.forEachPinOnMerge)(mergeSpec, (unitId, type, pinId) => {
+                this._removePinFromMerge(mergeId, unitId, type, pinId);
+                this._addPinToMerge(firstMergeId, unitId, type, pinId);
+            });
+        });
+    }
+    isPinMergedTo(mergeId, unitId, type, pinId) {
+        const merges = this._spec.merges || {};
+        return (!!merges[mergeId] &&
+            merges[mergeId][unitId] &&
+            merges[mergeId][unitId][type] &&
+            merges[mergeId][unitId][type][pinId]);
+    }
+    setUnitPinConstant(unitId, type, pinId, constant) {
+        if (type === 'input') {
+            this.setUnitInputConstant(unitId, pinId, constant);
+        }
+        else {
+            this.setUnitOutputConstant(unitId, pinId, constant);
+        }
+    }
+    setUnitInputConstant(unitId, pinId, constant) {
+        (0, object_1.pathSet)(this._spec, ['units', unitId, 'input', pinId], constant);
+        const unit = this.refUnit(unitId);
+        unit.setInputConstant(pinId, constant);
+    }
+    setUnitOutputConstant(unitId, pinId, constant) {
+        (0, object_1.pathSet)(this._spec, ['units', unitId, 'output', pinId], constant);
+        const unit = this.refUnit(unitId);
+        unit.setOutputConstant(pinId, constant);
+    }
+    setUnitInputIgnored(unitId, pinId, ignored) {
+        this.setUnitPinIgnored(unitId, 'input', pinId, ignored);
+    }
+    setUnitOutputIgnored(unitId, pinId, ignored) {
+        this.setUnitPinIgnored(unitId, 'output', pinId, ignored);
+    }
+    setUnitPinIgnored(unitId, type, pinId, ignored) {
+        const unit = this.refUnit(unitId);
+        if (ignored) {
+            (0, util_1.forEachPinOnMerges)(this._spec.merges, (mergeId, _unitId, _type, _pinId) => {
+                if (_unitId === unitId && _type === type && _pinId === pinId) {
+                    this._removePinFromMerge(mergeId, unitId, type, pinId);
+                }
+            });
+            // TODO perf
+            (0, f_2.default)(this._spec[`${type}s`] || {}, ({ plug }, id) => {
+                for (const subPinId in plug) {
+                    const subPinSpec = plug[subPinId];
+                    if (subPinSpec.unitId === unitId && subPinSpec.pinId === pinId) {
+                        this._unplugPin(type, id, subPinId);
+                        break;
+                    }
+                }
+            });
+        }
+        unit.setPinIgnored(type, pinId, ignored);
+    }
+    setUnitName(unitId, name) {
+        const unit = this._removeUnit(unitId);
+        this._addUnit(name, unit);
+    }
+    setUnitPinData(unitId, type, pinId, data) {
+        const unit = this.refUnit(unitId);
+        unit.setPinData(type, pinId, data);
+    }
+    setUnitInputData(unitId, pinId, data) {
+        const unit = this.refUnit(unitId);
+        unit.setPinData('input', pinId, data);
+    }
+    setUnitOutputData(unitId, pinId, data) {
+        const unit = this.refUnit(unitId);
+        unit.setPinData('output', pinId, data);
+    }
+    setMetadata(path, data) {
+        let cursor = this._spec;
+        let i = 0;
+        while (i < path.length - 1) {
+            const p = path[i];
+            if (!cursor[p]) {
+                cursor[p] = {};
+            }
+            cursor = cursor[p];
+            i++;
+        }
+        const p = path[i];
+        if ((0, isObjNotNull_1.isObjNotNull)(cursor[p]) && (0, isObjNotNull_1.isObjNotNull)(data)) {
+            cursor[p] = (0, f_3.default)(cursor[p], data);
+        }
+        else {
+            cursor[p] = data;
+        }
+        this.emit('metadata', { path, data });
+    }
+    appendParentRoot(subComponentId, childId, slotName) {
+        this._appendSubComponentChild(subComponentId, childId, slotName);
+        this.emit('append_parent_root', subComponentId, childId, slotName);
+    }
+    appendParentRootChildren(subComponentId, children, slotMap) {
+        for (const childId of children) {
+            const slotName = slotMap[childId] || 'default';
+            this._appendSubComponentChild(subComponentId, childId, slotName);
+        }
+        this.emit('append_parent_root_children', subComponentId, children, slotMap);
+    }
+    appendRoot(subComponentId) {
+        this._appendRoot(subComponentId);
+        this.emit('append_root', subComponentId);
+    }
+    _appendRoot(subComponentId) {
+        this._specAppendRoot(subComponentId);
+    }
+    removeRoot(subComponentId) {
+        this._removeRoot(subComponentId);
+    }
+    _removeRoot(subComponentId) {
+        this._simRemoveRoot(subComponentId);
+        this._specRemoveRoot(subComponentId);
+    }
+    _specRemoveRoot(subComponentId) {
+        // console.log('Graph', '_specRemoveRoot', subComponentId)
+        const index = this._spec.component.children.indexOf(subComponentId);
+        if (index > -1) {
+            this._spec.component.children.splice(index, 1);
+        }
+        else {
+            throw new Error('Root not found');
+        }
+    }
+    _simRemoveRoot(subComponentId) {
+        const subComponent = this.refUnit(subComponentId);
+        this.unregisterRoot(subComponent);
+    }
+    moveSubgraphInto(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap) {
+        // this._moveSubgraphInto(
+        //   graphId,
+        //   nodeIds,
+        //   nextIdMap,
+        //   nextPinIdMap,
+        //   nextMergePinId,
+        //   nextPlugSpec,
+        //   nextSubComponentParent,
+        //   nextSubComponentChildrenMap,
+        //   graph
+        // )
+        const spec = this._system.newSpec((0, spec_1.emptySpec)({
+            private: true,
+        }));
+        const graph = new Graph(spec, this._branch, this._system);
+        const subGraph = this.refGraph(graphId);
+        const units = Object.assign({}, this.refUnits());
+        const merges = Object.assign({}, this.refMerges());
+        const unitSpecs = (0, object_1.clone)(this.getUnitsSpec());
+        const mergesSpec = (0, object_1.clone)(this.getMergesSpec());
+        const pinSpecs = {
+            input: (0, object_1.clone)(this.getExposedInputSpecs()),
+            output: (0, object_1.clone)(this.getExposedOutputSpecs()),
+        };
+        const pinToMerge = (0, object_1.clone)(this._pinToMerge);
+        this._moveSubgraphInto__remove(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergesSpec, merges, pinSpecs, pinToMerge, graph);
+        this._moveSubgraphInto__inject(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergesSpec, merges, pinSpecs, pinToMerge, graph);
+        subGraph.injectGraph(graph);
+        this._moveSubgraphInto__recconect(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergesSpec, merges, pinSpecs, pinToMerge, graph);
+        this.emit('move_subgraph_into', graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap);
+        this.emit('leaf_move_subgraph_into', graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, []);
+    }
+    _moveSubgraphInto(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, ignoredUnit, unitSpecs, units, mergeSpecs, pinSpecs, pinToMerge, merges, graph) {
+        // console.log(
+        //   'Graph',
+        //   '_moveSubgraphInto',
+        //   graphId,
+        //   nodeIds,
+        //   nextIdMap,
+        //   nextPinIdMap,
+        //   nextMergePinId,
+        //   nextSubComponentParentMap,
+        //   nextSubComponentChildrenMap
+        // )
+        this._moveSubgraphInto__remove(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph);
+        this._moveSubgraphInto__inject(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph);
+        this._moveSubgraphInto__recconect(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph);
+    }
+    _moveSubgraphInto__template(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph, moveUnitInto, moveLinkPinInto, moveMergeInto, movePlugInto) {
+        // console.log(
+        //   'Graph',
+        //   '_moveSubgraphInto',
+        //   graphId,
+        //   nodeIds,
+        //   nextIdMap,
+        //   nextPinIdMap,
+        //   nextMergePinId,
+        //   nextSubComponentParentMap,
+        //   nextSubComponentChildrenMap
+        // )
+        const { merge: mergeIds, link: linkObjs, unit: unitIds, plug: plugObjs, } = nodeIds;
+        const unitIgnoredPin = {};
+        const unitIgnored = new Set(unitIds);
+        const mergeIgnored = new Set(mergeIds);
+        function setUnitPinIgnored(unitId, type, pinId) {
+            unitIgnoredPin[unitId] = unitIgnoredPin[unitId] || {
+                input: new Set(),
+                output: new Set(),
+            };
+            unitIgnoredPin[unitId][type].add(pinId);
+        }
+        for (const { unitId, type, pinId } of linkObjs) {
+            setUnitPinIgnored(unitId, type, pinId);
+        }
+        const nextMergeSpecs = {};
+        for (const mergeId of mergeIds) {
+            const mergeSpec = mergeSpecs[mergeId];
+            nextMergeSpecs[mergeId] = mergeSpec;
+            (0, util_1.forEachPinOnMerge)(mergeSpec, (unitId, type, pinId) => {
+                setUnitPinIgnored(unitId, type, pinId);
+            });
+        }
+        for (const { unitId, type, pinId } of linkObjs) {
+            const { mergeId, oppositePinId } = nextIdMap.link[unitId][type][pinId];
+            moveLinkPinInto(graphId, unitId, type, pinId, mergeId, oppositePinId, {}, unitIgnored, mergeIgnored, unitSpecs, units, mergeSpecs, merges, pinToMerge, graph);
+        }
+        for (const unitId of unitIds) {
+            const unit = units[unitId];
+            const nextUnitId = nextIdMap.unit[unitId] || unitId;
+            const nextUnitSubComponentParent = nextSubComponentParentMap[unitId] || null;
+            const nextSubComponentChildren = nextSubComponentChildrenMap[unitId] || [];
+            const ignoredPins = unitIgnoredPin[unitId] || {
+                input: new Set(),
+                output: new Set(),
+            };
+            const unitPinIdMap = nextPinIdMap[unitId] || (0, emptyIO_1.emptyIO)({}, {});
+            moveUnitInto(graphId, unitId, unit, nextUnitId, ignoredPins, mergeIgnored, unitPinIdMap, nextUnitSubComponentParent, nextSubComponentChildren, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph);
+        }
+        for (const mergeId of mergeIds) {
+            const { input: nextInputMergePinId, output: nextOutputMergePinId } = nextMergePinId[mergeId] || {};
+            const nextMergeSpec = nextMergeSpecs[mergeId];
+            moveMergeInto(graphId, mergeId, nextMergeSpec, nextInputMergePinId, nextOutputMergePinId, unitIgnored, mergeIgnored, {}, unitSpecs, units, mergeSpecs, merges, pinToMerge, pinSpecs, graph);
+        }
+        for (const { type, pinId, subPinId } of plugObjs) {
+            const subPinSpec = (0, f_1.default)(pinSpecs, [type, pinId, 'plug', subPinId]);
+            movePlugInto(graphId, type, pinId, subPinId, subPinSpec, nextPlugSpec, nextPinIdMap, nextMergePinId, nextIdMap, graph);
+        }
+    }
+    _moveSubgraphInto__inject(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph) {
+        // console.log(
+        //   'Graph',
+        //   '_moveSubgraphInto__inject',
+        //   graphId,
+        //   nodeIds,
+        //   nextIdMap,
+        //   nextPinIdMap,
+        //   nextMergePinId,
+        //   nextSubComponentParentMap,
+        //   nextSubComponentChildrenMap
+        // )
+        this._moveSubgraphInto__template(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph, this._moveUnitInto__inject, this._moveLinkPinInto__inject, this._moveMergeInto__inject, this._movePlugInto__inject);
+    }
+    _moveSubgraphInto__recconect(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph) {
+        // console.log(
+        //   'Graph',
+        //   '_moveSubgraphInto__inject',
+        //   graphId,
+        //   nodeIds,
+        //   nextIdMap,
+        //   nextPinIdMap,
+        //   nextMergePinId,
+        //   nextSubComponentParentMap,
+        //   nextSubComponentChildrenMap
+        // )
+        this._moveSubgraphInto__template(graphId, nodeIds, nextIdMap, nextPinIdMap, nextMergePinId, nextPlugSpec, nextSubComponentParentMap, nextSubComponentChildrenMap, unitSpecs, units, mergeSpecs, merges, pinSpecs, pinToMerge, graph, this._moveUnitInto__reconnect, this._moveLinkPinInto__reconnect, this._moveMergeInto__reconnect, this._movePlugInto__reconnect);
+    }
+    injectGraph(graph) {
+        const tempUnitId = '__temp__';
+        const bundle = graph.getBundleSpec();
+        this._addUnit(tempUnitId, graph);
+        this._explodeUnit(tempUnitId, {}, {}, false);
+        this.emit('inject_graph', bundle);
+        this.emit('leaf_inject_graph', bundle, []);
+    }
+    removeSubgraph(spec) {
+        // TODO
+    }
+    _removeSubgraph(spec) {
+        const { units, merges, inputs, outputs } = spec;
+    }
+    movePlugInto(graphId, type, pinId, subPinId, subPinSpec, graph = null) {
+        graph = graph || this.refGraph(graphId);
+        // console.log('Graph', 'movePlugInto', graphId, type, pinId, subPinId, subPinSpec)
+        this._movePlugInto(graphId, type, pinId, subPinId, subPinSpec, graph);
+    }
+    _movePlugInto(graphId, type, pinId, subPinId, subPinSpec, graph) {
+        // console.log('Graph', '_movePlugInto')
+        const plugCount = this.getPinPlugCount(type, pinId);
+        if (plugCount === 1) {
+            this._coverPinSet(type, pinId);
+        }
+        else {
+            this._coverPin(type, pinId, subPinId);
+        }
+        if (!graph.hasPinNamed(type, pinId)) {
+            graph.exposePinSet(type, pinId, { plug: {} }, false);
+        }
+        graph.exposePin(type, pinId, subPinId, subPinSpec, false);
+    }
+    _simMovePlugInto(graphId, type, pinId, subPinId) { }
+    moveUnitInto(graphId, unitId, nextUnitId, ignoredPin, ignoredMerge, nextPinMap, nextUnitSubComponentParent, nextSubComponentChildren, graph = null) {
+        graph = graph || this.refGraph(graphId);
+        this._moveUnitInto(graphId, unitId, nextUnitId, ignoredPin, ignoredMerge, nextPinMap, nextUnitSubComponentParent, nextSubComponentChildren, graph);
+        this.emit('move_unit_into', graphId, unitId, nextUnitId, ignoredPin, ignoredMerge, nextPinMap, nextUnitSubComponentParent, nextSubComponentChildren);
+    }
+    getUnitMergesSpec(unitId) {
+        const merges = this.getMergesSpec();
+        const unit_merges = {};
+        for (const mergeId in merges) {
+            const merge = merges[mergeId];
+            if (merge[unitId]) {
+                unit_merges[mergeId] = merge;
+            }
+        }
+        return unit_merges;
+    }
+    moveLinkPinInto(graphId, unitId, type, pinId, mergeId = null, oppositePinId = null, emit = true, graph = this.refGraph(graphId)) {
+        // console.log('Graph', 'moveLinkPinInto')
+        this._moveLinkPinInto(graphId, unitId, type, pinId, mergeId, oppositePinId, {}, graph);
+        emit &&
+            this.emit('move_link_pin_into', graphId, unitId, type, pinId, mergeId, oppositePinId);
+    }
+    _moveLinkPinInto(graphId, unitId, type, pinId, oppositeMergeId, oppositePinId, subPinSpec = {}, graph) {
+        // console.log(
+        //   'Graph',
+        //   '_moveLinkPinInto',
+        //   graphId,
+        //   unitId,
+        //   type,
+        //   pinId,
+        //   oppositeMergeId,
+        //   oppositePinId,
+        //   subPinSpec
+        // )
+        if (graphId === unitId) {
+            const mergeId = (0, object_1.pathOrDefault)(this._pinToMerge, [unitId, type, pinId], null);
+            if (mergeId) {
+                const unitMergePinCount = this._getMergeUnitPinCount(mergeId, unitId);
+                if (unitMergePinCount > 0) {
+                    //
+                }
+                else {
+                    graph.coverPinSet(type, pinId, false);
+                }
+            }
+            else {
+                graph.coverPinSet(type, pinId, false);
+            }
+        }
+        else {
+            if (oppositeMergeId && oppositePinId) {
+                const oppositeType = (0, util_1.opposite)(type);
+                if (this.hasMerge(oppositeMergeId)) {
+                    this._addPinToMerge(oppositeMergeId, unitId, type, pinId);
+                }
+                else {
+                    const pin = this.getUnitPin(unitId, type, pinId);
+                    const exposedPin = new Pin_1.Pin({ data: pin.peak() });
+                    const exposedMerge = new Merge_1.default(this._system);
+                    const pinSpec = { plug: { '0': subPinSpec } };
+                    if (graph.hasPinNamed(oppositeType, oppositePinId)) {
+                        //
+                    }
+                    else {
+                        graph.exposePinSet(oppositeType, oppositePinId, pinSpec, false, exposedPin, exposedMerge, false);
+                    }
+                    const merge = {
+                        [unitId]: {
+                            [type]: {
+                                [pinId]: true,
+                            },
+                        },
+                        [graphId]: {
+                            [oppositeType]: {
+                                [oppositePinId]: true,
+                            },
+                        },
+                    };
+                    this._addMerge(merge, oppositeMergeId, null, false);
+                }
+            }
+            else {
+                //
+            }
+        }
+    }
+    moveMergeInto(graphId, mergeId, nextInputMergeId, nextOutputMergeId, graph = null) {
+        graph = graph || this.refGraph(graphId);
+        const subGraph = this.refGraph(graphId);
+        const mergeSpec = (0, object_1.clone)(this.getMergeSpec(mergeId));
+        const units = Object.assign({}, this.refUnits());
+        const merges = Object.assign({}, this.refMerges());
+        const unitSpecs = (0, object_1.clone)(this.getUnitsSpec());
+        const mergeSpecs = (0, object_1.clone)(this.getMergesSpec());
+        const pinSpecs = {
+            input: (0, object_1.clone)(this.getExposedInputSpecs()),
+            output: (0, object_1.clone)(this.getExposedOutputSpecs()),
+        };
+        const pinToMerge = (0, object_1.clone)(this._pinToMerge);
+        this._moveMergeInto(graphId, mergeId, mergeSpec, nextInputMergeId, nextOutputMergeId, new Set(), new Set(), null, // TODO merge plugs
+        graph, unitSpecs, units, mergeSpecs, merges, pinToMerge, pinSpecs);
+        this.emit('move_merge_into', graphId, mergeId, nextInputMergeId, nextOutputMergeId);
+    }
+    explodeUnit(graphId, mapUnitId, mapMergeId, ignorePins = false) {
+        // console.log('Graph', 'explodeUnit', graphId, mapUnitId, mapMergeId)
+        this._explodeUnit(graphId, mapUnitId, mapMergeId, ignorePins);
+        this.emit('explode_unit', graphId, mapUnitId, mapMergeId);
+    }
+    _explodeUnit(graphId, mapUnitId, mapMergeId, ignorePins = true) {
+        // console.log('Graph', '_explodeUnit', graphId, mapUnitId, mapMergeId)
+        var _a, _b, _c;
+        this._fork();
+        const graph = this.refUnit(graphId);
+        const graphMerges = (0, object_1.clone)(this.getUnitMergesSpec(graphId));
+        const units = Object.assign({}, graph.refUnits());
+        const merges = Object.assign({}, graph.refMerges());
+        const inputs = Object.assign({}, graph.getInputs());
+        const outputs = Object.assign({}, graph.getOutputs());
+        const exposedMerges = Object.assign({}, graph.refExposedMerges());
+        const mergeSpecs = (0, object_1.clone)(graph.getMergesSpec());
+        const inputSpecs = (0, object_1.clone)(graph.getExposedInputSpecs());
+        const outputSpecs = (0, object_1.clone)(graph.getExposedOutputSpecs());
+        const componentSpec = (0, object_1.clone)(graph.getComponentSpec());
+        const isGraphComponent = this._isUnitComponent(graphId);
+        this._simRemoveUnit(graphId);
+        this._memRemoveUnit(graphId);
+        this._specRemoveUnit(graphId, isGraphComponent);
+        for (const unitId in units) {
+            const newUnitId = mapUnitId[unitId] || unitId;
+            const unit = graph.refUnit(unitId);
+            graph.removeUnit(unitId, false);
+            this._addUnit(newUnitId, unit);
+        }
+        for (const unitId in units) {
+            const newUnitId = mapUnitId[unitId] || unitId;
+            const subComponent = (_a = componentSpec === null || componentSpec === void 0 ? void 0 : componentSpec.subComponents) === null || _a === void 0 ? void 0 : _a[newUnitId];
+            if (subComponent) {
+                for (const childId of subComponent.children) {
+                    const childSlot = (_b = subComponent.childSlot[childId]) !== null && _b !== void 0 ? _b : 'default';
+                    const newChildId = (_c = mapUnitId[childId]) !== null && _c !== void 0 ? _c : childId;
+                    this._moveSubComponent(newUnitId, newChildId, childSlot);
+                }
+            }
+        }
+        for (const mergeId in merges) {
+            const merge = merges[mergeId];
+            const mergeSpec = mergeSpecs[mergeId];
+            const newMergeId = mapMergeId[mergeId] || mergeId;
+            if (graph.hasMerge(mergeId)) {
+                graph.removeMerge(mergeId);
+            }
+            const mergeInputPinId = (0, util_1.getMergePinNodeId)(mergeId, 'input');
+            const newMergeInputPinId = (0, util_1.getMergePinNodeId)(newMergeId, 'input');
+            merge.renameInput(mergeInputPinId, newMergeInputPinId);
+            const nextMergeSpec = {};
+            (0, util_1.forEachPinOnMerge)(mergeSpec, (unitId, type, pinId) => {
+                const newUnitId = mapUnitId[unitId] || unitId;
+                (0, object_1.pathSet)(nextMergeSpec, [newUnitId, type, pinId], true);
+            });
+            this._addMerge(nextMergeSpec, newMergeId, merge, false);
+        }
+        const exposePins = (type, pinSpecs, pins) => {
+            for (const pinId in pinSpecs) {
+                const pinSpec = pinSpecs[pinId];
+                const exposedPin = pins[pinId];
+                const exposedPinId = (0, util_1.getExposedPinId)(pinId, type);
+                const exposedMerge = exposedMerges[exposedPinId];
+                if (graph.hasPinNamed(type, pinId)) {
+                    graph.coverPinSet(type, pinId, false);
+                }
+                this._exposePinSet(type, pinId, pinSpec, exposedPin, exposedMerge);
+            }
+        };
+        if (ignorePins) {
+            //
+        }
+        else {
+            exposePins('input', inputSpecs, inputs);
+            exposePins('output', outputSpecs, outputs);
+        }
+        for (const mergeId in graphMerges) {
+            const merge = graphMerges[mergeId];
+            const newMergeId = mapMergeId[mergeId] || mergeId;
+            const nextMerge = {};
+            const graphMerge = merge[graphId];
+            const graphPinType = (0, object_1.getObjSingleKey)(graphMerge);
+            const graphPinId = (0, object_1.getObjSingleKey)(graphMerge[graphPinType]);
+            const pinSpec = graphPinType === 'input'
+                ? inputSpecs[graphPinId]
+                : outputSpecs[graphPinId];
+            const { plug } = pinSpec;
+            for (const subPinId in plug) {
+                const subPinSpec = plug[subPinId];
+                if (subPinSpec.mergeId) {
+                    const newMergeId = mapMergeId[subPinSpec.mergeId] || subPinSpec.mergeId;
+                    if (this.hasMerge(mergeId)) {
+                        this._mergeMerges([newMergeId, mergeId]);
+                    }
+                    else {
+                        const mergeClone = (0, object_1.clone)(merge);
+                        delete mergeClone[graphId];
+                        const otherUnitId = (0, object_1.getObjSingleKey)(mergeClone);
+                        const otherUnitPinType = (0, object_1.getObjSingleKey)(mergeClone[otherUnitId]);
+                        const otherUnitPinId = (0, object_1.getObjSingleKey)(mergeClone[otherUnitId][otherUnitPinType]);
+                        this._addPinToMerge(newMergeId, otherUnitId, otherUnitPinType, otherUnitPinId);
+                    }
+                }
+                else if (subPinSpec.unitId && subPinSpec.pinId) {
+                    const newUnitId = mapUnitId[subPinSpec.unitId] || subPinSpec.unitId;
+                    if (this.hasMerge(mergeId)) {
+                        this._addPinToMerge(mergeId, newUnitId, graphPinType, subPinSpec.pinId);
+                    }
+                    else {
+                        const mergeClone = (0, object_1.clone)(merge);
+                        delete mergeClone[graphId];
+                        const otherUnitId = (0, object_1.getObjSingleKey)(mergeClone);
+                        const otherUnitPinType = (0, object_1.getObjSingleKey)(mergeClone[otherUnitId]);
+                        const otherUnitPinId = (0, object_1.getObjSingleKey)(mergeClone[otherUnitId][otherUnitPinType]);
+                        this._addMerge({
+                            [newUnitId]: { [graphPinType]: { [subPinSpec.pinId]: true } },
+                            [otherUnitId]: {
+                                [otherUnitPinType]: { [otherUnitPinId]: true },
+                            },
+                        }, mergeId);
+                    }
+                }
+            }
+            (0, util_1.forEachPinOnMerge)(merge, (unitId, type, pinId) => {
+                const newUnitId = mapUnitId[unitId] || unitId;
+                (0, object_1.pathSet)(nextMerge, [newUnitId, type, pinId], true);
+            });
+        }
+    }
+    _removeSubComponentFromParent(subComponentId) {
+        this._simRemoveSubComponentFromParent(subComponentId);
+        this._specRemoveSubComponentFromParent(subComponentId);
+    }
+    moveSubComponent(parentId, childId, slotName) {
+        this._moveSubComponent(parentId, childId, slotName);
+    }
+    _moveSubComponent(parentId, childId, slotName) {
+        this._removeSubComponentFromParent(childId);
+        if (parentId) {
+            this._appendSubComponentChild(parentId, childId, slotName);
+        }
+        else {
+            this._appendRoot(childId);
+        }
+    }
+    _initSetComponent(component) {
+        const { slots = [], subComponents = {}, children = [] } = component;
+        for (const subComponentId in subComponents) {
+            const subComponent = subComponents[subComponentId];
+            this._initAddSubComponent(subComponentId, subComponent);
+        }
+        for (let i = 0; i < slots.length; i++) {
+            const slot = slots[i];
+            const [unitId, slotName] = slot;
+            const slotUnit = this.refUnit(unitId);
+            const _slotName = i === 0 ? 'default' : `${i}`;
+            this._slot[_slotName] = slotUnit;
+        }
+    }
+    _specSetComponent(component) {
+        const { slots = [], subComponents = {}, children = [] } = component;
+        for (const subComponentId in subComponents) {
+            const subComponent = subComponents[subComponentId];
+            this._specAddSubComponent(subComponentId, subComponent);
+        }
+        for (let i = 0; i < slots.length; i++) {
+            const slot = slots[i];
+            const [unitId, slotName] = slot;
+            const slotUnit = this.refUnit(unitId);
+            const _slotName = i === 0 ? 'default' : `${i}`;
+            this._slot[_slotName] = slotUnit;
+        }
+        // AD HOC
+        if (slots.length > 0) {
+            this._spec.component.slots = slots;
+        }
+        // for (const child of children) {
+        //   this.componentAppend(child)
+        // }
+    }
+    _initAddSubComponent(subComponentId, subComponent) {
+        const { children = [], childSlot = {} } = subComponent;
+        for (const childId of children) {
+            const slot = childSlot[childId] || 'default';
+            this._simSubComponentAppendChild(subComponentId, childId, slot);
+        }
+    }
+    _specAddSubComponent(subComponentId, subComponent) {
+        var _a;
+        const { children = [], childSlot = {} } = subComponent;
+        for (const childId of children) {
+            // AD HOC
+            // should get parent from memory
+            this._specComponentRemoveChild(childId);
+            const slot = childSlot[childId] || 'default';
+            this._specSubComponentAppendChild(subComponentId, childId, slot);
+        }
+        this._spec.component.subComponents[subComponentId] = subComponent;
+        this._spec.component.children = (_a = this._spec.component.children) !== null && _a !== void 0 ? _a : [];
+        this._spec.component.children.push(subComponentId);
+    }
+    appendParentChild(component, slotName) {
+        return (0, method_1.appendParentChild)(this, this._parent_children, component, slotName);
+    }
+    removeParentChild(component) {
+        return (0, method_1.removeParentChild)(this, this._parent_children, component);
+    }
+    registerRoot(component) {
+        return (0, method_1.registerRoot)(this, this._root, component);
+    }
+    unregisterRoot(component) {
+        return (0, method_1.unregisterRoot)(this, this._root, component);
+    }
+    registerParentRoot(component, slotName) {
+        return (0, method_1.registerParentRoot)(this, this._parent_root, component, slotName);
+    }
+    unregisterParentRoot(component) {
+        return (0, method_1.unregisterParentRoot)(this, this._parent_root, component);
+    }
+    insertChild(Bundle, at) {
+        return (0, method_1.insertChild)(this, this._children, Bundle, at);
+    }
+    appendChild(Bundle) {
+        return (0, method_1.appendChild)(this, this._children, Bundle);
+    }
+    pushChild(Bundle) {
+        return (0, method_1.pushChild)(this, this._children, Bundle);
+    }
+    pullChild(at) {
+        throw (0, method_1.pullChild)(this, this._children, at);
+    }
+    hasChild(at) {
+        return (0, method_1.hasChild)(this, this._children, at);
+    }
+    removeChild(at) {
+        return (0, method_1.removeChild)(this, this._children, at);
+    }
+    refChild(at) {
+        return (0, method_1.refChild)(this, this._children, at);
+    }
+    refChildren() {
+        return (0, method_1.refChildren)(this, this._children);
+    }
+    refSlot(slotName) {
+        return (0, method_1.refSlot)(this, slotName, this._slot);
+    }
+}
+exports.Graph = Graph;
+//# sourceMappingURL=index.js.map