Specs: DocumentFragment shouldn't need to track IDs

sky/specs/apis.md

 APIs
 ====
 
 The Sky core API
 ----------------
 
 ```javascript
 module 'sky:core' {
 
   // EVENTS
@@ skipping 97 matching lines @@
 
   class Text : Node {
     constructor (String value = ''); // O(1)
     attribute String value; // O(1)
 
     void replaceWith(String node); // O(1) // special case override of Node.replaceWith()
 
     virtual void valueChangeCallback(String? oldValue, String? newValue); // noop
   }
 
-  abstract class TreeRoot : ParentNode {
+  class DocumentFragment : ParentNode {
+    constructor (ChildArguments... nodes); // O(N) in number of arguments plus all their descendants
+  }
+
+  abstract class TreeScope : ParentNode {
+    readonly attribute Document? ownerDocument; // O(1)
+    readonly attribute TreeScope? parentScope; // O(1)
+
     Element? findId(String id); // O(1)
   }
 
-  class DocumentFragment : TreeRoot {
-    constructor (ChildArguments... nodes); // O(N) in number of arguments plus all their descendants
-  }
-
-  abstract class TreeScope : TreeRoot {
-    readonly attribute Document? ownerDocument; // O(1)
-    readonly attribute TreeScope? parentScope; // O(1)
-  }
-
   class ShadowRoot : TreeScope {
     constructor (Element host); // O(1) // note that there is no way in the API to use a newly created ShadowRoot
     readonly attribute Element host; // O(1)
   }
 
   class Document : TreeScope {
     constructor (ChildArguments... nodes); // O(N) in number of arguments plus all their descendants
   }
   
   class SelectorQuery {
     constructor (String selector); // O(F()) where F() is the complexity of the selector
 
     Boolean matches(Element element); // O(F())
     Element? find(Element root); // O(N*F())+O(M) where N is the number of descendants and M the average depth of the tree
-    Element? find(TreeRoot root); // O(N*F()) where N is the number of descendants
+    Element? find(DocumentFragment root); // O(N*F())+O(M) where N is the number of descendants and M the average depth of the tree
+    Element? find(TreeScope root); // O(N*F()) where N is the number of descendants
     Array<Element> findAll(Element root); // O(N*F())+O(N*M) where N is the number of descendants and M the average depth of the tree
-    Array<Element> findAll(TreeRoot root); // O(N*F()) where N is the number of descendants
+    Array<Element> findAll(DocumentFragment root); // O(N*F())+O(N*M) where N is the number of descendants and M the average depth of the tree
+    Array<Element> findAll(TreeScope root); // O(N*F()) where N is the number of descendants
   }
 
 
   // BUILT-IN ELEMENTS
 
   class ImportElement : Element {
     constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
     constructor (Dictionary attributes); // shorthand
     constructor (); // shorthand
@@ skipping 334 matching lines @@
   the core mojo fabric JS API   sky:mojo:fabric:core
   the asyncWait/cancelWait mojo fabric JS API (interface to IPC thread)  sky:mojo:fabric:ipc
   the mojom for the shell, proxying through C++ so that the shell pipe isn't exposed  sky:mojo:shell
   the sky API  sky:core
   the sky debug symbols for private APIs  sky:debug
 ```
 
 TODO(ianh): determine if we want to separate the "this" from the
 Document, especially for Modules, so that exposing a module's element
 doesn't expose the module's exports attribute.