diff --git a/cmd/godoc/handlers.go b/cmd/godoc/handlers.go
index 86a12439281..12b02bd4a97 100644
--- a/cmd/godoc/handlers.go
+++ b/cmd/godoc/handlers.go
@@ -13,7 +13,7 @@ import (
 
 	"golang.org/x/tools/godoc"
 	"golang.org/x/tools/godoc/redirect"
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 
 	_ "golang.org/x/tools/playground" // register "/compile" playground redirect
 )
diff --git a/cmd/godoc/main.go b/cmd/godoc/main.go
index a665be0769d..180f7551d16 100644
--- a/cmd/godoc/main.go
+++ b/cmd/godoc/main.go
@@ -41,11 +41,11 @@ import (
 
 	"golang.org/x/tools/godoc"
 	"golang.org/x/tools/godoc/static"
-	"golang.org/x/tools/godoc/vfs"
-	"golang.org/x/tools/godoc/vfs/gatefs"
-	"golang.org/x/tools/godoc/vfs/mapfs"
-	"golang.org/x/tools/godoc/vfs/zipfs"
 	"golang.org/x/tools/internal/gocommand"
+	"golang.org/x/tools/vfs"
+	"golang.org/x/tools/vfs/gatefs"
+	"golang.org/x/tools/vfs/mapfs"
+	"golang.org/x/tools/vfs/zipfs"
 )
 
 const defaultAddr = "localhost:6060" // default webserver address
diff --git a/godoc/corpus.go b/godoc/corpus.go
index f2167e71040..b283d2aacc8 100644
--- a/godoc/corpus.go
+++ b/godoc/corpus.go
@@ -11,7 +11,7 @@ import (
 
 	"golang.org/x/tools/godoc/analysis"
 	"golang.org/x/tools/godoc/util"
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 // A Corpus holds all the state related to serving and indexing a
diff --git a/godoc/dirtrees.go b/godoc/dirtrees.go
index 51aa1f3f1fd..5e4ef39abc4 100644
--- a/godoc/dirtrees.go
+++ b/godoc/dirtrees.go
@@ -17,7 +17,7 @@ import (
 	"sort"
 	"strings"
 
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 // Conventional name for directories containing test data.
diff --git a/godoc/dirtrees_test.go b/godoc/dirtrees_test.go
index 9727206ec23..4068e2bfb87 100644
--- a/godoc/dirtrees_test.go
+++ b/godoc/dirtrees_test.go
@@ -11,8 +11,8 @@ import (
 	"sort"
 	"testing"
 
-	"golang.org/x/tools/godoc/vfs"
-	"golang.org/x/tools/godoc/vfs/gatefs"
+	"golang.org/x/tools/vfs"
+	"golang.org/x/tools/vfs/gatefs"
 )
 
 func TestNewDirTree(t *testing.T) {
diff --git a/godoc/index.go b/godoc/index.go
index 05a1a9441ee..a42ac9827b4 100644
--- a/godoc/index.go
+++ b/godoc/index.go
@@ -64,7 +64,7 @@ import (
 	"unicode"
 
 	"golang.org/x/tools/godoc/util"
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 // ----------------------------------------------------------------------------
diff --git a/godoc/index_test.go b/godoc/index_test.go
index 97f31e71b78..a96d2254999 100644
--- a/godoc/index_test.go
+++ b/godoc/index_test.go
@@ -11,7 +11,7 @@ import (
 	"strings"
 	"testing"
 
-	"golang.org/x/tools/godoc/vfs/mapfs"
+	"golang.org/x/tools/vfs/mapfs"
 )
 
 func newCorpus(t *testing.T) *Corpus {
diff --git a/godoc/meta.go b/godoc/meta.go
index 76a27508b68..ed94088cf63 100644
--- a/godoc/meta.go
+++ b/godoc/meta.go
@@ -14,7 +14,7 @@ import (
 	"strings"
 	"time"
 
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 var (
diff --git a/godoc/parser.go b/godoc/parser.go
index c864a0a34a0..aae244c544e 100644
--- a/godoc/parser.go
+++ b/godoc/parser.go
@@ -14,7 +14,7 @@ import (
 	"go/token"
 	pathpkg "path"
 
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 var linePrefix = []byte("//line ")
diff --git a/godoc/pres.go b/godoc/pres.go
index 1daa5a125be..62b38006b04 100644
--- a/godoc/pres.go
+++ b/godoc/pres.go
@@ -10,7 +10,7 @@ import (
 	"sync"
 	"text/template"
 
-	"golang.org/x/tools/godoc/vfs/httpfs"
+	"golang.org/x/tools/vfs/httpfs"
 )
 
 // SearchResultFunc functions return an HTML body for displaying search results.
diff --git a/godoc/server.go b/godoc/server.go
index 92d1ec48d61..d88cf2f1212 100644
--- a/godoc/server.go
+++ b/godoc/server.go
@@ -28,7 +28,7 @@ import (
 
 	"golang.org/x/tools/godoc/analysis"
 	"golang.org/x/tools/godoc/util"
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 // handlerServer is a migration from an old godoc http Handler type.
diff --git a/godoc/server_test.go b/godoc/server_test.go
index 7fa02c53f4a..baa1e405d80 100644
--- a/godoc/server_test.go
+++ b/godoc/server_test.go
@@ -14,7 +14,7 @@ import (
 	"testing"
 	"text/template"
 
-	"golang.org/x/tools/godoc/vfs/mapfs"
+	"golang.org/x/tools/vfs/mapfs"
 )
 
 // TestIgnoredGoFiles tests the scenario where a folder has no .go or .c files,
diff --git a/godoc/static/doc.go b/godoc/static/doc.go
index b3d8bcf34b8..49fcb0167a3 100644
--- a/godoc/static/doc.go
+++ b/godoc/static/doc.go
@@ -4,5 +4,5 @@
 
 // Package static exports a map of static file content that supports the godoc
 // user interface. The map should be used with the mapfs package, see
-// golang.org/x/tools/godoc/vfs/mapfs.
+// golang.org/x/tools/vfs/mapfs.
 package static // import "golang.org/x/tools/godoc/static"
diff --git a/godoc/template.go b/godoc/template.go
index 4418bea09b5..03607d6ddc8 100644
--- a/godoc/template.go
+++ b/godoc/template.go
@@ -38,7 +38,7 @@ import (
 	"regexp"
 	"strings"
 
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 // Functions in this file panic on error, but the panic is recovered
diff --git a/godoc/util/util.go b/godoc/util/util.go
index 21390556e7f..1a3c6e9c2f0 100644
--- a/godoc/util/util.go
+++ b/godoc/util/util.go
@@ -11,7 +11,7 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 // An RWValue wraps a value and permits mutually exclusive
diff --git a/godoc/vfs/emptyvfs.go b/godoc/vfs/emptyvfs.go
index 4ab5c7c649e..674bf757c0b 100644
--- a/godoc/vfs/emptyvfs.go
+++ b/godoc/vfs/emptyvfs.go
@@ -5,85 +5,8 @@
 package vfs
 
 import (
-	"fmt"
-	"os"
-	"time"
+	"golang.org/x/tools/vfs"
 )
 
-// NewNameSpace returns a NameSpace pre-initialized with an empty
-// emulated directory mounted on the root mount point "/". This
-// allows directory traversal routines to work properly even if
-// a folder is not explicitly mounted at root by the user.
-func NewNameSpace() NameSpace {
-	ns := NameSpace{}
-	ns.Bind("/", &emptyVFS{}, "/", BindReplace)
-	return ns
-}
-
-// type emptyVFS emulates a FileSystem consisting of an empty directory
-type emptyVFS struct{}
-
-// Open implements Opener. Since emptyVFS is an empty directory, all
-// attempts to open a file should returns errors.
-func (e *emptyVFS) Open(path string) (ReadSeekCloser, error) {
-	if path == "/" {
-		return nil, fmt.Errorf("open: / is a directory")
-	}
-	return nil, os.ErrNotExist
-}
-
-// Stat returns os.FileInfo for an empty directory if the path
-// is root "/" or error. os.FileInfo is implemented by emptyVFS
-func (e *emptyVFS) Stat(path string) (os.FileInfo, error) {
-	if path == "/" {
-		return e, nil
-	}
-	return nil, os.ErrNotExist
-}
-
-func (e *emptyVFS) Lstat(path string) (os.FileInfo, error) {
-	return e.Stat(path)
-}
-
-// ReadDir returns an empty os.FileInfo slice for "/", else error.
-func (e *emptyVFS) ReadDir(path string) ([]os.FileInfo, error) {
-	if path == "/" {
-		return []os.FileInfo{}, nil
-	}
-	return nil, os.ErrNotExist
-}
-
-func (e *emptyVFS) String() string {
-	return "emptyVFS(/)"
-}
-
-func (e *emptyVFS) RootType(path string) RootType {
-	return ""
-}
-
-// These functions below implement os.FileInfo for the single
-// empty emulated directory.
-
-func (e *emptyVFS) Name() string {
-	return "/"
-}
-
-func (e *emptyVFS) Size() int64 {
-	return 0
-}
-
-func (e *emptyVFS) Mode() os.FileMode {
-	return os.ModeDir | os.ModePerm
-}
-
-func (e *emptyVFS) ModTime() time.Time {
-	return time.Time{}
-}
-
-func (e *emptyVFS) IsDir() bool {
-	return true
-}
-
-func (e *emptyVFS) Sys() any {
-	return nil
-}
+// Deprecated: use [vfs.NewNameSpace]
+var NewNameSpace = vfs.NewNameSpace
diff --git a/godoc/vfs/fs.go b/godoc/vfs/fs.go
index f12d653fef2..01c3a41dd73 100644
--- a/godoc/vfs/fs.go
+++ b/godoc/vfs/fs.go
@@ -3,78 +3,12 @@
 // license that can be found in the LICENSE file.
 
 //go:build go1.16
-// +build go1.16
 
 package vfs
 
 import (
-	"io/fs"
-	"os"
-	"path"
-	"strings"
+	"golang.org/x/tools/vfs"
 )
 
-// FromFS converts an fs.FS to the FileSystem interface.
-func FromFS(fsys fs.FS) FileSystem {
-	return &fsysToFileSystem{fsys}
-}
-
-type fsysToFileSystem struct {
-	fsys fs.FS
-}
-
-func (f *fsysToFileSystem) fsPath(name string) string {
-	name = path.Clean(name)
-	if name == "/" {
-		return "."
-	}
-	return strings.TrimPrefix(name, "/")
-}
-
-func (f *fsysToFileSystem) Open(name string) (ReadSeekCloser, error) {
-	file, err := f.fsys.Open(f.fsPath(name))
-	if err != nil {
-		return nil, err
-	}
-	if rsc, ok := file.(ReadSeekCloser); ok {
-		return rsc, nil
-	}
-	return &noSeekFile{f.fsPath(name), file}, nil
-}
-
-func (f *fsysToFileSystem) Lstat(name string) (os.FileInfo, error) {
-	return fs.Stat(f.fsys, f.fsPath(name))
-}
-
-func (f *fsysToFileSystem) Stat(name string) (os.FileInfo, error) {
-	return fs.Stat(f.fsys, f.fsPath(name))
-}
-
-func (f *fsysToFileSystem) RootType(name string) RootType { return "" }
-
-func (f *fsysToFileSystem) ReadDir(name string) ([]os.FileInfo, error) {
-	dirs, err := fs.ReadDir(f.fsys, f.fsPath(name))
-	var infos []os.FileInfo
-	for _, d := range dirs {
-		info, err1 := d.Info()
-		if err1 != nil {
-			if err == nil {
-				err = err1
-			}
-			continue
-		}
-		infos = append(infos, info)
-	}
-	return infos, err
-}
-
-func (f *fsysToFileSystem) String() string { return "io/fs" }
-
-type noSeekFile struct {
-	path string
-	fs.File
-}
-
-func (f *noSeekFile) Seek(offset int64, whence int) (int64, error) {
-	return 0, &fs.PathError{Op: "seek", Path: f.path, Err: fs.ErrInvalid}
-}
+// Deprecated: use [vfs.FromFS]
+var FromFS = vfs.FromFS
diff --git a/godoc/vfs/gatefs/gatefs.go b/godoc/vfs/gatefs/gatefs.go
index fe0462dc220..faa009edc67 100644
--- a/godoc/vfs/gatefs/gatefs.go
+++ b/godoc/vfs/gatefs/gatefs.go
@@ -4,90 +4,11 @@
 
 // Package gatefs provides an implementation of the FileSystem
 // interface that wraps another FileSystem and limits its concurrency.
-package gatefs // import "golang.org/x/tools/godoc/vfs/gatefs"
+package gatefs // import "golang.org/x/tools/vfs/gatefs"
 
 import (
-	"fmt"
-	"os"
-
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs/gatefs"
 )
 
-// New returns a new FileSystem that delegates to fs.
-// If gateCh is non-nil and buffered, it's used as a gate
-// to limit concurrency on calls to fs.
-func New(fs vfs.FileSystem, gateCh chan bool) vfs.FileSystem {
-	if cap(gateCh) == 0 {
-		return fs
-	}
-	return gatefs{fs, gate(gateCh)}
-}
-
-type gate chan bool
-
-func (g gate) enter() { g <- true }
-func (g gate) leave() { <-g }
-
-type gatefs struct {
-	fs vfs.FileSystem
-	gate
-}
-
-func (fs gatefs) String() string {
-	return fmt.Sprintf("gated(%s, %d)", fs.fs.String(), cap(fs.gate))
-}
-
-func (fs gatefs) RootType(path string) vfs.RootType {
-	return fs.fs.RootType(path)
-}
-
-func (fs gatefs) Open(p string) (vfs.ReadSeekCloser, error) {
-	fs.enter()
-	defer fs.leave()
-	rsc, err := fs.fs.Open(p)
-	if err != nil {
-		return nil, err
-	}
-	return gatef{rsc, fs.gate}, nil
-}
-
-func (fs gatefs) Lstat(p string) (os.FileInfo, error) {
-	fs.enter()
-	defer fs.leave()
-	return fs.fs.Lstat(p)
-}
-
-func (fs gatefs) Stat(p string) (os.FileInfo, error) {
-	fs.enter()
-	defer fs.leave()
-	return fs.fs.Stat(p)
-}
-
-func (fs gatefs) ReadDir(p string) ([]os.FileInfo, error) {
-	fs.enter()
-	defer fs.leave()
-	return fs.fs.ReadDir(p)
-}
-
-type gatef struct {
-	rsc vfs.ReadSeekCloser
-	gate
-}
-
-func (f gatef) Read(p []byte) (n int, err error) {
-	f.enter()
-	defer f.leave()
-	return f.rsc.Read(p)
-}
-
-func (f gatef) Seek(offset int64, whence int) (ret int64, err error) {
-	f.enter()
-	defer f.leave()
-	return f.rsc.Seek(offset, whence)
-}
-
-func (f gatef) Close() error {
-	f.enter()
-	defer f.leave()
-	return f.rsc.Close()
-}
+// Deprecated: use [gatefs.New]
+var New = gatefs.New
diff --git a/godoc/vfs/httpfs/httpfs.go b/godoc/vfs/httpfs/httpfs.go
index f232f03ffdb..bf8c0577fbe 100644
--- a/godoc/vfs/httpfs/httpfs.go
+++ b/godoc/vfs/httpfs/httpfs.go
@@ -3,92 +3,11 @@
 // license that can be found in the LICENSE file.
 
 // Package httpfs implements http.FileSystem using a godoc vfs.FileSystem.
-package httpfs // import "golang.org/x/tools/godoc/vfs/httpfs"
+package httpfs // import "golang.org/x/tools/vfs/httpfs"
 
 import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs/httpfs"
 )
 
-func New(fs vfs.FileSystem) http.FileSystem {
-	return &httpFS{fs}
-}
-
-type httpFS struct {
-	fs vfs.FileSystem
-}
-
-func (h *httpFS) Open(name string) (http.File, error) {
-	fi, err := h.fs.Stat(name)
-	if err != nil {
-		return nil, err
-	}
-	if fi.IsDir() {
-		return &httpDir{h.fs, name, nil}, nil
-	}
-	f, err := h.fs.Open(name)
-	if err != nil {
-		return nil, err
-	}
-	return &httpFile{h.fs, f, name}, nil
-}
-
-// httpDir implements http.File for a directory in a FileSystem.
-type httpDir struct {
-	fs      vfs.FileSystem
-	name    string
-	pending []os.FileInfo
-}
-
-func (h *httpDir) Close() error               { return nil }
-func (h *httpDir) Stat() (os.FileInfo, error) { return h.fs.Stat(h.name) }
-func (h *httpDir) Read([]byte) (int, error) {
-	return 0, fmt.Errorf("cannot Read from directory %s", h.name)
-}
-
-func (h *httpDir) Seek(offset int64, whence int) (int64, error) {
-	if offset == 0 && whence == 0 {
-		h.pending = nil
-		return 0, nil
-	}
-	return 0, fmt.Errorf("unsupported Seek in directory %s", h.name)
-}
-
-func (h *httpDir) Readdir(count int) ([]os.FileInfo, error) {
-	if h.pending == nil {
-		d, err := h.fs.ReadDir(h.name)
-		if err != nil {
-			return nil, err
-		}
-		if d == nil {
-			d = []os.FileInfo{} // not nil
-		}
-		h.pending = d
-	}
-
-	if len(h.pending) == 0 && count > 0 {
-		return nil, io.EOF
-	}
-	if count <= 0 || count > len(h.pending) {
-		count = len(h.pending)
-	}
-	d := h.pending[:count]
-	h.pending = h.pending[count:]
-	return d, nil
-}
-
-// httpFile implements http.File for a file (not directory) in a FileSystem.
-type httpFile struct {
-	fs vfs.FileSystem
-	vfs.ReadSeekCloser
-	name string
-}
-
-func (h *httpFile) Stat() (os.FileInfo, error) { return h.fs.Stat(h.name) }
-func (h *httpFile) Readdir(int) ([]os.FileInfo, error) {
-	return nil, fmt.Errorf("cannot Readdir from file %s", h.name)
-}
+// Deprecated: use [httpfs.New]
+var New = httpfs.New
diff --git a/godoc/vfs/mapfs/mapfs.go b/godoc/vfs/mapfs/mapfs.go
index 06fb4f09543..db783f72cd1 100644
--- a/godoc/vfs/mapfs/mapfs.go
+++ b/godoc/vfs/mapfs/mapfs.go
@@ -4,166 +4,11 @@
 
 // Package mapfs file provides an implementation of the FileSystem
 // interface based on the contents of a map[string]string.
-package mapfs // import "golang.org/x/tools/godoc/vfs/mapfs"
+package mapfs // import "golang.org/x/tools/vfs/mapfs"
 
 import (
-	"fmt"
-	"io"
-	"os"
-	pathpkg "path"
-	"sort"
-	"strings"
-	"time"
-
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs/mapfs"
 )
 
-// New returns a new FileSystem from the provided map.
-// Map keys must be forward slash-separated paths with
-// no leading slash, such as "file1.txt" or "dir/file2.txt".
-// New panics if any of the paths contain a leading slash.
-func New(m map[string]string) vfs.FileSystem {
-	// Verify all provided paths are relative before proceeding.
-	var pathsWithLeadingSlash []string
-	for p := range m {
-		if strings.HasPrefix(p, "/") {
-			pathsWithLeadingSlash = append(pathsWithLeadingSlash, p)
-		}
-	}
-	if len(pathsWithLeadingSlash) > 0 {
-		panic(fmt.Errorf("mapfs.New: invalid paths with a leading slash: %q", pathsWithLeadingSlash))
-	}
-
-	return mapFS(m)
-}
-
-// mapFS is the map based implementation of FileSystem
-type mapFS map[string]string
-
-func (fs mapFS) String() string { return "mapfs" }
-
-func (fs mapFS) RootType(p string) vfs.RootType {
-	return ""
-}
-
-func (fs mapFS) Close() error { return nil }
-
-func filename(p string) string {
-	return strings.TrimPrefix(p, "/")
-}
-
-func (fs mapFS) Open(p string) (vfs.ReadSeekCloser, error) {
-	b, ok := fs[filename(p)]
-	if !ok {
-		return nil, os.ErrNotExist
-	}
-	return nopCloser{strings.NewReader(b)}, nil
-}
-
-func fileInfo(name, contents string) os.FileInfo {
-	return mapFI{name: pathpkg.Base(name), size: len(contents)}
-}
-
-func dirInfo(name string) os.FileInfo {
-	return mapFI{name: pathpkg.Base(name), dir: true}
-}
-
-func (fs mapFS) Lstat(p string) (os.FileInfo, error) {
-	b, ok := fs[filename(p)]
-	if ok {
-		return fileInfo(p, b), nil
-	}
-	ents, _ := fs.ReadDir(p)
-	if len(ents) > 0 {
-		return dirInfo(p), nil
-	}
-	return nil, os.ErrNotExist
-}
-
-func (fs mapFS) Stat(p string) (os.FileInfo, error) {
-	return fs.Lstat(p)
-}
-
-// slashdir returns path.Dir(p), but special-cases paths not beginning
-// with a slash to be in the root.
-func slashdir(p string) string {
-	d := pathpkg.Dir(p)
-	if d == "." {
-		return "/"
-	}
-	if strings.HasPrefix(p, "/") {
-		return d
-	}
-	return "/" + d
-}
-
-func (fs mapFS) ReadDir(p string) ([]os.FileInfo, error) {
-	p = pathpkg.Clean(p)
-	var ents []string
-	fim := make(map[string]os.FileInfo) // base -> fi
-	for fn, b := range fs {
-		dir := slashdir(fn)
-		isFile := true
-		var lastBase string
-		for {
-			if dir == p {
-				base := lastBase
-				if isFile {
-					base = pathpkg.Base(fn)
-				}
-				if fim[base] == nil {
-					var fi os.FileInfo
-					if isFile {
-						fi = fileInfo(fn, b)
-					} else {
-						fi = dirInfo(base)
-					}
-					ents = append(ents, base)
-					fim[base] = fi
-				}
-			}
-			if dir == "/" {
-				break
-			} else {
-				isFile = false
-				lastBase = pathpkg.Base(dir)
-				dir = pathpkg.Dir(dir)
-			}
-		}
-	}
-	if len(ents) == 0 {
-		return nil, os.ErrNotExist
-	}
-
-	sort.Strings(ents)
-	var list []os.FileInfo
-	for _, dir := range ents {
-		list = append(list, fim[dir])
-	}
-	return list, nil
-}
-
-// mapFI is the map-based implementation of FileInfo.
-type mapFI struct {
-	name string
-	size int
-	dir  bool
-}
-
-func (fi mapFI) IsDir() bool        { return fi.dir }
-func (fi mapFI) ModTime() time.Time { return time.Time{} }
-func (fi mapFI) Mode() os.FileMode {
-	if fi.IsDir() {
-		return 0755 | os.ModeDir
-	}
-	return 0444
-}
-func (fi mapFI) Name() string { return pathpkg.Base(fi.name) }
-func (fi mapFI) Size() int64  { return int64(fi.size) }
-func (fi mapFI) Sys() any     { return nil }
-
-type nopCloser struct {
-	io.ReadSeeker
-}
-
-func (nc nopCloser) Close() error { return nil }
+// Deprecated: use [mapfs.New]
+var New = mapfs.New
diff --git a/godoc/vfs/namespace.go b/godoc/vfs/namespace.go
index 2566051a293..4bb541cd865 100644
--- a/godoc/vfs/namespace.go
+++ b/godoc/vfs/namespace.go
@@ -5,383 +5,20 @@
 package vfs
 
 import (
-	"fmt"
-	"io"
-	"os"
-	pathpkg "path"
-	"sort"
-	"strings"
-	"time"
+	"golang.org/x/tools/vfs"
 )
 
-// Setting debugNS = true will enable debugging prints about
-// name space translations.
-const debugNS = false
+// Deprecated: use [vfs.NameSpace]
+type NameSpace = vfs.NameSpace
 
-// A NameSpace is a file system made up of other file systems
-// mounted at specific locations in the name space.
-//
-// The representation is a map from mount point locations
-// to the list of file systems mounted at that location.  A traditional
-// Unix mount table would use a single file system per mount point,
-// but we want to be able to mount multiple file systems on a single
-// mount point and have the system behave as if the union of those
-// file systems were present at the mount point.
-// For example, if the OS file system has a Go installation in
-// c:\Go and additional Go path trees in d:\Work1 and d:\Work2, then
-// this name space creates the view we want for the godoc server:
-//
-//	NameSpace{
-//		"/": {
-//			{old: "/", fs: OS(`c:\Go`), new: "/"},
-//		},
-//		"/src/pkg": {
-//			{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
-//			{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
-//			{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
-//		},
-//	}
-//
-// This is created by executing:
-//
-//	ns := NameSpace{}
-//	ns.Bind("/", OS(`c:\Go`), "/", BindReplace)
-//	ns.Bind("/src/pkg", OS(`d:\Work1`), "/src", BindAfter)
-//	ns.Bind("/src/pkg", OS(`d:\Work2`), "/src", BindAfter)
-//
-// A particular mount point entry is a triple (old, fs, new), meaning that to
-// operate on a path beginning with old, replace that prefix (old) with new
-// and then pass that path to the FileSystem implementation fs.
-//
-// If you do not explicitly mount a FileSystem at the root mountpoint "/" of the
-// NameSpace like above, Stat("/") will return a "not found" error which could
-// break typical directory traversal routines. In such cases, use NewNameSpace()
-// to get a NameSpace pre-initialized with an emulated empty directory at root.
-//
-// Given this name space, a ReadDir of /src/pkg/code will check each prefix
-// of the path for a mount point (first /src/pkg/code, then /src/pkg, then /src,
-// then /), stopping when it finds one.  For the above example, /src/pkg/code
-// will find the mount point at /src/pkg:
-//
-//	{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
-//	{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
-//	{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
-//
-// ReadDir will when execute these three calls and merge the results:
-//
-//	OS(`c:\Go`).ReadDir("/src/pkg/code")
-//	OS(`d:\Work1').ReadDir("/src/code")
-//	OS(`d:\Work2').ReadDir("/src/code")
-//
-// Note that the "/src/pkg" in "/src/pkg/code" has been replaced by
-// just "/src" in the final two calls.
-//
-// OS is itself an implementation of a file system: it implements
-// OS(`c:\Go`).ReadDir("/src/pkg/code") as ioutil.ReadDir(`c:\Go\src\pkg\code`).
-//
-// Because the new path is evaluated by fs (here OS(root)), another way
-// to read the mount table is to mentally combine fs+new, so that this table:
-//
-//	{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
-//	{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
-//	{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
-//
-// reads as:
-//
-//	"/src/pkg" -> c:\Go\src\pkg
-//	"/src/pkg" -> d:\Work1\src
-//	"/src/pkg" -> d:\Work2\src
-//
-// An invariant (a redundancy) of the name space representation is that
-// ns[mtpt][i].old is always equal to mtpt (in the example, ns["/src/pkg"]'s
-// mount table entries always have old == "/src/pkg").  The 'old' field is
-// useful to callers, because they receive just a []mountedFS and not any
-// other indication of which mount point was found.
-type NameSpace map[string][]mountedFS
-
-// A mountedFS handles requests for path by replacing
-// a prefix 'old' with 'new' and then calling the fs methods.
-type mountedFS struct {
-	old string
-	fs  FileSystem
-	new string
-}
-
-// hasPathPrefix reports whether x == y or x == y + "/" + more.
-func hasPathPrefix(x, y string) bool {
-	return x == y || strings.HasPrefix(x, y) && (strings.HasSuffix(y, "/") || strings.HasPrefix(x[len(y):], "/"))
-}
-
-// translate translates path for use in m, replacing old with new.
-//
-// mountedFS{"/src/pkg", fs, "/src"}.translate("/src/pkg/code") == "/src/code".
-func (m mountedFS) translate(path string) string {
-	path = pathpkg.Clean("/" + path)
-	if !hasPathPrefix(path, m.old) {
-		panic("translate " + path + " but old=" + m.old)
-	}
-	return pathpkg.Join(m.new, path[len(m.old):])
-}
-
-func (NameSpace) String() string {
-	return "ns"
-}
-
-// Fprint writes a text representation of the name space to w.
-func (ns NameSpace) Fprint(w io.Writer) {
-	fmt.Fprint(w, "name space {\n")
-	var all []string
-	for mtpt := range ns {
-		all = append(all, mtpt)
-	}
-	sort.Strings(all)
-	for _, mtpt := range all {
-		fmt.Fprintf(w, "\t%s:\n", mtpt)
-		for _, m := range ns[mtpt] {
-			fmt.Fprintf(w, "\t\t%s %s\n", m.fs, m.new)
-		}
-	}
-	fmt.Fprint(w, "}\n")
-}
-
-// clean returns a cleaned, rooted path for evaluation.
-// It canonicalizes the path so that we can use string operations
-// to analyze it.
-func (NameSpace) clean(path string) string {
-	return pathpkg.Clean("/" + path)
-}
-
-type BindMode int
+// Deprecated: use [vfs.BindMode]
+type BindMode = vfs.BindMode
 
 const (
-	BindReplace BindMode = iota
-	BindBefore
-	BindAfter
+	// Deprecated: use [vfs.BindReplace]
+	BindReplace = vfs.BindReplace
+	// Deprecated: use [vfs.BindBefore]
+	BindBefore = vfs.BindBefore
+	// Deprecated: use [vfs.BindAfter]
+	BindAfter = vfs.BindAfter
 )
-
-// Bind causes references to old to redirect to the path new in newfs.
-// If mode is BindReplace, old redirections are discarded.
-// If mode is BindBefore, this redirection takes priority over existing ones,
-// but earlier ones are still consulted for paths that do not exist in newfs.
-// If mode is BindAfter, this redirection happens only after existing ones
-// have been tried and failed.
-func (ns NameSpace) Bind(old string, newfs FileSystem, new string, mode BindMode) {
-	old = ns.clean(old)
-	new = ns.clean(new)
-	m := mountedFS{old, newfs, new}
-	var mtpt []mountedFS
-	switch mode {
-	case BindReplace:
-		mtpt = append(mtpt, m)
-	case BindAfter:
-		mtpt = append(mtpt, ns.resolve(old)...)
-		mtpt = append(mtpt, m)
-	case BindBefore:
-		mtpt = append(mtpt, m)
-		mtpt = append(mtpt, ns.resolve(old)...)
-	}
-
-	// Extend m.old, m.new in inherited mount point entries.
-	for i := range mtpt {
-		m := &mtpt[i]
-		if m.old != old {
-			if !hasPathPrefix(old, m.old) {
-				// This should not happen.  If it does, panic so
-				// that we can see the call trace that led to it.
-				panic(fmt.Sprintf("invalid Bind: old=%q m={%q, %s, %q}", old, m.old, m.fs.String(), m.new))
-			}
-			suffix := old[len(m.old):]
-			m.old = pathpkg.Join(m.old, suffix)
-			m.new = pathpkg.Join(m.new, suffix)
-		}
-	}
-
-	ns[old] = mtpt
-}
-
-// resolve resolves a path to the list of mountedFS to use for path.
-func (ns NameSpace) resolve(path string) []mountedFS {
-	path = ns.clean(path)
-	for {
-		if m := ns[path]; m != nil {
-			if debugNS {
-				fmt.Printf("resolve %s: %v\n", path, m)
-			}
-			return m
-		}
-		if path == "/" {
-			break
-		}
-		path = pathpkg.Dir(path)
-	}
-	return nil
-}
-
-// Open implements the FileSystem Open method.
-func (ns NameSpace) Open(path string) (ReadSeekCloser, error) {
-	var err error
-	for _, m := range ns.resolve(path) {
-		if debugNS {
-			fmt.Printf("tx %s: %v\n", path, m.translate(path))
-		}
-		tp := m.translate(path)
-		r, err1 := m.fs.Open(tp)
-		if err1 == nil {
-			return r, nil
-		}
-		// IsNotExist errors in overlay FSes can mask real errors in
-		// the underlying FS, so ignore them if there is another error.
-		if err == nil || os.IsNotExist(err) {
-			err = err1
-		}
-	}
-	if err == nil {
-		err = &os.PathError{Op: "open", Path: path, Err: os.ErrNotExist}
-	}
-	return nil, err
-}
-
-// stat implements the FileSystem Stat and Lstat methods.
-func (ns NameSpace) stat(path string, f func(FileSystem, string) (os.FileInfo, error)) (os.FileInfo, error) {
-	var err error
-	for _, m := range ns.resolve(path) {
-		fi, err1 := f(m.fs, m.translate(path))
-		if err1 == nil {
-			return fi, nil
-		}
-		if err == nil {
-			err = err1
-		}
-	}
-	if err == nil {
-		err = &os.PathError{Op: "stat", Path: path, Err: os.ErrNotExist}
-	}
-	return nil, err
-}
-
-func (ns NameSpace) Stat(path string) (os.FileInfo, error) {
-	return ns.stat(path, FileSystem.Stat)
-}
-
-func (ns NameSpace) Lstat(path string) (os.FileInfo, error) {
-	return ns.stat(path, FileSystem.Lstat)
-}
-
-// dirInfo is a trivial implementation of os.FileInfo for a directory.
-type dirInfo string
-
-func (d dirInfo) Name() string       { return string(d) }
-func (d dirInfo) Size() int64        { return 0 }
-func (d dirInfo) Mode() os.FileMode  { return os.ModeDir | 0555 }
-func (d dirInfo) ModTime() time.Time { return startTime }
-func (d dirInfo) IsDir() bool        { return true }
-func (d dirInfo) Sys() any           { return nil }
-
-var startTime = time.Now()
-
-// ReadDir implements the FileSystem ReadDir method.  It's where most of the magic is.
-// (The rest is in resolve.)
-//
-// Logically, ReadDir must return the union of all the directories that are named
-// by path.  In order to avoid misinterpreting Go packages, of all the directories
-// that contain Go source code, we only include the files from the first,
-// but we include subdirectories from all.
-//
-// ReadDir must also return directory entries needed to reach mount points.
-// If the name space looks like the example in the type NameSpace comment,
-// but c:\Go does not have a src/pkg subdirectory, we still want to be able
-// to find that subdirectory, because we've mounted d:\Work1 and d:\Work2
-// there.  So if we don't see "src" in the directory listing for c:\Go, we add an
-// entry for it before returning.
-func (ns NameSpace) ReadDir(path string) ([]os.FileInfo, error) {
-	path = ns.clean(path)
-
-	// List matching directories and determine whether any of them contain
-	// Go files.
-	var (
-		dirs       [][]os.FileInfo
-		goDirIndex = -1
-		readDirErr error
-	)
-
-	for _, m := range ns.resolve(path) {
-		dir, err := m.fs.ReadDir(m.translate(path))
-		if err != nil {
-			if readDirErr == nil {
-				readDirErr = err
-			}
-			continue
-		}
-
-		dirs = append(dirs, dir)
-
-		if goDirIndex < 0 {
-			for _, f := range dir {
-				if !f.IsDir() && strings.HasSuffix(f.Name(), ".go") {
-					goDirIndex = len(dirs) - 1
-					break
-				}
-			}
-		}
-	}
-
-	// Build a list of files and subdirectories. If a directory contains Go files,
-	// only include files from that directory. Otherwise, include files from
-	// all directories. Include subdirectories from all directories regardless
-	// of whether Go files are present.
-	haveName := make(map[string]bool)
-	var all []os.FileInfo
-	for i, dir := range dirs {
-		for _, f := range dir {
-			name := f.Name()
-			if !haveName[name] && (f.IsDir() || goDirIndex < 0 || goDirIndex == i) {
-				all = append(all, f)
-				haveName[name] = true
-			}
-		}
-	}
-
-	// Add any missing directories needed to reach mount points.
-	for old := range ns {
-		if hasPathPrefix(old, path) && old != path {
-			// Find next element after path in old.
-			elem := old[len(path):]
-			elem = strings.TrimPrefix(elem, "/")
-			if i := strings.Index(elem, "/"); i >= 0 {
-				elem = elem[:i]
-			}
-			if !haveName[elem] {
-				haveName[elem] = true
-				all = append(all, dirInfo(elem))
-			}
-		}
-	}
-
-	if len(all) == 0 {
-		return nil, readDirErr
-	}
-
-	sort.Sort(byName(all))
-	return all, nil
-}
-
-// RootType returns the RootType for the given path in the namespace.
-func (ns NameSpace) RootType(path string) RootType {
-	// We resolve the given path to a list of mountedFS and then return
-	// the root type for the filesystem which contains the path.
-	for _, m := range ns.resolve(path) {
-		_, err := m.fs.ReadDir(m.translate(path))
-		// Found a match, return the filesystem's root type
-		if err == nil {
-			return m.fs.RootType(path)
-		}
-	}
-	return ""
-}
-
-// byName implements sort.Interface.
-type byName []os.FileInfo
-
-func (f byName) Len() int           { return len(f) }
-func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }
-func (f byName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
diff --git a/godoc/vfs/os.go b/godoc/vfs/os.go
index 35d050946e6..9c0df104e99 100644
--- a/godoc/vfs/os.go
+++ b/godoc/vfs/os.go
@@ -5,101 +5,14 @@
 package vfs
 
 import (
-	"fmt"
-	"go/build"
-	"io/ioutil"
-	"os"
-	pathpkg "path"
-	"path/filepath"
-	"runtime"
+	"golang.org/x/tools/vfs"
 )
 
 // We expose a new variable because otherwise we need to copy the findGOROOT logic again
 // from cmd/godoc which is already copied twice from the standard library.
 
-// GOROOT is the GOROOT path under which the godoc binary is running.
-// It is needed to check whether a filesystem root is under GOROOT or not.
-// This is set from cmd/godoc/main.go.
-var GOROOT = runtime.GOROOT()
+// Deprecated: use [vfs.GOROOT]
+var GOROOT = vfs.GOROOT
 
-// OS returns an implementation of FileSystem reading from the
-// tree rooted at root.  Recording a root is convenient everywhere
-// but necessary on Windows, because the slash-separated path
-// passed to Open has no way to specify a drive letter.  Using a root
-// lets code refer to OS(`c:\`), OS(`d:\`) and so on.
-func OS(root string) FileSystem {
-	var t RootType
-	switch {
-	case root == GOROOT:
-		t = RootTypeGoRoot
-	case isGoPath(root):
-		t = RootTypeGoPath
-	}
-	return osFS{rootPath: root, rootType: t}
-}
-
-type osFS struct {
-	rootPath string
-	rootType RootType
-}
-
-func isGoPath(path string) bool {
-	for _, bp := range filepath.SplitList(build.Default.GOPATH) {
-		for _, gp := range filepath.SplitList(path) {
-			if bp == gp {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func (root osFS) String() string { return "os(" + root.rootPath + ")" }
-
-// RootType returns the root type for the filesystem.
-//
-// Note that we ignore the path argument because roottype is a property of
-// this filesystem. But for other filesystems, the roottype might need to be
-// dynamically deduced at call time.
-func (root osFS) RootType(path string) RootType {
-	return root.rootType
-}
-
-func (root osFS) resolve(path string) string {
-	// Clean the path so that it cannot possibly begin with ../.
-	// If it did, the result of filepath.Join would be outside the
-	// tree rooted at root.  We probably won't ever see a path
-	// with .. in it, but be safe anyway.
-	path = pathpkg.Clean("/" + path)
-
-	return filepath.Join(root.rootPath, path)
-}
-
-func (root osFS) Open(path string) (ReadSeekCloser, error) {
-	f, err := os.Open(root.resolve(path))
-	if err != nil {
-		return nil, err
-	}
-	fi, err := f.Stat()
-	if err != nil {
-		f.Close()
-		return nil, err
-	}
-	if fi.IsDir() {
-		f.Close()
-		return nil, fmt.Errorf("Open: %s is a directory", path)
-	}
-	return f, nil
-}
-
-func (root osFS) Lstat(path string) (os.FileInfo, error) {
-	return os.Lstat(root.resolve(path))
-}
-
-func (root osFS) Stat(path string) (os.FileInfo, error) {
-	return os.Stat(root.resolve(path))
-}
-
-func (root osFS) ReadDir(path string) ([]os.FileInfo, error) {
-	return ioutil.ReadDir(root.resolve(path)) // is sorted
-}
+// Deprecated: use [vfs.OS]
+var OS = vfs.OS
diff --git a/godoc/vfs/vfs.go b/godoc/vfs/vfs.go
index f4ec2aa7a02..95e0047a1f4 100644
--- a/godoc/vfs/vfs.go
+++ b/godoc/vfs/vfs.go
@@ -4,54 +4,30 @@
 
 // Package vfs defines types for abstract file system access and provides an
 // implementation accessing the file system of the underlying OS.
-package vfs // import "golang.org/x/tools/godoc/vfs"
+package vfs // import "golang.org/x/tools/vfs"
 
 import (
-	"io"
-	"os"
+	"golang.org/x/tools/vfs"
 )
 
-// RootType indicates the type of files contained within a directory.
-//
-// It is used to indicate whether a directory is the root
-// of a GOROOT, a GOPATH, or neither.
-// An empty string represents the case when a directory is neither.
-type RootType string
+// Deprecated: use [vfs.RootType]
+type RootType = vfs.RootType
 
 const (
-	RootTypeGoRoot RootType = "GOROOT"
-	RootTypeGoPath RootType = "GOPATH"
+	// Deprecated: use [fs.RootTypeGoRoot]
+	RootTypeGoRoot = vfs.RootTypeGoRoot
+	// Deprecated: use [fs.RootTypeGoPath]
+	RootTypeGoPath = vfs.RootTypeGoPath
 )
 
-// The FileSystem interface specifies the methods godoc is using
-// to access the file system for which it serves documentation.
-type FileSystem interface {
-	Opener
-	Lstat(path string) (os.FileInfo, error)
-	Stat(path string) (os.FileInfo, error)
-	ReadDir(path string) ([]os.FileInfo, error)
-	RootType(path string) RootType
-	String() string
-}
-
-// Opener is a minimal virtual filesystem that can only open regular files.
-type Opener interface {
-	Open(name string) (ReadSeekCloser, error)
-}
-
-// A ReadSeekCloser can Read, Seek, and Close.
-type ReadSeekCloser interface {
-	io.Reader
-	io.Seeker
-	io.Closer
-}
-
-// ReadFile reads the file named by path from fs and returns the contents.
-func ReadFile(fs Opener, path string) ([]byte, error) {
-	rc, err := fs.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer rc.Close()
-	return io.ReadAll(rc)
-}
+// Deprecated: use [vfs.FileSystem]
+type FileSystem = vfs.FileSystem
+
+// Deprecated: use [vfs.Opener]
+type Opener = vfs.Opener
+
+// Deprecated: use [vfs.ReadSeekCloser]
+type ReadSeekCloser = vfs.ReadSeekCloser
+
+// Deprecated: use [vfs.ReadFile]
+var ReadFile = vfs.ReadFile
diff --git a/godoc/vfs/zipfs/zipfs.go b/godoc/vfs/zipfs/zipfs.go
index cdf231a1abd..0bd76d335cf 100644
--- a/godoc/vfs/zipfs/zipfs.go
+++ b/godoc/vfs/zipfs/zipfs.go
@@ -15,277 +15,11 @@
 //     like absolute paths w/o a leading '/'; i.e., the paths are considered
 //     relative to the root of the file system.
 //   - All path arguments to file system methods must be absolute paths.
-package zipfs // import "golang.org/x/tools/godoc/vfs/zipfs"
+package zipfs // import "golang.org/x/tools/vfs/zipfs"
 
 import (
-	"archive/zip"
-	"fmt"
-	"go/build"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"sort"
-	"strings"
-	"time"
-
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs/zipfs"
 )
 
-// zipFI is the zip-file based implementation of FileInfo
-type zipFI struct {
-	name string    // directory-local name
-	file *zip.File // nil for a directory
-}
-
-func (fi zipFI) Name() string {
-	return fi.name
-}
-
-func (fi zipFI) Size() int64 {
-	if f := fi.file; f != nil {
-		return int64(f.UncompressedSize)
-	}
-	return 0 // directory
-}
-
-func (fi zipFI) ModTime() time.Time {
-	if f := fi.file; f != nil {
-		return f.ModTime()
-	}
-	return time.Time{} // directory has no modified time entry
-}
-
-func (fi zipFI) Mode() os.FileMode {
-	if fi.file == nil {
-		// Unix directories typically are executable, hence 555.
-		return os.ModeDir | 0555
-	}
-	return 0444
-}
-
-func (fi zipFI) IsDir() bool {
-	return fi.file == nil
-}
-
-func (fi zipFI) Sys() any {
-	return nil
-}
-
-// zipFS is the zip-file based implementation of FileSystem
-type zipFS struct {
-	*zip.ReadCloser
-	list zipList
-	name string
-}
-
-func (fs *zipFS) String() string {
-	return "zip(" + fs.name + ")"
-}
-
-func (fs *zipFS) RootType(abspath string) vfs.RootType {
-	var t vfs.RootType
-	switch {
-	case exists(path.Join(vfs.GOROOT, abspath)):
-		t = vfs.RootTypeGoRoot
-	case isGoPath(abspath):
-		t = vfs.RootTypeGoPath
-	}
-	return t
-}
-
-func isGoPath(abspath string) bool {
-	for _, p := range filepath.SplitList(build.Default.GOPATH) {
-		if exists(path.Join(p, abspath)) {
-			return true
-		}
-	}
-	return false
-}
-
-func exists(path string) bool {
-	_, err := os.Stat(path)
-	return err == nil
-}
-
-func (fs *zipFS) Close() error {
-	fs.list = nil
-	return fs.ReadCloser.Close()
-}
-
-func zipPath(name string) (string, error) {
-	name = path.Clean(name)
-	if !path.IsAbs(name) {
-		return "", fmt.Errorf("stat: not an absolute path: %s", name)
-	}
-	return name[1:], nil // strip leading '/'
-}
-
-func isRoot(abspath string) bool {
-	return path.Clean(abspath) == "/"
-}
-
-func (fs *zipFS) stat(abspath string) (int, zipFI, error) {
-	if isRoot(abspath) {
-		return 0, zipFI{
-			name: "",
-			file: nil,
-		}, nil
-	}
-	zippath, err := zipPath(abspath)
-	if err != nil {
-		return 0, zipFI{}, err
-	}
-	i, exact := fs.list.lookup(zippath)
-	if i < 0 {
-		// zippath has leading '/' stripped - print it explicitly
-		return -1, zipFI{}, &os.PathError{Path: "/" + zippath, Err: os.ErrNotExist}
-	}
-	_, name := path.Split(zippath)
-	var file *zip.File
-	if exact {
-		file = fs.list[i] // exact match found - must be a file
-	}
-	return i, zipFI{name, file}, nil
-}
-
-func (fs *zipFS) Open(abspath string) (vfs.ReadSeekCloser, error) {
-	_, fi, err := fs.stat(abspath)
-	if err != nil {
-		return nil, err
-	}
-	if fi.IsDir() {
-		return nil, fmt.Errorf("Open: %s is a directory", abspath)
-	}
-	r, err := fi.file.Open()
-	if err != nil {
-		return nil, err
-	}
-	return &zipSeek{fi.file, r}, nil
-}
-
-type zipSeek struct {
-	file *zip.File
-	io.ReadCloser
-}
-
-func (f *zipSeek) Seek(offset int64, whence int) (int64, error) {
-	if whence == 0 && offset == 0 {
-		r, err := f.file.Open()
-		if err != nil {
-			return 0, err
-		}
-		f.Close()
-		f.ReadCloser = r
-		return 0, nil
-	}
-	return 0, fmt.Errorf("unsupported Seek in %s", f.file.Name)
-}
-
-func (fs *zipFS) Lstat(abspath string) (os.FileInfo, error) {
-	_, fi, err := fs.stat(abspath)
-	return fi, err
-}
-
-func (fs *zipFS) Stat(abspath string) (os.FileInfo, error) {
-	_, fi, err := fs.stat(abspath)
-	return fi, err
-}
-
-func (fs *zipFS) ReadDir(abspath string) ([]os.FileInfo, error) {
-	i, fi, err := fs.stat(abspath)
-	if err != nil {
-		return nil, err
-	}
-	if !fi.IsDir() {
-		return nil, fmt.Errorf("ReadDir: %s is not a directory", abspath)
-	}
-
-	var list []os.FileInfo
-
-	// make dirname the prefix that file names must start with to be considered
-	// in this directory. we must special case the root directory because, per
-	// the spec of this package, zip file entries MUST NOT start with /, so we
-	// should not append /, as we would in every other case.
-	var dirname string
-	if isRoot(abspath) {
-		dirname = ""
-	} else {
-		zippath, err := zipPath(abspath)
-		if err != nil {
-			return nil, err
-		}
-		dirname = zippath + "/"
-	}
-	prevname := ""
-	for _, e := range fs.list[i:] {
-		if !strings.HasPrefix(e.Name, dirname) {
-			break // not in the same directory anymore
-		}
-		name := e.Name[len(dirname):] // local name
-		file := e
-		if i := strings.IndexRune(name, '/'); i >= 0 {
-			// We infer directories from files in subdirectories.
-			// If we have x/y, return a directory entry for x.
-			name = name[0:i] // keep local directory name only
-			file = nil
-		}
-		// If we have x/y and x/z, don't return two directory entries for x.
-		// TODO(gri): It should be possible to do this more efficiently
-		// by determining the (fs.list) range of local directory entries
-		// (via two binary searches).
-		if name != prevname {
-			list = append(list, zipFI{name, file})
-			prevname = name
-		}
-	}
-
-	return list, nil
-}
-
-func New(rc *zip.ReadCloser, name string) vfs.FileSystem {
-	list := make(zipList, len(rc.File))
-	copy(list, rc.File) // sort a copy of rc.File
-	sort.Sort(list)
-	return &zipFS{rc, list, name}
-}
-
-type zipList []*zip.File
-
-// zipList implements sort.Interface
-func (z zipList) Len() int           { return len(z) }
-func (z zipList) Less(i, j int) bool { return z[i].Name < z[j].Name }
-func (z zipList) Swap(i, j int)      { z[i], z[j] = z[j], z[i] }
-
-// lookup returns the smallest index of an entry with an exact match
-// for name, or an inexact match starting with name/. If there is no
-// such entry, the result is -1, false.
-func (z zipList) lookup(name string) (index int, exact bool) {
-	// look for exact match first (name comes before name/ in z)
-	i := sort.Search(len(z), func(i int) bool {
-		return name <= z[i].Name
-	})
-	if i >= len(z) {
-		return -1, false
-	}
-	// 0 <= i < len(z)
-	if z[i].Name == name {
-		return i, true
-	}
-
-	// look for inexact match (must be in z[i:], if present)
-	z = z[i:]
-	name += "/"
-	j := sort.Search(len(z), func(i int) bool {
-		return name <= z[i].Name
-	})
-	if j >= len(z) {
-		return -1, false
-	}
-	// 0 <= j < len(z)
-	if strings.HasPrefix(z[j].Name, name) {
-		return i + j, false
-	}
-
-	return -1, false
-}
+// Deprecated: use [zipfs.New]
+var New = zipfs.New
diff --git a/vfs/emptyvfs.go b/vfs/emptyvfs.go
new file mode 100644
index 00000000000..4ab5c7c649e
--- /dev/null
+++ b/vfs/emptyvfs.go
@@ -0,0 +1,89 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package vfs
+
+import (
+	"fmt"
+	"os"
+	"time"
+)
+
+// NewNameSpace returns a NameSpace pre-initialized with an empty
+// emulated directory mounted on the root mount point "/". This
+// allows directory traversal routines to work properly even if
+// a folder is not explicitly mounted at root by the user.
+func NewNameSpace() NameSpace {
+	ns := NameSpace{}
+	ns.Bind("/", &emptyVFS{}, "/", BindReplace)
+	return ns
+}
+
+// type emptyVFS emulates a FileSystem consisting of an empty directory
+type emptyVFS struct{}
+
+// Open implements Opener. Since emptyVFS is an empty directory, all
+// attempts to open a file should returns errors.
+func (e *emptyVFS) Open(path string) (ReadSeekCloser, error) {
+	if path == "/" {
+		return nil, fmt.Errorf("open: / is a directory")
+	}
+	return nil, os.ErrNotExist
+}
+
+// Stat returns os.FileInfo for an empty directory if the path
+// is root "/" or error. os.FileInfo is implemented by emptyVFS
+func (e *emptyVFS) Stat(path string) (os.FileInfo, error) {
+	if path == "/" {
+		return e, nil
+	}
+	return nil, os.ErrNotExist
+}
+
+func (e *emptyVFS) Lstat(path string) (os.FileInfo, error) {
+	return e.Stat(path)
+}
+
+// ReadDir returns an empty os.FileInfo slice for "/", else error.
+func (e *emptyVFS) ReadDir(path string) ([]os.FileInfo, error) {
+	if path == "/" {
+		return []os.FileInfo{}, nil
+	}
+	return nil, os.ErrNotExist
+}
+
+func (e *emptyVFS) String() string {
+	return "emptyVFS(/)"
+}
+
+func (e *emptyVFS) RootType(path string) RootType {
+	return ""
+}
+
+// These functions below implement os.FileInfo for the single
+// empty emulated directory.
+
+func (e *emptyVFS) Name() string {
+	return "/"
+}
+
+func (e *emptyVFS) Size() int64 {
+	return 0
+}
+
+func (e *emptyVFS) Mode() os.FileMode {
+	return os.ModeDir | os.ModePerm
+}
+
+func (e *emptyVFS) ModTime() time.Time {
+	return time.Time{}
+}
+
+func (e *emptyVFS) IsDir() bool {
+	return true
+}
+
+func (e *emptyVFS) Sys() any {
+	return nil
+}
diff --git a/vfs/fs.go b/vfs/fs.go
new file mode 100644
index 00000000000..2bec5886052
--- /dev/null
+++ b/vfs/fs.go
@@ -0,0 +1,79 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+
+package vfs
+
+import (
+	"io/fs"
+	"os"
+	"path"
+	"strings"
+)
+
+// FromFS converts an fs.FS to the FileSystem interface.
+func FromFS(fsys fs.FS) FileSystem {
+	return &fsysToFileSystem{fsys}
+}
+
+type fsysToFileSystem struct {
+	fsys fs.FS
+}
+
+func (f *fsysToFileSystem) fsPath(name string) string {
+	name = path.Clean(name)
+	if name == "/" {
+		return "."
+	}
+	return strings.TrimPrefix(name, "/")
+}
+
+func (f *fsysToFileSystem) Open(name string) (ReadSeekCloser, error) {
+	file, err := f.fsys.Open(f.fsPath(name))
+	if err != nil {
+		return nil, err
+	}
+	if rsc, ok := file.(ReadSeekCloser); ok {
+		return rsc, nil
+	}
+	return &noSeekFile{f.fsPath(name), file}, nil
+}
+
+func (f *fsysToFileSystem) Lstat(name string) (os.FileInfo, error) {
+	return fs.Stat(f.fsys, f.fsPath(name))
+}
+
+func (f *fsysToFileSystem) Stat(name string) (os.FileInfo, error) {
+	return fs.Stat(f.fsys, f.fsPath(name))
+}
+
+func (f *fsysToFileSystem) RootType(name string) RootType { return "" }
+
+func (f *fsysToFileSystem) ReadDir(name string) ([]os.FileInfo, error) {
+	dirs, err := fs.ReadDir(f.fsys, f.fsPath(name))
+	var infos []os.FileInfo
+	for _, d := range dirs {
+		info, err1 := d.Info()
+		if err1 != nil {
+			if err == nil {
+				err = err1
+			}
+			continue
+		}
+		infos = append(infos, info)
+	}
+	return infos, err
+}
+
+func (f *fsysToFileSystem) String() string { return "io/fs" }
+
+type noSeekFile struct {
+	path string
+	fs.File
+}
+
+func (f *noSeekFile) Seek(offset int64, whence int) (int64, error) {
+	return 0, &fs.PathError{Op: "seek", Path: f.path, Err: fs.ErrInvalid}
+}
diff --git a/vfs/gatefs/gatefs.go b/vfs/gatefs/gatefs.go
new file mode 100644
index 00000000000..f443d8f6264
--- /dev/null
+++ b/vfs/gatefs/gatefs.go
@@ -0,0 +1,93 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package gatefs provides an implementation of the FileSystem
+// interface that wraps another FileSystem and limits its concurrency.
+package gatefs // import "golang.org/x/tools/vfs/gatefs"
+
+import (
+	"fmt"
+	"os"
+
+	"golang.org/x/tools/vfs"
+)
+
+// New returns a new FileSystem that delegates to fs.
+// If gateCh is non-nil and buffered, it's used as a gate
+// to limit concurrency on calls to fs.
+func New(fs vfs.FileSystem, gateCh chan bool) vfs.FileSystem {
+	if cap(gateCh) == 0 {
+		return fs
+	}
+	return gatefs{fs, gate(gateCh)}
+}
+
+type gate chan bool
+
+func (g gate) enter() { g <- true }
+func (g gate) leave() { <-g }
+
+type gatefs struct {
+	fs vfs.FileSystem
+	gate
+}
+
+func (fs gatefs) String() string {
+	return fmt.Sprintf("gated(%s, %d)", fs.fs.String(), cap(fs.gate))
+}
+
+func (fs gatefs) RootType(path string) vfs.RootType {
+	return fs.fs.RootType(path)
+}
+
+func (fs gatefs) Open(p string) (vfs.ReadSeekCloser, error) {
+	fs.enter()
+	defer fs.leave()
+	rsc, err := fs.fs.Open(p)
+	if err != nil {
+		return nil, err
+	}
+	return gatef{rsc, fs.gate}, nil
+}
+
+func (fs gatefs) Lstat(p string) (os.FileInfo, error) {
+	fs.enter()
+	defer fs.leave()
+	return fs.fs.Lstat(p)
+}
+
+func (fs gatefs) Stat(p string) (os.FileInfo, error) {
+	fs.enter()
+	defer fs.leave()
+	return fs.fs.Stat(p)
+}
+
+func (fs gatefs) ReadDir(p string) ([]os.FileInfo, error) {
+	fs.enter()
+	defer fs.leave()
+	return fs.fs.ReadDir(p)
+}
+
+type gatef struct {
+	rsc vfs.ReadSeekCloser
+	gate
+}
+
+func (f gatef) Read(p []byte) (n int, err error) {
+	f.enter()
+	defer f.leave()
+	return f.rsc.Read(p)
+}
+
+func (f gatef) Seek(offset int64, whence int) (ret int64, err error) {
+	f.enter()
+	defer f.leave()
+	return f.rsc.Seek(offset, whence)
+}
+
+func (f gatef) Close() error {
+	f.enter()
+	defer f.leave()
+	return f.rsc.Close()
+}
diff --git a/godoc/vfs/gatefs/gatefs_test.go b/vfs/gatefs/gatefs_test.go
similarity index 91%
rename from godoc/vfs/gatefs/gatefs_test.go
rename to vfs/gatefs/gatefs_test.go
index a0156b4504d..79e255b077c 100644
--- a/godoc/vfs/gatefs/gatefs_test.go
+++ b/vfs/gatefs/gatefs_test.go
@@ -9,8 +9,8 @@ import (
 	"runtime"
 	"testing"
 
-	"golang.org/x/tools/godoc/vfs"
-	"golang.org/x/tools/godoc/vfs/gatefs"
+	"golang.org/x/tools/vfs"
+	"golang.org/x/tools/vfs/gatefs"
 )
 
 func TestRootType(t *testing.T) {
diff --git a/vfs/httpfs/httpfs.go b/vfs/httpfs/httpfs.go
new file mode 100644
index 00000000000..7419f36102e
--- /dev/null
+++ b/vfs/httpfs/httpfs.go
@@ -0,0 +1,94 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package httpfs implements http.FileSystem using a godoc vfs.FileSystem.
+package httpfs // import "golang.org/x/tools/vfs/httpfs"
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+
+	"golang.org/x/tools/vfs"
+)
+
+func New(fs vfs.FileSystem) http.FileSystem {
+	return &httpFS{fs}
+}
+
+type httpFS struct {
+	fs vfs.FileSystem
+}
+
+func (h *httpFS) Open(name string) (http.File, error) {
+	fi, err := h.fs.Stat(name)
+	if err != nil {
+		return nil, err
+	}
+	if fi.IsDir() {
+		return &httpDir{h.fs, name, nil}, nil
+	}
+	f, err := h.fs.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	return &httpFile{h.fs, f, name}, nil
+}
+
+// httpDir implements http.File for a directory in a FileSystem.
+type httpDir struct {
+	fs      vfs.FileSystem
+	name    string
+	pending []os.FileInfo
+}
+
+func (h *httpDir) Close() error               { return nil }
+func (h *httpDir) Stat() (os.FileInfo, error) { return h.fs.Stat(h.name) }
+func (h *httpDir) Read([]byte) (int, error) {
+	return 0, fmt.Errorf("cannot Read from directory %s", h.name)
+}
+
+func (h *httpDir) Seek(offset int64, whence int) (int64, error) {
+	if offset == 0 && whence == 0 {
+		h.pending = nil
+		return 0, nil
+	}
+	return 0, fmt.Errorf("unsupported Seek in directory %s", h.name)
+}
+
+func (h *httpDir) Readdir(count int) ([]os.FileInfo, error) {
+	if h.pending == nil {
+		d, err := h.fs.ReadDir(h.name)
+		if err != nil {
+			return nil, err
+		}
+		if d == nil {
+			d = []os.FileInfo{} // not nil
+		}
+		h.pending = d
+	}
+
+	if len(h.pending) == 0 && count > 0 {
+		return nil, io.EOF
+	}
+	if count <= 0 || count > len(h.pending) {
+		count = len(h.pending)
+	}
+	d := h.pending[:count]
+	h.pending = h.pending[count:]
+	return d, nil
+}
+
+// httpFile implements http.File for a file (not directory) in a FileSystem.
+type httpFile struct {
+	fs vfs.FileSystem
+	vfs.ReadSeekCloser
+	name string
+}
+
+func (h *httpFile) Stat() (os.FileInfo, error) { return h.fs.Stat(h.name) }
+func (h *httpFile) Readdir(int) ([]os.FileInfo, error) {
+	return nil, fmt.Errorf("cannot Readdir from file %s", h.name)
+}
diff --git a/vfs/mapfs/mapfs.go b/vfs/mapfs/mapfs.go
new file mode 100644
index 00000000000..1639a8961cf
--- /dev/null
+++ b/vfs/mapfs/mapfs.go
@@ -0,0 +1,169 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package mapfs file provides an implementation of the FileSystem
+// interface based on the contents of a map[string]string.
+package mapfs // import "golang.org/x/tools/vfs/mapfs"
+
+import (
+	"fmt"
+	"io"
+	"os"
+	pathpkg "path"
+	"sort"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/vfs"
+)
+
+// New returns a new FileSystem from the provided map.
+// Map keys must be forward slash-separated paths with
+// no leading slash, such as "file1.txt" or "dir/file2.txt".
+// New panics if any of the paths contain a leading slash.
+func New(m map[string]string) vfs.FileSystem {
+	// Verify all provided paths are relative before proceeding.
+	var pathsWithLeadingSlash []string
+	for p := range m {
+		if strings.HasPrefix(p, "/") {
+			pathsWithLeadingSlash = append(pathsWithLeadingSlash, p)
+		}
+	}
+	if len(pathsWithLeadingSlash) > 0 {
+		panic(fmt.Errorf("mapfs.New: invalid paths with a leading slash: %q", pathsWithLeadingSlash))
+	}
+
+	return mapFS(m)
+}
+
+// mapFS is the map based implementation of FileSystem
+type mapFS map[string]string
+
+func (fs mapFS) String() string { return "mapfs" }
+
+func (fs mapFS) RootType(p string) vfs.RootType {
+	return ""
+}
+
+func (fs mapFS) Close() error { return nil }
+
+func filename(p string) string {
+	return strings.TrimPrefix(p, "/")
+}
+
+func (fs mapFS) Open(p string) (vfs.ReadSeekCloser, error) {
+	b, ok := fs[filename(p)]
+	if !ok {
+		return nil, os.ErrNotExist
+	}
+	return nopCloser{strings.NewReader(b)}, nil
+}
+
+func fileInfo(name, contents string) os.FileInfo {
+	return mapFI{name: pathpkg.Base(name), size: len(contents)}
+}
+
+func dirInfo(name string) os.FileInfo {
+	return mapFI{name: pathpkg.Base(name), dir: true}
+}
+
+func (fs mapFS) Lstat(p string) (os.FileInfo, error) {
+	b, ok := fs[filename(p)]
+	if ok {
+		return fileInfo(p, b), nil
+	}
+	ents, _ := fs.ReadDir(p)
+	if len(ents) > 0 {
+		return dirInfo(p), nil
+	}
+	return nil, os.ErrNotExist
+}
+
+func (fs mapFS) Stat(p string) (os.FileInfo, error) {
+	return fs.Lstat(p)
+}
+
+// slashdir returns path.Dir(p), but special-cases paths not beginning
+// with a slash to be in the root.
+func slashdir(p string) string {
+	d := pathpkg.Dir(p)
+	if d == "." {
+		return "/"
+	}
+	if strings.HasPrefix(p, "/") {
+		return d
+	}
+	return "/" + d
+}
+
+func (fs mapFS) ReadDir(p string) ([]os.FileInfo, error) {
+	p = pathpkg.Clean(p)
+	var ents []string
+	fim := make(map[string]os.FileInfo) // base -> fi
+	for fn, b := range fs {
+		dir := slashdir(fn)
+		isFile := true
+		var lastBase string
+		for {
+			if dir == p {
+				base := lastBase
+				if isFile {
+					base = pathpkg.Base(fn)
+				}
+				if fim[base] == nil {
+					var fi os.FileInfo
+					if isFile {
+						fi = fileInfo(fn, b)
+					} else {
+						fi = dirInfo(base)
+					}
+					ents = append(ents, base)
+					fim[base] = fi
+				}
+			}
+			if dir == "/" {
+				break
+			} else {
+				isFile = false
+				lastBase = pathpkg.Base(dir)
+				dir = pathpkg.Dir(dir)
+			}
+		}
+	}
+	if len(ents) == 0 {
+		return nil, os.ErrNotExist
+	}
+
+	sort.Strings(ents)
+	var list []os.FileInfo
+	for _, dir := range ents {
+		list = append(list, fim[dir])
+	}
+	return list, nil
+}
+
+// mapFI is the map-based implementation of FileInfo.
+type mapFI struct {
+	name string
+	size int
+	dir  bool
+}
+
+func (fi mapFI) IsDir() bool        { return fi.dir }
+func (fi mapFI) ModTime() time.Time { return time.Time{} }
+func (fi mapFI) Mode() os.FileMode {
+	if fi.IsDir() {
+		return 0755 | os.ModeDir
+	}
+	return 0444
+}
+func (fi mapFI) Name() string { return pathpkg.Base(fi.name) }
+func (fi mapFI) Size() int64  { return int64(fi.size) }
+func (fi mapFI) Sys() any     { return nil }
+
+type nopCloser struct {
+	io.ReadSeeker
+}
+
+func (nc nopCloser) Close() error { return nil }
diff --git a/godoc/vfs/mapfs/mapfs_test.go b/vfs/mapfs/mapfs_test.go
similarity index 100%
rename from godoc/vfs/mapfs/mapfs_test.go
rename to vfs/mapfs/mapfs_test.go
diff --git a/vfs/namespace.go b/vfs/namespace.go
new file mode 100644
index 00000000000..2566051a293
--- /dev/null
+++ b/vfs/namespace.go
@@ -0,0 +1,387 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package vfs
+
+import (
+	"fmt"
+	"io"
+	"os"
+	pathpkg "path"
+	"sort"
+	"strings"
+	"time"
+)
+
+// Setting debugNS = true will enable debugging prints about
+// name space translations.
+const debugNS = false
+
+// A NameSpace is a file system made up of other file systems
+// mounted at specific locations in the name space.
+//
+// The representation is a map from mount point locations
+// to the list of file systems mounted at that location.  A traditional
+// Unix mount table would use a single file system per mount point,
+// but we want to be able to mount multiple file systems on a single
+// mount point and have the system behave as if the union of those
+// file systems were present at the mount point.
+// For example, if the OS file system has a Go installation in
+// c:\Go and additional Go path trees in d:\Work1 and d:\Work2, then
+// this name space creates the view we want for the godoc server:
+//
+//	NameSpace{
+//		"/": {
+//			{old: "/", fs: OS(`c:\Go`), new: "/"},
+//		},
+//		"/src/pkg": {
+//			{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
+//			{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
+//			{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
+//		},
+//	}
+//
+// This is created by executing:
+//
+//	ns := NameSpace{}
+//	ns.Bind("/", OS(`c:\Go`), "/", BindReplace)
+//	ns.Bind("/src/pkg", OS(`d:\Work1`), "/src", BindAfter)
+//	ns.Bind("/src/pkg", OS(`d:\Work2`), "/src", BindAfter)
+//
+// A particular mount point entry is a triple (old, fs, new), meaning that to
+// operate on a path beginning with old, replace that prefix (old) with new
+// and then pass that path to the FileSystem implementation fs.
+//
+// If you do not explicitly mount a FileSystem at the root mountpoint "/" of the
+// NameSpace like above, Stat("/") will return a "not found" error which could
+// break typical directory traversal routines. In such cases, use NewNameSpace()
+// to get a NameSpace pre-initialized with an emulated empty directory at root.
+//
+// Given this name space, a ReadDir of /src/pkg/code will check each prefix
+// of the path for a mount point (first /src/pkg/code, then /src/pkg, then /src,
+// then /), stopping when it finds one.  For the above example, /src/pkg/code
+// will find the mount point at /src/pkg:
+//
+//	{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
+//	{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
+//	{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
+//
+// ReadDir will when execute these three calls and merge the results:
+//
+//	OS(`c:\Go`).ReadDir("/src/pkg/code")
+//	OS(`d:\Work1').ReadDir("/src/code")
+//	OS(`d:\Work2').ReadDir("/src/code")
+//
+// Note that the "/src/pkg" in "/src/pkg/code" has been replaced by
+// just "/src" in the final two calls.
+//
+// OS is itself an implementation of a file system: it implements
+// OS(`c:\Go`).ReadDir("/src/pkg/code") as ioutil.ReadDir(`c:\Go\src\pkg\code`).
+//
+// Because the new path is evaluated by fs (here OS(root)), another way
+// to read the mount table is to mentally combine fs+new, so that this table:
+//
+//	{old: "/src/pkg", fs: OS(`c:\Go`), new: "/src/pkg"},
+//	{old: "/src/pkg", fs: OS(`d:\Work1`), new: "/src"},
+//	{old: "/src/pkg", fs: OS(`d:\Work2`), new: "/src"},
+//
+// reads as:
+//
+//	"/src/pkg" -> c:\Go\src\pkg
+//	"/src/pkg" -> d:\Work1\src
+//	"/src/pkg" -> d:\Work2\src
+//
+// An invariant (a redundancy) of the name space representation is that
+// ns[mtpt][i].old is always equal to mtpt (in the example, ns["/src/pkg"]'s
+// mount table entries always have old == "/src/pkg").  The 'old' field is
+// useful to callers, because they receive just a []mountedFS and not any
+// other indication of which mount point was found.
+type NameSpace map[string][]mountedFS
+
+// A mountedFS handles requests for path by replacing
+// a prefix 'old' with 'new' and then calling the fs methods.
+type mountedFS struct {
+	old string
+	fs  FileSystem
+	new string
+}
+
+// hasPathPrefix reports whether x == y or x == y + "/" + more.
+func hasPathPrefix(x, y string) bool {
+	return x == y || strings.HasPrefix(x, y) && (strings.HasSuffix(y, "/") || strings.HasPrefix(x[len(y):], "/"))
+}
+
+// translate translates path for use in m, replacing old with new.
+//
+// mountedFS{"/src/pkg", fs, "/src"}.translate("/src/pkg/code") == "/src/code".
+func (m mountedFS) translate(path string) string {
+	path = pathpkg.Clean("/" + path)
+	if !hasPathPrefix(path, m.old) {
+		panic("translate " + path + " but old=" + m.old)
+	}
+	return pathpkg.Join(m.new, path[len(m.old):])
+}
+
+func (NameSpace) String() string {
+	return "ns"
+}
+
+// Fprint writes a text representation of the name space to w.
+func (ns NameSpace) Fprint(w io.Writer) {
+	fmt.Fprint(w, "name space {\n")
+	var all []string
+	for mtpt := range ns {
+		all = append(all, mtpt)
+	}
+	sort.Strings(all)
+	for _, mtpt := range all {
+		fmt.Fprintf(w, "\t%s:\n", mtpt)
+		for _, m := range ns[mtpt] {
+			fmt.Fprintf(w, "\t\t%s %s\n", m.fs, m.new)
+		}
+	}
+	fmt.Fprint(w, "}\n")
+}
+
+// clean returns a cleaned, rooted path for evaluation.
+// It canonicalizes the path so that we can use string operations
+// to analyze it.
+func (NameSpace) clean(path string) string {
+	return pathpkg.Clean("/" + path)
+}
+
+type BindMode int
+
+const (
+	BindReplace BindMode = iota
+	BindBefore
+	BindAfter
+)
+
+// Bind causes references to old to redirect to the path new in newfs.
+// If mode is BindReplace, old redirections are discarded.
+// If mode is BindBefore, this redirection takes priority over existing ones,
+// but earlier ones are still consulted for paths that do not exist in newfs.
+// If mode is BindAfter, this redirection happens only after existing ones
+// have been tried and failed.
+func (ns NameSpace) Bind(old string, newfs FileSystem, new string, mode BindMode) {
+	old = ns.clean(old)
+	new = ns.clean(new)
+	m := mountedFS{old, newfs, new}
+	var mtpt []mountedFS
+	switch mode {
+	case BindReplace:
+		mtpt = append(mtpt, m)
+	case BindAfter:
+		mtpt = append(mtpt, ns.resolve(old)...)
+		mtpt = append(mtpt, m)
+	case BindBefore:
+		mtpt = append(mtpt, m)
+		mtpt = append(mtpt, ns.resolve(old)...)
+	}
+
+	// Extend m.old, m.new in inherited mount point entries.
+	for i := range mtpt {
+		m := &mtpt[i]
+		if m.old != old {
+			if !hasPathPrefix(old, m.old) {
+				// This should not happen.  If it does, panic so
+				// that we can see the call trace that led to it.
+				panic(fmt.Sprintf("invalid Bind: old=%q m={%q, %s, %q}", old, m.old, m.fs.String(), m.new))
+			}
+			suffix := old[len(m.old):]
+			m.old = pathpkg.Join(m.old, suffix)
+			m.new = pathpkg.Join(m.new, suffix)
+		}
+	}
+
+	ns[old] = mtpt
+}
+
+// resolve resolves a path to the list of mountedFS to use for path.
+func (ns NameSpace) resolve(path string) []mountedFS {
+	path = ns.clean(path)
+	for {
+		if m := ns[path]; m != nil {
+			if debugNS {
+				fmt.Printf("resolve %s: %v\n", path, m)
+			}
+			return m
+		}
+		if path == "/" {
+			break
+		}
+		path = pathpkg.Dir(path)
+	}
+	return nil
+}
+
+// Open implements the FileSystem Open method.
+func (ns NameSpace) Open(path string) (ReadSeekCloser, error) {
+	var err error
+	for _, m := range ns.resolve(path) {
+		if debugNS {
+			fmt.Printf("tx %s: %v\n", path, m.translate(path))
+		}
+		tp := m.translate(path)
+		r, err1 := m.fs.Open(tp)
+		if err1 == nil {
+			return r, nil
+		}
+		// IsNotExist errors in overlay FSes can mask real errors in
+		// the underlying FS, so ignore them if there is another error.
+		if err == nil || os.IsNotExist(err) {
+			err = err1
+		}
+	}
+	if err == nil {
+		err = &os.PathError{Op: "open", Path: path, Err: os.ErrNotExist}
+	}
+	return nil, err
+}
+
+// stat implements the FileSystem Stat and Lstat methods.
+func (ns NameSpace) stat(path string, f func(FileSystem, string) (os.FileInfo, error)) (os.FileInfo, error) {
+	var err error
+	for _, m := range ns.resolve(path) {
+		fi, err1 := f(m.fs, m.translate(path))
+		if err1 == nil {
+			return fi, nil
+		}
+		if err == nil {
+			err = err1
+		}
+	}
+	if err == nil {
+		err = &os.PathError{Op: "stat", Path: path, Err: os.ErrNotExist}
+	}
+	return nil, err
+}
+
+func (ns NameSpace) Stat(path string) (os.FileInfo, error) {
+	return ns.stat(path, FileSystem.Stat)
+}
+
+func (ns NameSpace) Lstat(path string) (os.FileInfo, error) {
+	return ns.stat(path, FileSystem.Lstat)
+}
+
+// dirInfo is a trivial implementation of os.FileInfo for a directory.
+type dirInfo string
+
+func (d dirInfo) Name() string       { return string(d) }
+func (d dirInfo) Size() int64        { return 0 }
+func (d dirInfo) Mode() os.FileMode  { return os.ModeDir | 0555 }
+func (d dirInfo) ModTime() time.Time { return startTime }
+func (d dirInfo) IsDir() bool        { return true }
+func (d dirInfo) Sys() any           { return nil }
+
+var startTime = time.Now()
+
+// ReadDir implements the FileSystem ReadDir method.  It's where most of the magic is.
+// (The rest is in resolve.)
+//
+// Logically, ReadDir must return the union of all the directories that are named
+// by path.  In order to avoid misinterpreting Go packages, of all the directories
+// that contain Go source code, we only include the files from the first,
+// but we include subdirectories from all.
+//
+// ReadDir must also return directory entries needed to reach mount points.
+// If the name space looks like the example in the type NameSpace comment,
+// but c:\Go does not have a src/pkg subdirectory, we still want to be able
+// to find that subdirectory, because we've mounted d:\Work1 and d:\Work2
+// there.  So if we don't see "src" in the directory listing for c:\Go, we add an
+// entry for it before returning.
+func (ns NameSpace) ReadDir(path string) ([]os.FileInfo, error) {
+	path = ns.clean(path)
+
+	// List matching directories and determine whether any of them contain
+	// Go files.
+	var (
+		dirs       [][]os.FileInfo
+		goDirIndex = -1
+		readDirErr error
+	)
+
+	for _, m := range ns.resolve(path) {
+		dir, err := m.fs.ReadDir(m.translate(path))
+		if err != nil {
+			if readDirErr == nil {
+				readDirErr = err
+			}
+			continue
+		}
+
+		dirs = append(dirs, dir)
+
+		if goDirIndex < 0 {
+			for _, f := range dir {
+				if !f.IsDir() && strings.HasSuffix(f.Name(), ".go") {
+					goDirIndex = len(dirs) - 1
+					break
+				}
+			}
+		}
+	}
+
+	// Build a list of files and subdirectories. If a directory contains Go files,
+	// only include files from that directory. Otherwise, include files from
+	// all directories. Include subdirectories from all directories regardless
+	// of whether Go files are present.
+	haveName := make(map[string]bool)
+	var all []os.FileInfo
+	for i, dir := range dirs {
+		for _, f := range dir {
+			name := f.Name()
+			if !haveName[name] && (f.IsDir() || goDirIndex < 0 || goDirIndex == i) {
+				all = append(all, f)
+				haveName[name] = true
+			}
+		}
+	}
+
+	// Add any missing directories needed to reach mount points.
+	for old := range ns {
+		if hasPathPrefix(old, path) && old != path {
+			// Find next element after path in old.
+			elem := old[len(path):]
+			elem = strings.TrimPrefix(elem, "/")
+			if i := strings.Index(elem, "/"); i >= 0 {
+				elem = elem[:i]
+			}
+			if !haveName[elem] {
+				haveName[elem] = true
+				all = append(all, dirInfo(elem))
+			}
+		}
+	}
+
+	if len(all) == 0 {
+		return nil, readDirErr
+	}
+
+	sort.Sort(byName(all))
+	return all, nil
+}
+
+// RootType returns the RootType for the given path in the namespace.
+func (ns NameSpace) RootType(path string) RootType {
+	// We resolve the given path to a list of mountedFS and then return
+	// the root type for the filesystem which contains the path.
+	for _, m := range ns.resolve(path) {
+		_, err := m.fs.ReadDir(m.translate(path))
+		// Found a match, return the filesystem's root type
+		if err == nil {
+			return m.fs.RootType(path)
+		}
+	}
+	return ""
+}
+
+// byName implements sort.Interface.
+type byName []os.FileInfo
+
+func (f byName) Len() int           { return len(f) }
+func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }
+func (f byName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
diff --git a/godoc/vfs/namespace_test.go b/vfs/namespace_test.go
similarity index 97%
rename from godoc/vfs/namespace_test.go
rename to vfs/namespace_test.go
index edf3bc7508a..cc36fbdb30c 100644
--- a/godoc/vfs/namespace_test.go
+++ b/vfs/namespace_test.go
@@ -10,8 +10,8 @@ import (
 	"testing"
 	"time"
 
-	"golang.org/x/tools/godoc/vfs"
-	"golang.org/x/tools/godoc/vfs/mapfs"
+	"golang.org/x/tools/vfs"
+	"golang.org/x/tools/vfs/mapfs"
 )
 
 func TestNewNameSpace(t *testing.T) {
diff --git a/vfs/os.go b/vfs/os.go
new file mode 100644
index 00000000000..35d050946e6
--- /dev/null
+++ b/vfs/os.go
@@ -0,0 +1,105 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package vfs
+
+import (
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"os"
+	pathpkg "path"
+	"path/filepath"
+	"runtime"
+)
+
+// We expose a new variable because otherwise we need to copy the findGOROOT logic again
+// from cmd/godoc which is already copied twice from the standard library.
+
+// GOROOT is the GOROOT path under which the godoc binary is running.
+// It is needed to check whether a filesystem root is under GOROOT or not.
+// This is set from cmd/godoc/main.go.
+var GOROOT = runtime.GOROOT()
+
+// OS returns an implementation of FileSystem reading from the
+// tree rooted at root.  Recording a root is convenient everywhere
+// but necessary on Windows, because the slash-separated path
+// passed to Open has no way to specify a drive letter.  Using a root
+// lets code refer to OS(`c:\`), OS(`d:\`) and so on.
+func OS(root string) FileSystem {
+	var t RootType
+	switch {
+	case root == GOROOT:
+		t = RootTypeGoRoot
+	case isGoPath(root):
+		t = RootTypeGoPath
+	}
+	return osFS{rootPath: root, rootType: t}
+}
+
+type osFS struct {
+	rootPath string
+	rootType RootType
+}
+
+func isGoPath(path string) bool {
+	for _, bp := range filepath.SplitList(build.Default.GOPATH) {
+		for _, gp := range filepath.SplitList(path) {
+			if bp == gp {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (root osFS) String() string { return "os(" + root.rootPath + ")" }
+
+// RootType returns the root type for the filesystem.
+//
+// Note that we ignore the path argument because roottype is a property of
+// this filesystem. But for other filesystems, the roottype might need to be
+// dynamically deduced at call time.
+func (root osFS) RootType(path string) RootType {
+	return root.rootType
+}
+
+func (root osFS) resolve(path string) string {
+	// Clean the path so that it cannot possibly begin with ../.
+	// If it did, the result of filepath.Join would be outside the
+	// tree rooted at root.  We probably won't ever see a path
+	// with .. in it, but be safe anyway.
+	path = pathpkg.Clean("/" + path)
+
+	return filepath.Join(root.rootPath, path)
+}
+
+func (root osFS) Open(path string) (ReadSeekCloser, error) {
+	f, err := os.Open(root.resolve(path))
+	if err != nil {
+		return nil, err
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+	if fi.IsDir() {
+		f.Close()
+		return nil, fmt.Errorf("Open: %s is a directory", path)
+	}
+	return f, nil
+}
+
+func (root osFS) Lstat(path string) (os.FileInfo, error) {
+	return os.Lstat(root.resolve(path))
+}
+
+func (root osFS) Stat(path string) (os.FileInfo, error) {
+	return os.Stat(root.resolve(path))
+}
+
+func (root osFS) ReadDir(path string) ([]os.FileInfo, error) {
+	return ioutil.ReadDir(root.resolve(path)) // is sorted
+}
diff --git a/godoc/vfs/os_test.go b/vfs/os_test.go
similarity index 95%
rename from godoc/vfs/os_test.go
rename to vfs/os_test.go
index 98631e0516a..6307628abd3 100644
--- a/godoc/vfs/os_test.go
+++ b/vfs/os_test.go
@@ -9,7 +9,7 @@ import (
 	"runtime"
 	"testing"
 
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 func TestRootType(t *testing.T) {
diff --git a/vfs/vfs.go b/vfs/vfs.go
new file mode 100644
index 00000000000..22f7ae6fa6f
--- /dev/null
+++ b/vfs/vfs.go
@@ -0,0 +1,57 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package vfs defines types for abstract file system access and provides an
+// implementation accessing the file system of the underlying OS.
+package vfs // import "golang.org/x/tools/vfs"
+
+import (
+	"io"
+	"os"
+)
+
+// RootType indicates the type of files contained within a directory.
+//
+// It is used to indicate whether a directory is the root
+// of a GOROOT, a GOPATH, or neither.
+// An empty string represents the case when a directory is neither.
+type RootType string
+
+const (
+	RootTypeGoRoot RootType = "GOROOT"
+	RootTypeGoPath RootType = "GOPATH"
+)
+
+// The FileSystem interface specifies the methods godoc is using
+// to access the file system for which it serves documentation.
+type FileSystem interface {
+	Opener
+	Lstat(path string) (os.FileInfo, error)
+	Stat(path string) (os.FileInfo, error)
+	ReadDir(path string) ([]os.FileInfo, error)
+	RootType(path string) RootType
+	String() string
+}
+
+// Opener is a minimal virtual filesystem that can only open regular files.
+type Opener interface {
+	Open(name string) (ReadSeekCloser, error)
+}
+
+// A ReadSeekCloser can Read, Seek, and Close.
+type ReadSeekCloser interface {
+	io.Reader
+	io.Seeker
+	io.Closer
+}
+
+// ReadFile reads the file named by path from fs and returns the contents.
+func ReadFile(fs Opener, path string) ([]byte, error) {
+	rc, err := fs.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	return io.ReadAll(rc)
+}
diff --git a/vfs/zipfs/zipfs.go b/vfs/zipfs/zipfs.go
new file mode 100644
index 00000000000..3d058c5d0da
--- /dev/null
+++ b/vfs/zipfs/zipfs.go
@@ -0,0 +1,291 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package zipfs file provides an implementation of the FileSystem
+// interface based on the contents of a .zip file.
+//
+// Assumptions:
+//
+//   - The file paths stored in the zip file must use a slash ('/') as path
+//     separator; and they must be relative (i.e., they must not start with
+//     a '/' - this is usually the case if the file was created w/o special
+//     options).
+//   - The zip file system treats the file paths found in the zip internally
+//     like absolute paths w/o a leading '/'; i.e., the paths are considered
+//     relative to the root of the file system.
+//   - All path arguments to file system methods must be absolute paths.
+package zipfs // import "golang.org/x/tools/vfs/zipfs"
+
+import (
+	"archive/zip"
+	"fmt"
+	"go/build"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"golang.org/x/tools/vfs"
+)
+
+// zipFI is the zip-file based implementation of FileInfo
+type zipFI struct {
+	name string    // directory-local name
+	file *zip.File // nil for a directory
+}
+
+func (fi zipFI) Name() string {
+	return fi.name
+}
+
+func (fi zipFI) Size() int64 {
+	if f := fi.file; f != nil {
+		return int64(f.UncompressedSize)
+	}
+	return 0 // directory
+}
+
+func (fi zipFI) ModTime() time.Time {
+	if f := fi.file; f != nil {
+		return f.ModTime()
+	}
+	return time.Time{} // directory has no modified time entry
+}
+
+func (fi zipFI) Mode() os.FileMode {
+	if fi.file == nil {
+		// Unix directories typically are executable, hence 555.
+		return os.ModeDir | 0555
+	}
+	return 0444
+}
+
+func (fi zipFI) IsDir() bool {
+	return fi.file == nil
+}
+
+func (fi zipFI) Sys() any {
+	return nil
+}
+
+// zipFS is the zip-file based implementation of FileSystem
+type zipFS struct {
+	*zip.ReadCloser
+	list zipList
+	name string
+}
+
+func (fs *zipFS) String() string {
+	return "zip(" + fs.name + ")"
+}
+
+func (fs *zipFS) RootType(abspath string) vfs.RootType {
+	var t vfs.RootType
+	switch {
+	case exists(path.Join(vfs.GOROOT, abspath)):
+		t = vfs.RootTypeGoRoot
+	case isGoPath(abspath):
+		t = vfs.RootTypeGoPath
+	}
+	return t
+}
+
+func isGoPath(abspath string) bool {
+	for _, p := range filepath.SplitList(build.Default.GOPATH) {
+		if exists(path.Join(p, abspath)) {
+			return true
+		}
+	}
+	return false
+}
+
+func exists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+func (fs *zipFS) Close() error {
+	fs.list = nil
+	return fs.ReadCloser.Close()
+}
+
+func zipPath(name string) (string, error) {
+	name = path.Clean(name)
+	if !path.IsAbs(name) {
+		return "", fmt.Errorf("stat: not an absolute path: %s", name)
+	}
+	return name[1:], nil // strip leading '/'
+}
+
+func isRoot(abspath string) bool {
+	return path.Clean(abspath) == "/"
+}
+
+func (fs *zipFS) stat(abspath string) (int, zipFI, error) {
+	if isRoot(abspath) {
+		return 0, zipFI{
+			name: "",
+			file: nil,
+		}, nil
+	}
+	zippath, err := zipPath(abspath)
+	if err != nil {
+		return 0, zipFI{}, err
+	}
+	i, exact := fs.list.lookup(zippath)
+	if i < 0 {
+		// zippath has leading '/' stripped - print it explicitly
+		return -1, zipFI{}, &os.PathError{Path: "/" + zippath, Err: os.ErrNotExist}
+	}
+	_, name := path.Split(zippath)
+	var file *zip.File
+	if exact {
+		file = fs.list[i] // exact match found - must be a file
+	}
+	return i, zipFI{name, file}, nil
+}
+
+func (fs *zipFS) Open(abspath string) (vfs.ReadSeekCloser, error) {
+	_, fi, err := fs.stat(abspath)
+	if err != nil {
+		return nil, err
+	}
+	if fi.IsDir() {
+		return nil, fmt.Errorf("Open: %s is a directory", abspath)
+	}
+	r, err := fi.file.Open()
+	if err != nil {
+		return nil, err
+	}
+	return &zipSeek{fi.file, r}, nil
+}
+
+type zipSeek struct {
+	file *zip.File
+	io.ReadCloser
+}
+
+func (f *zipSeek) Seek(offset int64, whence int) (int64, error) {
+	if whence == 0 && offset == 0 {
+		r, err := f.file.Open()
+		if err != nil {
+			return 0, err
+		}
+		f.Close()
+		f.ReadCloser = r
+		return 0, nil
+	}
+	return 0, fmt.Errorf("unsupported Seek in %s", f.file.Name)
+}
+
+func (fs *zipFS) Lstat(abspath string) (os.FileInfo, error) {
+	_, fi, err := fs.stat(abspath)
+	return fi, err
+}
+
+func (fs *zipFS) Stat(abspath string) (os.FileInfo, error) {
+	_, fi, err := fs.stat(abspath)
+	return fi, err
+}
+
+func (fs *zipFS) ReadDir(abspath string) ([]os.FileInfo, error) {
+	i, fi, err := fs.stat(abspath)
+	if err != nil {
+		return nil, err
+	}
+	if !fi.IsDir() {
+		return nil, fmt.Errorf("ReadDir: %s is not a directory", abspath)
+	}
+
+	var list []os.FileInfo
+
+	// make dirname the prefix that file names must start with to be considered
+	// in this directory. we must special case the root directory because, per
+	// the spec of this package, zip file entries MUST NOT start with /, so we
+	// should not append /, as we would in every other case.
+	var dirname string
+	if isRoot(abspath) {
+		dirname = ""
+	} else {
+		zippath, err := zipPath(abspath)
+		if err != nil {
+			return nil, err
+		}
+		dirname = zippath + "/"
+	}
+	prevname := ""
+	for _, e := range fs.list[i:] {
+		if !strings.HasPrefix(e.Name, dirname) {
+			break // not in the same directory anymore
+		}
+		name := e.Name[len(dirname):] // local name
+		file := e
+		if i := strings.IndexRune(name, '/'); i >= 0 {
+			// We infer directories from files in subdirectories.
+			// If we have x/y, return a directory entry for x.
+			name = name[0:i] // keep local directory name only
+			file = nil
+		}
+		// If we have x/y and x/z, don't return two directory entries for x.
+		// TODO(gri): It should be possible to do this more efficiently
+		// by determining the (fs.list) range of local directory entries
+		// (via two binary searches).
+		if name != prevname {
+			list = append(list, zipFI{name, file})
+			prevname = name
+		}
+	}
+
+	return list, nil
+}
+
+func New(rc *zip.ReadCloser, name string) vfs.FileSystem {
+	list := make(zipList, len(rc.File))
+	copy(list, rc.File) // sort a copy of rc.File
+	sort.Sort(list)
+	return &zipFS{rc, list, name}
+}
+
+type zipList []*zip.File
+
+// zipList implements sort.Interface
+func (z zipList) Len() int           { return len(z) }
+func (z zipList) Less(i, j int) bool { return z[i].Name < z[j].Name }
+func (z zipList) Swap(i, j int)      { z[i], z[j] = z[j], z[i] }
+
+// lookup returns the smallest index of an entry with an exact match
+// for name, or an inexact match starting with name/. If there is no
+// such entry, the result is -1, false.
+func (z zipList) lookup(name string) (index int, exact bool) {
+	// look for exact match first (name comes before name/ in z)
+	i := sort.Search(len(z), func(i int) bool {
+		return name <= z[i].Name
+	})
+	if i >= len(z) {
+		return -1, false
+	}
+	// 0 <= i < len(z)
+	if z[i].Name == name {
+		return i, true
+	}
+
+	// look for inexact match (must be in z[i:], if present)
+	z = z[i:]
+	name += "/"
+	j := sort.Search(len(z), func(i int) bool {
+		return name <= z[i].Name
+	})
+	if j >= len(z) {
+		return -1, false
+	}
+	// 0 <= j < len(z)
+	if strings.HasPrefix(z[j].Name, name) {
+		return i + j, false
+	}
+
+	return -1, false
+}
diff --git a/godoc/vfs/zipfs/zipfs_test.go b/vfs/zipfs/zipfs_test.go
similarity index 99%
rename from godoc/vfs/zipfs/zipfs_test.go
rename to vfs/zipfs/zipfs_test.go
index b6f2431b0b5..5e3760456b8 100644
--- a/godoc/vfs/zipfs/zipfs_test.go
+++ b/vfs/zipfs/zipfs_test.go
@@ -12,7 +12,7 @@ import (
 	"reflect"
 	"testing"
 
-	"golang.org/x/tools/godoc/vfs"
+	"golang.org/x/tools/vfs"
 )
 
 var (