diff --git a/_content/lib/godoc/packageroot.html b/_content/lib/godoc/packageroot.html
index 8655dcd..2b5c5e6 100644
--- a/_content/lib/godoc/packageroot.html
+++ b/_content/lib/godoc/packageroot.html
@@ -45,7 +45,6 @@
 
 						{{range .List}}
 							<tr>
-							{{if .IsGOROOT}}
 							{{if $.DirFlat}}
 								{{if .HasPkg}}
 										<td class="pkg-name">
@@ -57,10 +56,9 @@
 										<a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Name}}</a>
 									</td>
 							{{end}}
-								<td class="pkg-synopsis">
-									{{html .Synopsis}}
-								</td>
-							{{end}}
+							<td class="pkg-synopsis">
+								{{html .Synopsis}}
+							</td>
 							</tr>
 						{{end}}
 					</table>
diff --git a/internal/godoc/corpus.go b/internal/godoc/corpus.go
index 6de01d1..7c403f6 100644
--- a/internal/godoc/corpus.go
+++ b/internal/godoc/corpus.go
@@ -8,7 +8,6 @@
 package godoc
 
 import (
-	"errors"
 	"io/fs"
 	"sync"
 	"time"
@@ -27,25 +26,12 @@
 	// Verbose logging.
 	Verbose bool
 
-	// SummarizePackage optionally specifies a function to
-	// summarize a package. It exists as an optimization to
-	// avoid reading files to parse package comments.
-	//
-	// If SummarizePackage returns false for ok, the caller
-	// ignores all return values and parses the files in the package
-	// as if SummarizePackage were nil.
-	//
-	// If showList is false, the package is hidden from the
-	// package listing.
-	SummarizePackage func(pkg string) (summary string, showList, ok bool)
-
 	// Send a value on this channel to trigger a metadata refresh.
 	// It is buffered so that if a signal is not lost if sent
 	// during a refresh.
 	refreshMetadataSignal chan bool
 
 	// file system information
-	fsTree      rwValue // *Directory tree of packages, updated with each sync (but sync code is removed now)
 	fsModified  rwValue // timestamp of last call to invalidateIndex
 	docMetadata rwValue // mapping from paths to *Metadata
 
@@ -77,9 +63,6 @@
 // Init initializes Corpus, once options on Corpus are set.
 // It must be called before any subsequent method calls.
 func (c *Corpus) Init() error {
-	if err := c.initFSTree(); err != nil {
-		return err
-	}
 	c.updateMetadata()
 	go c.refreshMetadataLoop()
 
@@ -88,12 +71,3 @@
 	c.initMu.Unlock()
 	return nil
 }
-
-func (c *Corpus) initFSTree() error {
-	dir := c.newDirectory("/", -1)
-	if dir == nil {
-		return errors.New("godoc: corpus fstree is nil")
-	}
-	c.fsTree.Set(dir)
-	return nil
-}
diff --git a/internal/godoc/dirtrees.go b/internal/godoc/dirtrees.go
index f7adf99..ddc2ae8 100644
--- a/internal/godoc/dirtrees.go
+++ b/internal/godoc/dirtrees.go
@@ -16,104 +16,45 @@
 	"io/fs"
 	"log"
 	pathpkg "path"
-	"runtime"
 	"sort"
 	"strings"
 )
 
-// Conventional name for directories containing test data.
-// Excluded from directory trees.
-//
-const testdataDirName = "testdata"
-
 type Directory struct {
-	Depth    int
-	Path     string       // directory path; includes Name
-	Name     string       // directory name
+	Path     string       // directory path
 	HasPkg   bool         // true if the directory contains at least one package
 	Synopsis string       // package documentation, if any
-	IsGOROOT bool         // is this GOROOT
 	Dirs     []*Directory // subdirectories
 }
 
-type dirEntryOrFileInfo interface {
-	Name() string
-	IsDir() bool
+func (d *Directory) Name() string {
+	return pathpkg.Base(d.Path)
 }
 
-func isGoFile(fi dirEntryOrFileInfo) bool {
+func isPkgFile(fi fs.DirEntry) bool {
 	name := fi.Name()
 	return !fi.IsDir() &&
-		len(name) > 0 && name[0] != '.' && // ignore .files
-		pathpkg.Ext(name) == ".go"
-}
-
-func isPkgFile(fi dirEntryOrFileInfo) bool {
-	return isGoFile(fi) &&
+		pathpkg.Ext(name) == ".go" &&
 		!strings.HasSuffix(fi.Name(), "_test.go") // ignore test files
 }
 
-func isPkgDir(fi dirEntryOrFileInfo) bool {
+func isPkgDir(fi fs.DirEntry) bool {
 	name := fi.Name()
-	return fi.IsDir() && len(name) > 0 &&
-		name[0] != '_' && name[0] != '.' // ignore _files and .files
+	return fi.IsDir() &&
+		name != "testdata" &&
+		len(name) > 0 && name[0] != '_' && name[0] != '.' // ignore _files and .files
 }
 
-type treeBuilder struct {
-	c        *Corpus
-	maxDepth int
-}
-
-// ioGate is a semaphore controlling VFS activity (ReadDir, parseFile, etc).
-// Send before an operation and receive after.
-var ioGate = make(chan struct{}, 20)
-
-// workGate controls the number of concurrent workers. Too many concurrent
-// workers and performance degrades and the race detector gets overwhelmed. If
-// we cannot check out a concurrent worker, work is performed by the main thread
-// instead of spinning up another goroutine.
-var workGate = make(chan struct{}, runtime.NumCPU()*4)
-
-func (b *treeBuilder) newDirTree(fset *token.FileSet, path, name string, depth int) *Directory {
-	if name == testdataDirName {
-		return nil
-	}
-
-	if depth >= b.maxDepth {
-		// return a dummy directory so that the parent directory
-		// doesn't get discarded just because we reached the max
-		// directory depth
-		return &Directory{
-			Depth: depth,
-			Path:  path,
-			Name:  name,
-		}
-	}
-
+func newDirTree(fsys fs.FS, fset *token.FileSet, path string) *Directory {
 	var synopses [3]string // prioritized package documentation (0 == highest priority)
 
-	show := true // show in package listing
 	hasPkgFiles := false
 	haveSummary := false
 
-	if hook := b.c.SummarizePackage; hook != nil {
-		if summary, show0, ok := hook(strings.TrimPrefix(path, "/src/")); ok {
-			hasPkgFiles = true
-			show = show0
-			synopses[0] = summary
-			haveSummary = true
-		}
-	}
-
-	ioGate <- struct{}{}
-	list, err := fs.ReadDir(b.c.fs, toFS(path))
-	<-ioGate
+	list, err := fs.ReadDir(fsys, toFS(path))
 	if err != nil {
 		// TODO: propagate more. See golang.org/issue/14252.
-		// For now:
-		if b.c.Verbose {
-			log.Printf("newDirTree reading %s: %v", path, err)
-		}
+		log.Printf("newDirTree reading %s: %v", path, err)
 	}
 
 	// determine number of subdirectories and if there are package files
@@ -121,38 +62,24 @@
 	var dirs []*Directory
 
 	for _, d := range list {
-		filename := pathpkg.Join(path, d.Name())
+		name := d.Name()
+		filename := pathpkg.Join(path, name)
 		switch {
 		case isPkgDir(d):
-			name := d.Name()
-			select {
-			case workGate <- struct{}{}:
-				ch := make(chan *Directory, 1)
-				dirchs = append(dirchs, ch)
-				go func() {
-					ch <- b.newDirTree(fset, filename, name, depth+1)
-					<-workGate
-				}()
-			default:
-				// no free workers, do work synchronously
-				dir := b.newDirTree(fset, filename, name, depth+1)
-				if dir != nil {
-					dirs = append(dirs, dir)
-				}
+			dir := newDirTree(fsys, fset, filename)
+			if dir != nil {
+				dirs = append(dirs, dir)
 			}
+
 		case !haveSummary && isPkgFile(d):
 			// looks like a package file, but may just be a file ending in ".go";
 			// don't just count it yet (otherwise we may end up with hasPkgFiles even
 			// though the directory doesn't contain any real package files - was bug)
 			// no "optimal" package synopsis yet; continue to collect synopses
-			ioGate <- struct{}{}
 			const flags = parser.ParseComments | parser.PackageClauseOnly
-			file, err := b.c.parseFile(fset, filename, flags)
-			<-ioGate
+			file, err := parseFile(fsys, fset, filename, flags)
 			if err != nil {
-				if b.c.Verbose {
-					log.Printf("Error parsing %v: %v", filename, err)
-				}
+				log.Printf("parsing %v: %v", filename, err)
 				break
 			}
 
@@ -186,7 +113,7 @@
 	// We need to sort the dirs slice because
 	// it is appended again after reading from dirchs.
 	sort.Slice(dirs, func(i, j int) bool {
-		return dirs[i].Name < dirs[j].Name
+		return dirs[i].Path < dirs[j].Path
 	})
 
 	// if there are no package files and no subdirectories
@@ -204,21 +131,13 @@
 	}
 
 	return &Directory{
-		Depth:    depth,
 		Path:     path,
-		Name:     name,
-		HasPkg:   hasPkgFiles && show, // TODO(bradfitz): add proper Hide field?
+		HasPkg:   hasPkgFiles,
 		Synopsis: synopsis,
-		IsGOROOT: isGOROOT(b.c.fs),
 		Dirs:     dirs,
 	}
 }
 
-func isGOROOT(fsys fs.FS) bool {
-	_, err := fs.Stat(fsys, "src/math/abs.go")
-	return err == nil
-}
-
 // toFS returns the io/fs name for path (no leading slash).
 func toFS(path string) string {
 	if path == "/" {
@@ -227,112 +146,68 @@
 	return pathpkg.Clean(strings.TrimPrefix(path, "/"))
 }
 
-// newDirectory creates a new package directory tree with at most maxDepth
-// levels, anchored at root. The result tree is pruned such that it only
-// contains directories that contain package files or that contain
-// subdirectories containing package files (transitively). If a non-nil
-// pathFilter is provided, directory paths additionally must be accepted
-// by the filter (i.e., pathFilter(path) must be true). If a value >= 0 is
-// provided for maxDepth, nodes at larger depths are pruned as well; they
-// are assumed to contain package files even if their contents are not known
-// (i.e., in this case the tree may contain directories w/o any package files).
-//
-func (c *Corpus) newDirectory(root string, maxDepth int) *Directory {
-	// The root could be a symbolic link so use Stat not Lstat.
-	d, err := fs.Stat(c.fs, toFS(root))
-	// If we fail here, report detailed error messages; otherwise
-	// is is hard to see why a directory tree was not built.
-	switch {
-	case err != nil:
-		log.Printf("newDirectory(%s): %s", root, err)
-		return nil
-	case root != "/" && !isPkgDir(d):
-		log.Printf("newDirectory(%s): not a package directory", root)
-		return nil
-	case root == "/" && !d.IsDir():
-		log.Printf("newDirectory(%s): not a directory", root)
-		return nil
-	}
-	if maxDepth < 0 {
-		maxDepth = 1e6 // "infinity"
-	}
-	b := treeBuilder{c, maxDepth}
-	// the file set provided is only for local parsing, no position
-	// information escapes and thus we don't need to save the set
-	return b.newDirTree(token.NewFileSet(), root, d.Name(), 0)
+// walk calls f(d, depth) for each directory d in the tree rooted at dir, including dir itself.
+// The depth argument specifies the depth of d in the tree.
+// The depth of dir itself is 0.
+func (dir *Directory) walk(f func(d *Directory, depth int)) {
+	walkDirs(f, dir, 0)
 }
 
-func (dir *Directory) walk(c chan<- *Directory, skipRoot bool) {
-	if dir != nil {
-		if !skipRoot {
-			c <- dir
-		}
-		for _, d := range dir.Dirs {
-			d.walk(c, false)
-		}
+func walkDirs(f func(d *Directory, depth int), d *Directory, depth int) {
+	f(d, depth)
+	for _, sub := range d.Dirs {
+		walkDirs(f, sub, depth+1)
 	}
 }
 
-func (dir *Directory) iter(skipRoot bool) <-chan *Directory {
-	c := make(chan *Directory)
-	go func() {
-		dir.walk(c, skipRoot)
-		close(c)
-	}()
-	return c
-}
-
-func (dir *Directory) lookupLocal(name string) *Directory {
-	for _, d := range dir.Dirs {
-		if d.Name == name {
-			return d
-		}
-	}
-	return nil
-}
-
-func splitPath(p string) []string {
-	p = strings.TrimPrefix(p, "/")
-	if p == "" {
-		return nil
-	}
-	return strings.Split(p, "/")
-}
-
 // lookup looks for the *Directory for a given path, relative to dir.
 func (dir *Directory) lookup(path string) *Directory {
-	d := splitPath(dir.Path)
-	p := splitPath(path)
-	i := 0
-	for i < len(d) {
-		if i >= len(p) || d[i] != p[i] {
+	path = pathpkg.Join(dir.Path, path)
+	if path == dir.Path {
+		return dir
+	}
+	dirPathLen := len(dir.Path)
+	if dir.Path == "/" {
+		dirPathLen = 0 // so path[dirPathLen] is a slash
+	}
+	if !strings.HasPrefix(path, dir.Path) || path[dirPathLen] != '/' {
+		println("NO", path, dir.Path)
+		return nil
+	}
+	d := dir
+Walk:
+	for i := dirPathLen + 1; i <= len(path); i++ {
+		if i == len(path) || path[i] == '/' {
+			// Find next child along path.
+			for _, sub := range d.Dirs {
+				if sub.Path == path[:i] {
+					d = sub
+					continue Walk
+				}
+			}
+			println("LOST", path[:i])
 			return nil
 		}
-		i++
 	}
-	for dir != nil && i < len(p) {
-		dir = dir.lookupLocal(p[i])
-		i++
-	}
-	return dir
+	return d
 }
 
-// DirEntry describes a directory entry. The Depth and Height values
-// are useful for presenting an entry in an indented fashion.
-//
+// DirEntry describes a directory entry.
+// The Depth gives the directory depth relative to the overall list,
+// for use in presenting a hierarchical directory entry.
 type DirEntry struct {
 	Depth    int    // >= 0
-	Height   int    // = DirList.MaxHeight - Depth, > 0
-	Path     string // directory path; includes Name, relative to DirList root
-	Name     string // directory name
+	Path     string // relative path to directory from listing start
 	HasPkg   bool   // true if the directory contains at least one package
 	Synopsis string // package documentation, if any
-	IsGOROOT bool   // root type of the filesystem containing the direntry
+}
+
+func (d *DirEntry) Name() string {
+	return pathpkg.Base(d.Path)
 }
 
 type DirList struct {
-	MaxHeight int // directory tree height, > 0
-	List      []DirEntry
+	List []DirEntry
 }
 
 // listing creates a (linear) directory listing from a directory tree.
@@ -340,52 +215,32 @@
 // If filter is set, only the directory entries whose paths match the filter
 // are included.
 //
-func (dir *Directory) listing(skipRoot bool, filter func(string) bool) *DirList {
+func (dir *Directory) listing(filter func(string) bool) *DirList {
 	if dir == nil {
 		return nil
 	}
 
-	// determine number of entries n and maximum height
-	n := 0
-	minDepth := 1 << 30 // infinity
-	maxDepth := 0
-	for d := range dir.iter(skipRoot) {
-		n++
-		if minDepth > d.Depth {
-			minDepth = d.Depth
+	var list []DirEntry
+	dir.walk(func(d *Directory, depth int) {
+		if depth == 0 || filter != nil && !filter(d.Path) {
+			return
 		}
-		if maxDepth < d.Depth {
-			maxDepth = d.Depth
-		}
-	}
-	maxHeight := maxDepth - minDepth + 1
-
-	if n == 0 {
-		return nil
-	}
-
-	// create list
-	list := make([]DirEntry, 0, n)
-	for d := range dir.iter(skipRoot) {
-		if filter != nil && !filter(d.Path) {
-			continue
-		}
-		var p DirEntry
-		p.Depth = d.Depth - minDepth
-		p.Height = maxHeight - p.Depth
 		// the path is relative to root.Path - remove the root.Path
 		// prefix (the prefix should always be present but avoid
 		// crashes and check)
 		path := strings.TrimPrefix(d.Path, dir.Path)
 		// remove leading separator if any - path must be relative
 		path = strings.TrimPrefix(path, "/")
-		p.Path = path
-		p.Name = d.Name
-		p.HasPkg = d.HasPkg
-		p.Synopsis = d.Synopsis
-		p.IsGOROOT = d.IsGOROOT
-		list = append(list, p)
-	}
+		list = append(list, DirEntry{
+			Depth:    depth,
+			Path:     path,
+			HasPkg:   d.HasPkg,
+			Synopsis: d.Synopsis,
+		})
+	})
 
-	return &DirList{maxHeight, list}
+	if len(list) == 0 {
+		return nil
+	}
+	return &DirList{list}
 }
diff --git a/internal/godoc/dirtrees_test.go b/internal/godoc/dirtrees_test.go
index 766bc55..e228901 100644
--- a/internal/godoc/dirtrees_test.go
+++ b/internal/godoc/dirtrees_test.go
@@ -8,6 +8,7 @@
 package godoc
 
 import (
+	"go/token"
 	"os"
 	"runtime"
 	"sort"
@@ -15,17 +16,14 @@
 )
 
 func TestNewDirTree(t *testing.T) {
-	c := NewCorpus(os.DirFS(runtime.GOROOT()))
-	// 3 levels deep is enough for testing
-	dir := c.newDirectory("/", 3)
-
+	dir := newDirTree(os.DirFS(runtime.GOROOT()), token.NewFileSet(), "/src")
 	processDir(t, dir)
 }
 
 func processDir(t *testing.T, dir *Directory) {
 	var list []string
 	for _, d := range dir.Dirs {
-		list = append(list, d.Name)
+		list = append(list, d.Name())
 		// recursively process the lower level
 		processDir(t, d)
 	}
@@ -45,24 +43,6 @@
 	b.ResetTimer()
 	b.ReportAllocs()
 	for tries := 0; tries < b.N; tries++ {
-		corpus := NewCorpus(fs)
-		corpus.newDirectory("/", -1)
-	}
-}
-
-func TestIsGOROOT(t *testing.T) {
-	tests := []struct {
-		path     string
-		isGOROOT bool
-	}{
-		{runtime.GOROOT(), true},
-		{"/tmp/", false},
-	}
-
-	for _, item := range tests {
-		fs := os.DirFS(item.path)
-		if isGOROOT(fs) != item.isGOROOT {
-			t.Errorf("%s: isGOROOT = %v, want %v", item.path, !item.isGOROOT, item.isGOROOT)
-		}
+		newDirTree(fs, token.NewFileSet(), "/src")
 	}
 }
diff --git a/internal/godoc/godoc.go b/internal/godoc/godoc.go
index 25c3cd7..6031666 100644
--- a/internal/godoc/godoc.go
+++ b/internal/godoc/godoc.go
@@ -17,15 +17,8 @@
 	"strconv"
 	"strings"
 	"text/template"
-	"time"
 )
 
-// Fake relative package path for built-ins. Documentation for all globals
-// (not just exported ones) will be shown for packages in this directory,
-// and there will be no association of consts, vars, and factory functions
-// with types (see issue 6645).
-const builtinPkgPath = "builtin"
-
 // FuncMap defines template functions used in godoc templates.
 //
 // Convention: template function names ending in "_html" or "_url" produce
@@ -105,9 +98,8 @@
 	IsFiltered bool                 // true if results were filtered
 
 	// directory info
-	Dirs    *DirList  // nil if no directory information
-	DirTime time.Time // directory time stamp
-	DirFlat bool      // if set, show directory in a flat (non-indented) manner
+	Dirs    *DirList // nil if no directory information
+	DirFlat bool     // if set, show directory in a flat (non-indented) manner
 }
 
 func (info *PageInfo) IsEmpty() bool {
diff --git a/internal/godoc/parser.go b/internal/godoc/parser.go
index f742596..ec03639 100644
--- a/internal/godoc/parser.go
+++ b/internal/godoc/parser.go
@@ -48,8 +48,8 @@
 	}
 }
 
-func (c *Corpus) parseFile(fset *token.FileSet, filename string, mode parser.Mode) (*ast.File, error) {
-	src, err := fs.ReadFile(c.fs, toFS(filename))
+func parseFile(fsys fs.FS, fset *token.FileSet, filename string, mode parser.Mode) (*ast.File, error) {
+	src, err := fs.ReadFile(fsys, toFS(filename))
 	if err != nil {
 		return nil, err
 	}
@@ -61,11 +61,11 @@
 	return parser.ParseFile(fset, filename, src, mode)
 }
 
-func (c *Corpus) parseFiles(fset *token.FileSet, relpath string, abspath string, localnames []string) (map[string]*ast.File, error) {
+func parseFiles(fsys fs.FS, fset *token.FileSet, relpath string, abspath string, localnames []string) (map[string]*ast.File, error) {
 	files := make(map[string]*ast.File)
 	for _, f := range localnames {
 		absname := pathpkg.Join(abspath, f)
-		file, err := c.parseFile(fset, absname, parser.ParseComments)
+		file, err := parseFile(fsys, fset, absname, parser.ParseComments)
 		if err != nil {
 			return nil, err
 		}
diff --git a/internal/godoc/pres.go b/internal/godoc/pres.go
index 688400b..2689c4a 100644
--- a/internal/godoc/pres.go
+++ b/internal/godoc/pres.go
@@ -19,8 +19,6 @@
 
 	mux        *http.ServeMux
 	fileServer http.Handler
-	cmdHandler handlerServer
-	pkgHandler handlerServer
 
 	DirlistHTML,
 	ErrorHTML,
@@ -52,22 +50,12 @@
 		mux:        http.NewServeMux(),
 		fileServer: http.FileServer(http.FS(c.fs)),
 	}
-	p.cmdHandler = handlerServer{
-		p:       p,
-		c:       c,
-		pattern: "/cmd/",
-		fsRoot:  "/src",
+	docs := &docServer{
+		p: p,
+		d: NewDocTree(c.fs),
 	}
-	p.pkgHandler = handlerServer{
-		p:           p,
-		c:           c,
-		pattern:     "/pkg/",
-		stripPrefix: "pkg/",
-		fsRoot:      "/src",
-		exclude:     []string{"/src/cmd"},
-	}
-	p.cmdHandler.registerWithMux(p.mux)
-	p.pkgHandler.registerWithMux(p.mux)
+	p.mux.Handle("/cmd/", docs)
+	p.mux.Handle("/pkg/", docs)
 	p.mux.HandleFunc("/", p.ServeFile)
 	return p
 }
@@ -80,26 +68,6 @@
 	p.mux.ServeHTTP(w, r)
 }
 
-func (p *Presentation) PkgFSRoot() string {
-	return p.pkgHandler.fsRoot
-}
-
-func (p *Presentation) CmdFSRoot() string {
-	return p.cmdHandler.fsRoot
-}
-
-// TODO(bradfitz): move this to be a method on Corpus. Just moving code around for now,
-// but this doesn't feel right.
-func (p *Presentation) GetPkgPageInfo(abspath, relpath string, mode PageInfoMode) *PageInfo {
-	return p.pkgHandler.GetPageInfo(abspath, relpath, mode, "", "")
-}
-
-// TODO(bradfitz): move this to be a method on Corpus. Just moving code around for now,
-// but this doesn't feel right.
-func (p *Presentation) GetCmdPageInfo(abspath, relpath string, mode PageInfoMode) *PageInfo {
-	return p.cmdHandler.GetPageInfo(abspath, relpath, mode, "", "")
-}
-
 func (p *Presentation) googleCN(r *http.Request) bool {
 	return p.GoogleCN != nil && p.GoogleCN(r)
 }
diff --git a/internal/godoc/server.go b/internal/godoc/server.go
index 6640d97..a16a95c 100644
--- a/internal/godoc/server.go
+++ b/internal/godoc/server.go
@@ -10,7 +10,6 @@
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"go/ast"
 	"go/build"
@@ -35,19 +34,27 @@
 	"golang.org/x/website/internal/texthtml"
 )
 
-// handlerServer is a migration from an old godoc http Handler type.
-// This should probably merge into something else.
-type handlerServer struct {
-	p           *Presentation
-	c           *Corpus  // copy of p.Corpus
-	pattern     string   // url pattern; e.g. "/pkg/"
-	stripPrefix string   // prefix to strip from import path; e.g. "pkg/"
-	fsRoot      string   // file system root to which the pattern is mapped; e.g. "/src"
-	exclude     []string // file system paths to exclude; e.g. "/src/cmd"
+type DocTree struct {
+	fs   fs.FS
+	root *Directory
 }
 
-func (s *handlerServer) registerWithMux(mux *http.ServeMux) {
-	mux.Handle(s.pattern, s)
+func NewDocTree(fsys fs.FS) *DocTree {
+	src := newDirTree(fsys, token.NewFileSet(), "/src")
+	root := &Directory{
+		Path: "/",
+		Dirs: []*Directory{src},
+	}
+	return &DocTree{
+		fs:   fsys,
+		root: root,
+	}
+}
+
+// docServer serves a package doc tree (/cmd or /pkg).
+type docServer struct {
+	p *Presentation
+	d *DocTree
 }
 
 // GetPageInfo returns the PageInfo for a package directory abspath. If the
@@ -57,8 +64,7 @@
 // directory, PageInfo.PAst and PageInfo.PDoc are nil. If there are no sub-
 // directories, PageInfo.Dirs is nil. If an error occurred, PageInfo.Err is
 // set to the respective error but the error is not logged.
-//
-func (h *handlerServer) GetPageInfo(abspath, relpath string, mode PageInfoMode, goos, goarch string) *PageInfo {
+func (d *DocTree) GetPageInfo(abspath, relpath string, mode PageInfoMode, goos, goarch string) *PageInfo {
 	info := &PageInfo{Dirname: abspath, Mode: mode}
 
 	// Restrict to the package files that would be used when building
@@ -70,11 +76,11 @@
 	ctxt := build.Default
 	ctxt.IsAbsPath = pathpkg.IsAbs
 	ctxt.IsDir = func(path string) bool {
-		fi, err := fs.Stat(h.c.fs, toFS(filepath.ToSlash(path)))
+		fi, err := fs.Stat(d.fs, toFS(filepath.ToSlash(path)))
 		return err == nil && fi.IsDir()
 	}
 	ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) {
-		f, err := fs.ReadDir(h.c.fs, toFS(filepath.ToSlash(dir)))
+		f, err := fs.ReadDir(d.fs, toFS(filepath.ToSlash(dir)))
 		filtered := make([]os.FileInfo, 0, len(f))
 		for _, i := range f {
 			if mode&NoFiltering != 0 || i.Name() != "internal" {
@@ -87,7 +93,7 @@
 		return filtered, err
 	}
 	ctxt.OpenFile = func(name string) (r io.ReadCloser, err error) {
-		data, err := fs.ReadFile(h.c.fs, toFS(filepath.ToSlash(name)))
+		data, err := fs.ReadFile(d.fs, toFS(filepath.ToSlash(name)))
 		if err != nil {
 			return nil, err
 		}
@@ -133,7 +139,7 @@
 	if len(pkgfiles) > 0 {
 		// build package AST
 		fset := token.NewFileSet()
-		files, err := h.c.parseFiles(fset, relpath, abspath, pkgfiles)
+		files, err := parseFiles(d.fs, fset, relpath, abspath, pkgfiles)
 		if err != nil {
 			info.Err = err
 			return info
@@ -170,11 +176,11 @@
 
 			// collect examples
 			testfiles := append(pkginfo.TestGoFiles, pkginfo.XTestGoFiles...)
-			files, err = h.c.parseFiles(fset, relpath, abspath, testfiles)
+			files, err = parseFiles(d.fs, fset, relpath, abspath, testfiles)
 			if err != nil {
 				log.Println("parsing examples:", err)
 			}
-			info.Examples = collectExamples(h.c, pkg, files)
+			info.Examples = collectExamples(pkg, files)
 			info.Bugs = info.PDoc.Notes["BUG"]
 		} else {
 			// show source code
@@ -188,37 +194,13 @@
 		info.IsMain = pkgname == "main"
 	}
 
-	// get directory information, if any
-	var dir *Directory
-	if tree, _ := h.c.fsTree.Get(); tree != nil && tree.(*Directory) != nil {
-		// directory tree is present; lookup respective directory
-		// (may still fail if the file system was updated and the
-		// new directory tree has not yet been computed)
-		dir = tree.(*Directory).lookup(abspath)
-	}
-	if dir == nil {
-		// TODO(agnivade): handle this case better, now since there is no CLI mode.
-		// no directory tree present (happens in command-line mode);
-		// compute 2 levels for this page. The second level is to
-		// get the synopses of sub-directories.
-		// note: cannot use path filter here because in general
-		// it doesn't contain the FSTree path
-		dir = h.c.newDirectory(abspath, 2)
-	}
-	info.Dirs = dir.listing(true, func(path string) bool { return h.includePath(path, mode) })
+	info.Dirs = d.root.lookup(abspath).listing(func(path string) bool { return d.includePath(path, mode) })
 	info.DirFlat = mode&FlatDir != 0
 
 	return info
 }
 
-func (h *handlerServer) includePath(path string, mode PageInfoMode) (r bool) {
-	// if the path is under one of the exclusion paths, don't list.
-	for _, e := range h.exclude {
-		if strings.HasPrefix(path, e) {
-			return false
-		}
-	}
-
+func (d *DocTree) includePath(path string, mode PageInfoMode) (r bool) {
 	// if the path includes 'internal', don't list unless we are in the NoFiltering mode.
 	if mode&NoFiltering != 0 {
 		return true
@@ -239,27 +221,23 @@
 func (s funcsByName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s funcsByName) Less(i, j int) bool { return s[i].Name < s[j].Name }
 
-func (h *handlerServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (h *docServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if redirect(w, r) {
 		return
 	}
 
-	relpath := pathpkg.Clean(r.URL.Path[len(h.stripPrefix)+1:])
+	// TODO(rsc): URL should be clean already.
+	relpath := pathpkg.Clean(strings.TrimPrefix(r.URL.Path, "/pkg/"))
 
-	if !h.corpusInitialized() {
-		h.p.ServeError(w, r, relpath, errors.New("Scan is not yet complete. Please retry after a few moments"))
-		return
-	}
-
-	abspath := pathpkg.Join(h.fsRoot, relpath)
+	abspath := pathpkg.Join("/src", relpath)
 	mode := GetPageInfoMode(r.FormValue("m"))
-	if relpath == builtinPkgPath {
+	if relpath == "builtin" {
 		// The fake built-in package contains unexported identifiers,
 		// but we want to show them. Also, disable type association,
 		// since it's not helpful for this fake package (see issue 6645).
 		mode |= NoFiltering | NoTypeAssoc
 	}
-	info := h.GetPageInfo(abspath, relpath, mode, r.FormValue("GOOS"), r.FormValue("GOARCH"))
+	info := h.d.GetPageInfo(abspath, relpath, mode, r.FormValue("GOOS"), r.FormValue("GOARCH"))
 	if info.Err != nil {
 		log.Print(info.Err)
 		h.p.ServeError(w, r, relpath, info.Err)
@@ -316,48 +294,45 @@
 	})
 }
 
-func (h *handlerServer) corpusInitialized() bool {
-	h.c.initMu.RLock()
-	defer h.c.initMu.RUnlock()
-	return h.c.initDone
-}
-
 type PageInfoMode uint
 
 const (
 	NoFiltering PageInfoMode = 1 << iota // do not filter exports
+	FlatDir                              // show directory in a flat (non-indented) manner
 	AllMethods                           // show all embedded methods
 	ShowSource                           // show source code, do not extract documentation
-	FlatDir                              // show directory in a flat (non-indented) manner
 	NoTypeAssoc                          // don't associate consts, vars, and factory functions with types (not exposed via ?m= query parameter, used for package builtin, see issue 6645)
 )
 
 // modeNames defines names for each PageInfoMode flag.
-var modeNames = map[string]PageInfoMode{
-	"all":     NoFiltering,
-	"methods": AllMethods,
-	"src":     ShowSource,
-	"flat":    FlatDir,
+// The order here must match the order of the constants above.
+var modeNames = []string{
+	"all",
+	"flat",
+	"methods",
+	"src",
 }
 
 // generate a query string for persisting PageInfoMode between pages.
-func modeQueryString(mode PageInfoMode) string {
-	if modeNames := mode.names(); len(modeNames) > 0 {
-		return "?m=" + strings.Join(modeNames, ",")
-	}
-	return ""
-}
-
-// alphabetically sorted names of active flags for a PageInfoMode.
-func (m PageInfoMode) names() []string {
-	var names []string
-	for name, mode := range modeNames {
-		if m&mode != 0 {
-			names = append(names, name)
+func (m PageInfoMode) String() string {
+	s := ""
+	for i, name := range modeNames {
+		if m&(1<<i) != 0 && name != "" {
+			if s != "" {
+				s += ","
+			}
+			s += name
 		}
 	}
-	sort.Strings(names)
-	return names
+	return s
+}
+
+func modeQueryString(m PageInfoMode) string {
+	s := m.String()
+	if s == "" {
+		return ""
+	}
+	return "?m=" + s
 }
 
 // GetPageInfoMode computes the PageInfoMode flags by analyzing the request
@@ -365,8 +340,11 @@
 func GetPageInfoMode(text string) PageInfoMode {
 	var mode PageInfoMode
 	for _, k := range strings.Split(text, ",") {
-		if m, found := modeNames[strings.TrimSpace(k)]; found {
-			mode |= m
+		k = strings.TrimSpace(k)
+		for i, name := range modeNames {
+			if name == k {
+				mode |= 1 << i
+			}
 		}
 	}
 	return mode
@@ -402,7 +380,7 @@
 }
 
 // collectExamples collects examples for pkg from testfiles.
-func collectExamples(c *Corpus, pkg *ast.Package, testfiles map[string]*ast.File) []*doc.Example {
+func collectExamples(pkg *ast.Package, testfiles map[string]*ast.File) []*doc.Example {
 	var files []*ast.File
 	for _, f := range testfiles {
 		files = append(files, f)
@@ -414,8 +392,6 @@
 		name := stripExampleSuffix(e.Name)
 		if name == "" || globals[name] {
 			examples = append(examples, e)
-		} else if c.Verbose {
-			log.Printf("skipping example 'Example%s' because '%s' is not a known function or type", e.Name, e.Name)
 		}
 	}
 
diff --git a/internal/godoc/server_test.go b/internal/godoc/server_test.go
index ea3f8fb..934850e 100644
--- a/internal/godoc/server_test.go
+++ b/internal/godoc/server_test.go
@@ -23,19 +23,14 @@
 	packagePath := "github.com/package"
 	packageComment := "main is documented in an ignored .go file"
 
-	c := NewCorpus(fstest.MapFS{
+	fs := fstest.MapFS{
 		"src/" + packagePath + "/ignored.go": {Data: []byte(`// +build ignore
 
 // ` + packageComment + `
 package main`)},
-	})
-	srv := &handlerServer{
-		p: &Presentation{
-			Corpus: c,
-		},
-		c: c,
 	}
-	pInfo := srv.GetPageInfo("/src/"+packagePath, packagePath, NoFiltering, "linux", "amd64")
+	d := NewDocTree(fs)
+	pInfo := d.GetPageInfo("/src/"+packagePath, packagePath, NoFiltering, "linux", "amd64")
 
 	if pInfo.PDoc == nil {
 		t.Error("pInfo.PDoc = nil; want non-nil.")
@@ -57,7 +52,7 @@
 
 func TestIssue5247(t *testing.T) {
 	const packagePath = "example.com/p"
-	c := NewCorpus(fstest.MapFS{
+	fs := fstest.MapFS{
 		"src/" + packagePath + "/p.go": {Data: []byte(`package p
 
 //line notgen.go:3
@@ -65,13 +60,10 @@
 // line 2 should appear
 func F()
 //line foo.go:100`)}, // No newline at end to check corner cases.
-	})
-
-	srv := &handlerServer{
-		p: &Presentation{Corpus: c},
-		c: c,
 	}
-	pInfo := srv.GetPageInfo("/src/"+packagePath, packagePath, 0, "linux", "amd64")
+
+	d := NewDocTree(fs)
+	pInfo := d.GetPageInfo("/src/"+packagePath, packagePath, 0, "linux", "amd64")
 	if got, want := pInfo.PDoc.Funcs[0].Doc, "F doc //line 1 should appear\nline 2 should appear\n"; got != want {
 		t.Errorf("pInfo.PDoc.Funcs[0].Doc = %q; want %q", got, want)
 	}