Seperating editor and runtime data with ScriptableObjects

My goal is to have a very strong separation between my editor and runtime code, and I think I may have achieved this. In my current implementation I am using two ScriptableObjects, one that is in the assets folder, and the other in the editor folder. The object in the asset folder holds the processed data, and the editor folder object handles serializing all the unprocessed data. For the most part everything seems to work fine with this.

My main concern is with how I am attaching the objects together. Currently I am attaching the editor object as a sub-asset to the runtime asset, and I'm concerned with how Unity might treat this in a build. Will the sub-asset cause an error, because the script couldn't be found? Am I fine if I just don't access it? Or maybe due to it being a sub-asset I'm not maintaining separation? I really would just like to know if my solution is a reasonable one, and if it isn't - is there a better one?

 /// <summary> Returns the editor assigned to this object. </summary>
 public static GraphEditor Editor(this IGraphObject value)
 {
     GraphEditor graphEditor = null;
 
     if ( value is ScriptableObject graphObject )
     {
         var path = AssetDatabase.GetAssetPath(graphObject);
         var assets = AssetDatabase.LoadAllAssetsAtPath(path);
 
         // find existing editor
         foreach (var asset in assets)
         {
             if ( asset is GraphEditor editor )
             {
                 graphEditor = editor;
             }
         }
 
         // not found
         if ( graphEditor == null )
         {
             // create new editor
             graphEditor = ScriptableObject.CreateInstance<GraphEditor>();
             graphEditor.GraphObject = value;
 
             // save to asset
             AssetDatabase.AddObjectToAsset(graphEditor, path);
             AssetDatabase.SaveAssets();
         }
     }
     else if ( value != null )
     {
         // invalid object
         Debug.LogWarningFormat( "{0} must be of type {1}", value, typeof(ScriptableObject) );
     }
 
     return graphEditor;
 }

 /// <summary> In editor representation of a graph that manages the elements and serialization. </summary>
 public class GraphEditor : ScriptableObject
 {
     [SerializeField]
     private ScriptableObject graphObject;
 
     /// <summary> Reference to the casted serializable graph. </summary> 
     public IGraphObject GraphObject
     {
         get { return graphObject as IGraphObject; }
         set
         {
             if ( graphObject == null )
             {
                 graphObject = value as ScriptableObject;
             }
             else
             {
                 Debug.LogWarningFormat("{0} is already assigned to {1}", this, graphObject);
             }
         }
     }
 }

 [CreateAssetMenu]
 public class GraphObject : ScriptableObject, IGraphObject
 {
 
 }