docs: private RootInformation getRootInformation(EnclosedEntity entity, ArtifactContainer firstPotentialRoot) {
          //first we need to see if we need a new overlay container, you only get new overlays for new artifact roots, not fake roots
          OverlayContainer newOverlay = rootOverlay;
          if (delegate.isRoot()) {
              //the delegate was root, so we're moving up to a new artifact root.
              //we have to correct the overlay
  
              //the overlay is simple, it always has a 1:1 relationship with artifact roots.
              //as we have gone up a root, we make it do so also.
              newOverlay = rootOverlay.getParentOverlay();
          }
  
          //now we need to work out what the root is for this entity.  There are two options, either a fake root or a real root.
          //to see if we need to use a fake root we ask the structure helper if the path to this entity is valid
          //we only ask the structure helper this question if the path contains containers..
          // eg. /filename  does not. 
          //     /container/filename does.
          //because if it is just /filename then there can't be a fake root above it.
  
          //note that if filename is a container then it might be a fake root itself,
          //that is ok though as when we create a new InterpretedContainerImpl for it the constructor will do a test to see if it should be a fake root
          String ePath = entity.getPath();
          //remove leading / from path so we can test if this has containers above it
          ePath = ePath.substring(1);
  
          ArtifactContainer structureHelperSetRootDelegate = null;
          final ArtifactContainer newRootDelegate;
          if (ePath.indexOf("/") == -1 || (structureHelper != null && structureHelper.isValid(entity.getRoot(), entity.getPath()))) {
              //easy case, the entry in the enclosing container is supposed to be there..
              //we don't need to pass a fake root node, because the node did exist under the
              //artifact api root.
  
              //leave structureHelperSetRootDelegate as null as the new root won't have a structure helper root delegate...
              //...it will have a normal root delegate though so set this
              newRootDelegate = entity.getRoot();
          } else {
              //walk up the enclosing container chain, asking the structure helper
              //if each should be considered as the root.
              ArtifactContainer enclosing = firstPotentialRoot;
              while (!enclosing.isRoot()) {
                  if (structureHelper != null && structureHelper.isRoot(enclosing)) {
                      structureHelperSetRootDelegate = enclosing;
                      break;
                  }
                  enclosing = enclosing.getEnclosingContainer();
              }
              if (structureHelper == null) {
                  newRootDelegate = enclosing;
              } else {
                  if (structureHelperSetRootDelegate == null) {
                      //this means the structure helper told us a path was not valid,
                      //but did not identify to us which container as part of that path
                      //should have been the new root.
                      throw new IllegalStateException();
                  }
  
                  //we've found the root delegate from the structure helper so use this as the root deleage for the new root
                  newRootDelegate = structureHelperSetRootDelegate;
              }
          }
  
          //the adaptable root for the new adaptable entry, is derivable, because
          //we only need to tell containers the correct overlay, 
          //can initialise it with the correct overlay, and correct structure helper delegate.
          Container newRoot = new InterpretedContainerImpl(newRootDelegate, newOverlay, factoryHolder, structureHelper, structureHelperSetRootDelegate);
          return new RootInformation(newRoot, newOverlay, structureHelperSetRootDelegate);
      }