diff --git a/cmd/golangorg/godoc_test.go b/cmd/golangorg/godoc_test.go
index 0900aba..a9d5b8b 100644
--- a/cmd/golangorg/godoc_test.go
+++ b/cmd/golangorg/godoc_test.go
@@ -176,8 +176,11 @@
 		releaseTag  string // optional release tag that must be in go/build.ReleaseTags
 	}{
 		{
-			path:     "/",
-			contains: []string{"Go is an open source programming language"},
+			path: "/",
+			contains: []string{
+				"Go is an open source programming language",
+				"Binary distributions available for",
+			},
 		},
 		{
 			path:     "/conduct",
diff --git a/cmd/golangorg/main.go b/cmd/golangorg/main.go
index 4f9e280..be8205c 100644
--- a/cmd/golangorg/main.go
+++ b/cmd/golangorg/main.go
@@ -78,12 +78,7 @@
 	}
 	fsys = unionFS{content, os.DirFS(*goroot)}
 
-	corpus := godoc.NewCorpus(fsys)
-	// Initialize the version info before readTemplates, which saves
-	// the map value in a method value.
-	corpus.InitVersionInfo()
-
-	pres = godoc.NewPresentation(corpus)
+	pres = godoc.NewPresentation(fsys)
 	pres.GoogleCN = googleCN
 
 	readTemplates(pres)
diff --git a/cmd/golangorg/release_test.go b/cmd/golangorg/release_test.go
index 98c54c5..9dbbaf5 100644
--- a/cmd/golangorg/release_test.go
+++ b/cmd/golangorg/release_test.go
@@ -27,7 +27,7 @@
 	origFS, origPres := fsys, pres
 	defer func() { fsys, pres = origFS, origPres }()
 	fsys = website.Content
-	pres = godoc.NewPresentation(godoc.NewCorpus(fsys))
+	pres = godoc.NewPresentation(fsys)
 	readTemplates(pres)
 	mux := registerHandlers(pres)
 
diff --git a/internal/api/api.go b/internal/api/api.go
index 59e6740..a9669f2 100644
--- a/internal/api/api.go
+++ b/internal/api/api.go
@@ -12,8 +12,8 @@
 
 import (
 	"bufio"
-	"go/build"
-	"os"
+	"io/fs"
+	"path"
 	"path/filepath"
 	"sort"
 	"strconv"
@@ -64,15 +64,10 @@
 	return ""
 }
 
-func Load() (DB, error) {
-	var apiGlob string
-	if os.Getenv("GOROOT") == "" {
-		apiGlob = filepath.Join(build.Default.GOROOT, "api", "go*.txt")
-	} else {
-		apiGlob = filepath.Join(os.Getenv("GOROOT"), "api", "go*.txt")
-	}
-
-	files, err := filepath.Glob(apiGlob)
+// Load loads a database from fsys's api/go*.txt files.
+// Typically, fsys should be the root of a Go repository (a $GOROOT).
+func Load(fsys fs.FS) (DB, error) {
+	files, err := fs.Glob(fsys, "api/go*.txt")
 	if err != nil {
 		return nil, err
 	}
@@ -87,7 +82,7 @@
 	// when the symbol was added. See golang.org/issue/44081.
 	//
 	ver := func(name string) int {
-		base := filepath.Base(name)
+		base := path.Base(name)
 		ver := strings.TrimPrefix(strings.TrimSuffix(base, ".txt"), "go1.")
 		if ver == "go1" {
 			return 0
@@ -98,7 +93,7 @@
 	sort.Slice(files, func(i, j int) bool { return ver(files[i]) > ver(files[j]) })
 	vp := new(parser)
 	for _, f := range files {
-		if err := vp.parseFile(f); err != nil {
+		if err := vp.parseFile(fsys, f); err != nil {
 			return nil, err
 		}
 	}
@@ -116,8 +111,8 @@
 // vp.res to VERSION, overwriting any previous value.
 // As a special case, if goVERSION is "go1", it deletes
 // from the map instead.
-func (vp *parser) parseFile(name string) error {
-	f, err := os.Open(name)
+func (vp *parser) parseFile(fsys fs.FS, name string) error {
+	f, err := fsys.Open(name)
 	if err != nil {
 		return err
 	}
diff --git a/internal/api/api_test.go b/internal/api/api_test.go
index bfddc5d..64c8800 100644
--- a/internal/api/api_test.go
+++ b/internal/api/api_test.go
@@ -9,6 +9,8 @@
 
 import (
 	"go/build"
+	"os"
+	"runtime"
 	"testing"
 )
 
@@ -91,7 +93,7 @@
 }
 
 func TestAPIVersion(t *testing.T) {
-	av, err := Load()
+	av, err := Load(os.DirFS(runtime.GOROOT()))
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/internal/godoc/astfuncs.go b/internal/godoc/astfuncs.go
index 22e1bdc..f6cafd4 100644
--- a/internal/godoc/astfuncs.go
+++ b/internal/godoc/astfuncs.go
@@ -67,7 +67,6 @@
 	var pkgName, structName string
 	var apiInfo api.PkgDB
 	if gd, ok := x.(*ast.GenDecl); ok && pageInfo != nil && pageInfo.PDoc != nil &&
-		p.Corpus != nil &&
 		gd.Tok == token.TYPE && len(gd.Specs) != 0 {
 		pkgName = pageInfo.PDoc.ImportPath
 		if ts, ok := gd.Specs[0].(*ast.TypeSpec); ok {
@@ -75,7 +74,7 @@
 				structName = ts.Name.Name
 			}
 		}
-		apiInfo = p.Corpus.pkgAPIInfo[pkgName]
+		apiInfo = p.api[pkgName]
 	}
 
 	var out = w
diff --git a/internal/godoc/corpus.go b/internal/godoc/corpus.go
deleted file mode 100644
index 2bdb113..0000000
--- a/internal/godoc/corpus.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-//go:build go1.16
-// +build go1.16
-
-package godoc
-
-import (
-	"io/fs"
-
-	"golang.org/x/website/internal/api"
-)
-
-// A Corpus holds all the state related to serving and indexing a
-// collection of Go code.
-//
-// Construct a new Corpus with NewCorpus, then modify options,
-// then call its Init method.
-type Corpus struct {
-	fs fs.FS
-
-	// pkgAPIInfo contains the information about which package API
-	// features were added in which version of Go.
-	pkgAPIInfo api.DB
-}
-
-// NewCorpus returns a new Corpus from a filesystem.
-// The returned corpus has all indexing enabled and MaxResults set to 1000.
-// Change or set any options on Corpus before calling the Corpus.Init method.
-func NewCorpus(fsys fs.FS) *Corpus {
-	c := &Corpus{
-		fs: fsys,
-	}
-	return c
-}
diff --git a/internal/godoc/godoc.go b/internal/godoc/godoc.go
index 5b8ca55..ff0a202 100644
--- a/internal/godoc/godoc.go
+++ b/internal/godoc/godoc.go
@@ -38,8 +38,8 @@
 }
 
 func (p *Presentation) initFuncMap() {
-	if p.Corpus == nil {
-		panic("nil Presentation.Corpus")
+	if p.fs == nil {
+		panic("nil Presentation.fs")
 	}
 	p.templateFuncs = template.FuncMap{
 		"code":     p.code,
@@ -48,7 +48,7 @@
 	p.funcMap = template.FuncMap{
 		// various helpers
 		"filename": filenameFunc,
-		"since":    p.Corpus.pkgAPIInfo.Func,
+		"since":    p.api.Func,
 
 		// formatting of AST nodes
 		"node":         p.nodeFunc,
diff --git a/internal/godoc/meta.go b/internal/godoc/meta.go
index b6b7791..0c5809e 100644
--- a/internal/godoc/meta.go
+++ b/internal/godoc/meta.go
@@ -12,6 +12,7 @@
 	"encoding/json"
 	"io/fs"
 	"log"
+	"path"
 	"strings"
 )
 
@@ -21,28 +22,28 @@
 	jsonEnd   = []byte("}-->")
 )
 
-type Metadata struct {
-	// Copied from document metadata
+type file struct {
+	// Copied from document metadata directives
 	Title    string
 	Subtitle string
 	Template bool
 
 	Path     string // URL path
 	FilePath string // filesystem path relative to goroot
+	Body     []byte // content after metadata
 }
 
-type MetaJSON struct {
+type metaJSON struct {
 	Title    string
 	Subtitle string
 	Template bool
 	Redirect string // if set, redirect to other URL
 }
 
-// extractMetadata extracts the MetaJSON from a byte slice.
-// It returns the Metadata value and the remaining data.
-// If no metadata is present the original byte slice is returned.
-//
-func extractMetadata(b []byte) (meta MetaJSON, tail []byte, err error) {
+// extractMetadata extracts the metaJSON from a byte slice.
+// It returns the metadata and the remaining text.
+// If no metadata is present, it returns an empty metaJSON and the original text.
+func extractMetadata(b []byte) (meta metaJSON, tail []byte, err error) {
 	tail = b
 	if !bytes.HasPrefix(b, jsonStart) {
 		return
@@ -59,66 +60,77 @@
 	return
 }
 
-// MetadataFor returns the *Metadata for a given absolute path
-// or nil if none exists.
-func (c *Corpus) MetadataFor(path string) *Metadata {
-	// Strip any .html or .md; it all names the same page.
+var join = path.Join
+
+// open returns the file for a given absolute path or nil if none exists.
+func open(fsys fs.FS, path string) *file {
+	// Strip trailing .html or .md or /; it all names the same page.
 	if strings.HasSuffix(path, ".html") {
 		path = strings.TrimSuffix(path, ".html")
 	} else if strings.HasSuffix(path, ".md") {
 		path = strings.TrimSuffix(path, ".md")
+	} else if path != "/" && strings.HasSuffix(path, "/") {
+		path = strings.TrimSuffix(path, "/")
 	}
 
-	file := path + ".html"
-	b, err := fs.ReadFile(c.fs, toFS(file))
-	if err != nil {
-		file = path + ".md"
-		b, err = fs.ReadFile(c.fs, toFS(file))
-	}
-	if err != nil {
-		// Special case for memory model and spec, which live
-		// in the main Go repo's doc directory and therefore have not
-		// been renamed to their serving paths.
-		// We wait until the ReadFiles above have failed so that the
-		// code works if these are ever moved to /ref/spec and /ref/mem.
-		switch path {
-		case "/ref/spec":
-			if m := c.MetadataFor("/doc/go_spec"); m != nil {
-				return m
-			}
-		case "/ref/mem":
-			if m := c.MetadataFor("/doc/go_mem"); m != nil {
-				return m
-			}
+	files := []string{path + ".html", path + ".md", join(path, "index.html"), join(path, "index.md")}
+	var filePath string
+	var b []byte
+	var err error
+	for _, filePath = range files {
+		b, err = fs.ReadFile(fsys, toFS(filePath))
+		if err == nil {
+			break
 		}
-		return nil
 	}
 
-	js, _, err := extractMetadata(b)
+	// Special case for memory model and spec, which live
+	// in the main Go repo's doc directory and therefore have not
+	// been renamed to their serving paths.
+	// We wait until the ReadFiles above have failed so that the
+	// code works if these are ever moved to /ref/spec and /ref/mem.
+	if err != nil && path == "/ref/spec" {
+		return open(fsys, "/doc/go_spec")
+	}
+	if err != nil && path == "/ref/mem" {
+		return open(fsys, "/doc/go_mem")
+	}
+
 	if err != nil {
-		log.Printf("MetadataFor %s: %v", path, err)
 		return nil
 	}
 
-	meta := &Metadata{
-		Title:    js.Title,
-		Subtitle: js.Subtitle,
-		Template: js.Template,
-		Path:     path,
-		FilePath: file,
-	}
-	if js.Redirect != "" {
-		// Allow (placeholder) documents to declare a redirect.
-		meta.Path = js.Redirect
-	}
-
 	// Special case for memory model and spec, continued.
 	switch path {
 	case "/doc/go_spec":
-		meta.Path = "/ref/spec"
+		path = "/ref/spec"
 	case "/doc/go_mem":
-		meta.Path = "/ref/mem"
+		path = "/ref/mem"
 	}
 
-	return meta
+	// If we read an index.md or index.html, the canonical path is without the index.md/index.html suffix.
+	if strings.HasSuffix(filePath, "/index.md") || strings.HasSuffix(filePath, "/index.html") {
+		path = filePath[:strings.LastIndex(filePath, "/")+1]
+	}
+
+	js, body, err := extractMetadata(b)
+	if err != nil {
+		log.Printf("extractMetadata %s: %v", path, err)
+		return nil
+	}
+
+	f := &file{
+		Title:    js.Title,
+		Subtitle: js.Subtitle,
+		Template: js.Template,
+		Path:     path,
+		FilePath: filePath,
+		Body:     body,
+	}
+	if js.Redirect != "" {
+		// Allow (placeholder) documents to declare a redirect.
+		f.Path = js.Redirect
+	}
+
+	return f
 }
diff --git a/internal/godoc/pres.go b/internal/godoc/pres.go
index 4aaa41b..5ce3c22 100644
--- a/internal/godoc/pres.go
+++ b/internal/godoc/pres.go
@@ -8,16 +8,20 @@
 package godoc
 
 import (
+	"io/fs"
+	"log"
 	"net/http"
 	"sync"
 	"text/template"
 
+	"golang.org/x/website/internal/api"
 	"golang.org/x/website/internal/pkgdoc"
 )
 
-// Presentation generates output from a corpus.
+// Presentation generates output from a file system.
 type Presentation struct {
-	Corpus *Corpus
+	fs  fs.FS
+	api api.DB
 
 	mux        *http.ServeMux
 	fileServer http.Handler
@@ -42,19 +46,21 @@
 	templateFuncs   template.FuncMap
 }
 
-// NewPresentation returns a new Presentation from a corpus.
-func NewPresentation(c *Corpus) *Presentation {
-	if c == nil {
-		panic("nil Corpus")
+// NewPresentation returns a new Presentation from a file system.
+func NewPresentation(fsys fs.FS) *Presentation {
+	apiDB, err := api.Load(fsys)
+	if err != nil {
+		log.Fatalf("NewPresentation loading api: %v", err)
 	}
 	p := &Presentation{
-		Corpus:     c,
+		fs:         fsys,
+		api:        apiDB,
 		mux:        http.NewServeMux(),
-		fileServer: http.FileServer(http.FS(c.fs)),
+		fileServer: http.FileServer(http.FS(fsys)),
 	}
 	docs := &docServer{
 		p: p,
-		d: pkgdoc.NewDocs(c.fs),
+		d: pkgdoc.NewDocs(fsys),
 	}
 	p.mux.Handle("/cmd/", docs)
 	p.mux.Handle("/pkg/", docs)
diff --git a/internal/godoc/server.go b/internal/godoc/server.go
index cdcd59c..4d3a740 100644
--- a/internal/godoc/server.go
+++ b/internal/godoc/server.go
@@ -203,8 +203,8 @@
 	return nil
 }
 
-func (p *Presentation) serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath, title string) {
-	src, err := fs.ReadFile(p.Corpus.fs, toFS(abspath))
+func (p *Presentation) serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
+	src, err := fs.ReadFile(p.fs, toFS(abspath))
 	if err != nil {
 		log.Printf("ReadFile: %s", err)
 		p.ServeError(w, r, relpath, err)
@@ -230,6 +230,10 @@
 
 	fmt.Fprintf(&buf, `<p><a href="/%s?m=text">View as plain text</a></p>`, htmlpkg.EscapeString(relpath))
 
+	title := "Text file"
+	if strings.HasSuffix(relpath, ".go") {
+		title = "Source file"
+	}
 	p.ServePage(w, Page{
 		Title:    title,
 		SrcPath:  relpath,
@@ -244,7 +248,7 @@
 		return
 	}
 
-	list, err := fs.ReadDir(p.Corpus.fs, toFS(abspath))
+	list, err := fs.ReadDir(p.fs, toFS(abspath))
 	if err != nil {
 		p.ServeError(w, r, relpath, err)
 		return
@@ -267,15 +271,9 @@
 	})
 }
 
-func (p *Presentation) ServeHTMLDoc(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
-	// get HTML body contents
-	src, err := fs.ReadFile(p.Corpus.fs, toFS(abspath))
-	if err != nil {
-		log.Printf("ReadFile: %s", err)
-		p.ServeError(w, r, relpath, err)
-		return
-	}
-	isMarkdown := strings.HasSuffix(abspath, ".md")
+func (p *Presentation) serveHTML(w http.ResponseWriter, r *http.Request, f *file) {
+	src := f.Body
+	isMarkdown := strings.HasSuffix(f.FilePath, ".md")
 
 	// if it begins with "<!DOCTYPE " assume it is standalone
 	// html that doesn't need the template wrapping.
@@ -284,30 +282,24 @@
 		return
 	}
 
-	// if it begins with a JSON blob, read in the metadata.
-	meta, src, err := extractMetadata(src)
-	if err != nil {
-		log.Printf("decoding metadata %s: %v", relpath, err)
-	}
-
 	page := Page{
-		Title:    meta.Title,
-		Subtitle: meta.Subtitle,
+		Title:    f.Title,
+		Subtitle: f.Subtitle,
 		GoogleCN: p.googleCN(r),
 	}
 
 	// evaluate as template if indicated
-	if meta.Template {
+	if f.Template {
 		tmpl, err := template.New("main").Funcs(p.TemplateFuncs()).Parse(string(src))
 		if err != nil {
-			log.Printf("parsing template %s: %v", relpath, err)
-			p.ServeError(w, r, relpath, err)
+			log.Printf("parsing template %s: %v", f.Path, err)
+			p.ServeError(w, r, f.Path, err)
 			return
 		}
 		var buf bytes.Buffer
 		if err := tmpl.Execute(&buf, page); err != nil {
-			log.Printf("executing template %s: %v", relpath, err)
-			p.ServeError(w, r, relpath, err)
+			log.Printf("executing template %s: %v", f.Path, err)
+			p.ServeError(w, r, f.Path, err)
 			return
 		}
 		src = buf.Bytes()
@@ -318,15 +310,15 @@
 	if isMarkdown {
 		html, err := renderMarkdown(src)
 		if err != nil {
-			log.Printf("executing markdown %s: %v", relpath, err)
-			p.ServeError(w, r, relpath, err)
+			log.Printf("executing markdown %s: %v", f.Path, err)
+			p.ServeError(w, r, f.Path, err)
 			return
 		}
 		src = html
 	}
 
 	// if it's the language spec, add tags to EBNF productions
-	if strings.HasSuffix(abspath, "go_spec.html") {
+	if strings.HasSuffix(f.FilePath, "go_spec.html") {
 		var buf bytes.Buffer
 		spec.Linkify(&buf, src)
 		src = buf.Bytes()
@@ -350,36 +342,26 @@
 
 	// Check to see if we need to redirect or serve another file.
 	abspath := r.URL.Path
-	if m := p.Corpus.MetadataFor(abspath); m != nil {
-		if m.Path != abspath {
+	if f := open(p.fs, abspath); f != nil {
+		if f.Path != abspath {
 			// Redirect to canonical path.
-			http.Redirect(w, r, m.Path, http.StatusMovedPermanently)
+			http.Redirect(w, r, f.Path, http.StatusMovedPermanently)
 			return
 		}
 		// Serve from the actual filesystem path.
-		p.ServeHTMLDoc(w, r, m.FilePath, m.Path)
+		p.serveHTML(w, r, f)
 		return
 	}
 
 	relpath := abspath[1:] // strip leading slash
 
-	switch path.Ext(relpath) {
-	case ".html":
-		p.ServeHTMLDoc(w, r, abspath, relpath)
-		return
-
-	case ".go":
-		p.serveTextFile(w, r, abspath, relpath, "Source file")
-		return
-	}
-
-	dir, err := fs.Stat(p.Corpus.fs, toFS(abspath))
+	dir, err := fs.Stat(p.fs, toFS(abspath))
 	if err != nil {
 		// Check for spurious trailing slash.
 		if strings.HasSuffix(abspath, "/") {
 			trimmed := abspath[:len(abspath)-1]
-			if _, err := fs.Stat(p.Corpus.fs, toFS(trimmed)); err == nil ||
-				p.Corpus.MetadataFor(trimmed) != nil {
+			if _, err := fs.Stat(p.fs, toFS(trimmed)); err == nil ||
+				open(p.fs, trimmed) != nil {
 				http.Redirect(w, r, trimmed, http.StatusMovedPermanently)
 				return
 			}
@@ -393,20 +375,15 @@
 		if redirect(w, r) {
 			return
 		}
-		index := path.Join(fsPath, "index.html")
-		if isTextFile(p.Corpus.fs, index) || isTextFile(p.Corpus.fs, path.Join(fsPath, "index.md")) {
-			p.ServeHTMLDoc(w, r, index, index)
-			return
-		}
 		p.serveDirectory(w, r, abspath, relpath)
 		return
 	}
 
-	if isTextFile(p.Corpus.fs, fsPath) {
+	if isTextFile(p.fs, fsPath) {
 		if redirectFile(w, r) {
 			return
 		}
-		p.serveTextFile(w, r, abspath, relpath, "Text file")
+		p.serveTextFile(w, r, abspath, relpath)
 		return
 	}
 
diff --git a/internal/godoc/server_test.go b/internal/godoc/server_test.go
index 57d61e9..152e934 100644
--- a/internal/godoc/server_test.go
+++ b/internal/godoc/server_test.go
@@ -29,11 +29,11 @@
 }
 
 func TestRedirectAndMetadata(t *testing.T) {
-	c := NewCorpus(fstest.MapFS{
+	fsys := fstest.MapFS{
 		"doc/x/index.html": {Data: []byte("Hello, x.")},
-	})
+	}
 	p := &Presentation{
-		Corpus:    c,
+		fs:        fsys,
 		GodocHTML: template.Must(template.New("").Parse(`{{printf "%s" .Body}}`)),
 	}
 
@@ -54,10 +54,10 @@
 
 func TestMarkdown(t *testing.T) {
 	p := &Presentation{
-		Corpus: NewCorpus(fstest.MapFS{
+		fs: fstest.MapFS{
 			"doc/test.md":  {Data: []byte("**bold**")},
 			"doc/test2.md": {Data: []byte(`{{"*template*"}}`)},
-		}),
+		},
 		GodocHTML: template.Must(template.New("").Parse(`{{printf "%s" .Body}}`)),
 	}
 
diff --git a/internal/godoc/template.go b/internal/godoc/template.go
index 5baa140..138b71f 100644
--- a/internal/godoc/template.go
+++ b/internal/godoc/template.go
@@ -50,8 +50,8 @@
 
 // contents reads and returns the content of the named file
 // (from the virtual file system, so for example /doc refers to $GOROOT/doc).
-func (c *Corpus) contents(name string) string {
-	file, err := fs.ReadFile(c.fs, toFS(name))
+func (p *Presentation) contents(name string) string {
+	file, err := fs.ReadFile(p.fs, toFS(name))
 	if err != nil {
 		log.Panic(err)
 	}
@@ -81,7 +81,7 @@
 		}
 	}()
 
-	text := p.Corpus.contents(file)
+	text := p.contents(file)
 	var command string
 	switch len(arg) {
 	case 0:
@@ -89,10 +89,10 @@
 		command = fmt.Sprintf("code %q", file)
 	case 1:
 		command = fmt.Sprintf("code %q %s", file, stringFor(arg[0]))
-		text = p.Corpus.oneLine(file, text, arg[0])
+		text = p.oneLine(file, text, arg[0])
 	case 2:
 		command = fmt.Sprintf("code %q %s %s", file, stringFor(arg[0]), stringFor(arg[1]))
-		text = p.Corpus.multipleLines(file, text, arg[0], arg[1])
+		text = p.multipleLines(file, text, arg[0], arg[1])
 	default:
 		return "", fmt.Errorf("incorrect code invocation: code %q [%v, ...] (%d arguments)", file, arg[0], len(arg))
 	}
@@ -124,8 +124,8 @@
 }
 
 // oneLine returns the single line generated by a two-argument code invocation.
-func (c *Corpus) oneLine(file, text string, arg interface{}) string {
-	lines := strings.SplitAfter(c.contents(file), "\n")
+func (p *Presentation) oneLine(file, text string, arg interface{}) string {
+	lines := strings.SplitAfter(p.contents(file), "\n")
 	line, pattern, isInt := parseArg(arg, file, len(lines))
 	if isInt {
 		return lines[line-1]
@@ -134,8 +134,8 @@
 }
 
 // multipleLines returns the text generated by a three-argument code invocation.
-func (c *Corpus) multipleLines(file, text string, arg1, arg2 interface{}) string {
-	lines := strings.SplitAfter(c.contents(file), "\n")
+func (p *Presentation) multipleLines(file, text string, arg1, arg2 interface{}) string {
+	lines := strings.SplitAfter(p.contents(file), "\n")
 	line1, pattern1, isInt1 := parseArg(arg1, file, len(lines))
 	line2, pattern2, isInt2 := parseArg(arg2, file, len(lines))
 	if !isInt1 {
diff --git a/internal/godoc/versions.go b/internal/godoc/versions.go
deleted file mode 100644
index 9f18fb4..0000000
--- a/internal/godoc/versions.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2018 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
-// +build go1.16
-
-// This file caches information about which standard library types, methods,
-// and functions appeared in what version of Go
-
-package godoc
-
-import (
-	"log"
-
-	"golang.org/x/website/internal/api"
-)
-
-// InitVersionInfo parses the $GOROOT/api/go*.txt API definition files to discover
-// which API features were added in which Go releases.
-func (c *Corpus) InitVersionInfo() {
-	var err error
-	c.pkgAPIInfo, err = api.Load()
-	if err != nil {
-		// TODO: consider making this fatal, after the Go 1.11 cycle.
-		log.Printf("godoc: error parsing API version files: %v", err)
-	}
-}