diff --git a/internal/datasource.go b/internal/datasource.go
index 517772f..32ceebe 100644
--- a/internal/datasource.go
+++ b/internal/datasource.go
@@ -25,17 +25,17 @@
 	GetPathInfo(ctx context.Context, path, inModulePath, inVersion string) (outModulePath, outVersion string, isPackage bool, err error)
 	// GetPseudoVersionsForModule returns LegacyModuleInfo for all known
 	// pseudo-versions for the module corresponding to modulePath.
-	GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*LegacyModuleInfo, error)
+	GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
 	// GetPseudoVersionsForModule returns LegacyModuleInfo for all known
 	// pseudo-versions for any module containing a package with the given import
 	// path.
-	GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*LegacyModuleInfo, error)
+	GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
 	// GetTaggedVersionsForModule returns LegacyModuleInfo for all known tagged
 	// versions for the module corresponding to modulePath.
-	GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*LegacyModuleInfo, error)
+	GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
 	// GetTaggedVersionsForModule returns LegacyModuleInfo for all known tagged
 	// versions for any module containing a package with the given import path.
-	GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*LegacyModuleInfo, error)
+	GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
 
 	// TODO(b/155474770): Deprecate these methods.
 	//
diff --git a/internal/frontend/tabs.go b/internal/frontend/tabs.go
index 50ecba1..6613632 100644
--- a/internal/frontend/tabs.go
+++ b/internal/frontend/tabs.go
@@ -208,7 +208,7 @@
 	case "licenses":
 		return &LicensesDetails{Licenses: transformLicenses(mi.ModulePath, mi.Version, licenses)}, nil
 	case "versions":
-		return fetchModuleVersionsDetails(ctx, ds, mi)
+		return fetchModuleVersionsDetails(ctx, ds, &mi.ModuleInfo)
 	case "overview":
 		// TODO(b/138448402): implement remaining module views.
 		readme := &internal.Readme{Filepath: mi.LegacyReadmeFilePath, Contents: mi.LegacyReadmeContents}
diff --git a/internal/frontend/versions.go b/internal/frontend/versions.go
index c365acf..3ee148a 100644
--- a/internal/frontend/versions.go
+++ b/internal/frontend/versions.go
@@ -63,7 +63,7 @@
 
 // fetchModuleVersionsDetails builds a version hierarchy for module versions
 // with the same series path as the given version.
-func fetchModuleVersionsDetails(ctx context.Context, ds internal.DataSource, mi *internal.LegacyModuleInfo) (*VersionsDetails, error) {
+func fetchModuleVersionsDetails(ctx context.Context, ds internal.DataSource, mi *internal.ModuleInfo) (*VersionsDetails, error) {
 	versions, err := ds.GetTaggedVersionsForModule(ctx, mi.ModulePath)
 	if err != nil {
 		return nil, err
@@ -76,7 +76,7 @@
 			return nil, err
 		}
 	}
-	linkify := func(m *internal.LegacyModuleInfo) string {
+	linkify := func(m *internal.ModuleInfo) string {
 		return constructModuleURL(m.ModulePath, linkVersion(m.Version, m.ModulePath))
 	}
 	return buildVersionDetails(mi.ModulePath, versions, linkify), nil
@@ -98,7 +98,7 @@
 		}
 	}
 
-	var filteredVersions []*internal.LegacyModuleInfo
+	var filteredVersions []*internal.ModuleInfo
 	// TODO(rfindley): remove this filtering, as it should not be necessary and
 	// is probably a relic of earlier version query implementations.
 	for _, v := range versions {
@@ -109,7 +109,7 @@
 		}
 	}
 
-	linkify := func(mi *internal.LegacyModuleInfo) string {
+	linkify := func(mi *internal.ModuleInfo) string {
 		// Here we have only version information, but need to construct the full
 		// import path of the package corresponding to this version.
 		var versionPath string
@@ -135,7 +135,7 @@
 //   3) Join with the versioned module path foo.com/bar/v2 to get
 //      foo.com/bar/v2/baz.
 // ...being careful about slashes along the way.
-func pathInVersion(v1Path string, mi *internal.LegacyModuleInfo) string {
+func pathInVersion(v1Path string, mi *internal.ModuleInfo) string {
 	suffix := strings.TrimPrefix(strings.TrimPrefix(v1Path, mi.SeriesPath()), "/")
 	if suffix == "" {
 		return mi.ModulePath
@@ -147,7 +147,7 @@
 // versions tab, organizing major versions into those that have the same module
 // path as the package version under consideration, and those that don't.  The
 // given versions MUST be sorted first by module path and then by semver.
-func buildVersionDetails(currentModulePath string, modInfos []*internal.LegacyModuleInfo, linkify func(v *internal.LegacyModuleInfo) string) *VersionsDetails {
+func buildVersionDetails(currentModulePath string, modInfos []*internal.ModuleInfo, linkify func(v *internal.ModuleInfo) string) *VersionsDetails {
 
 	// lists organizes versions by VersionListKey. Note that major version isn't
 	// sufficient as a key: there are packages contained in the same major
diff --git a/internal/frontend/versions_test.go b/internal/frontend/versions_test.go
index 4b99506..32ee36c 100644
--- a/internal/frontend/versions_test.go
+++ b/internal/frontend/versions_test.go
@@ -58,8 +58,8 @@
 	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
 	defer cancel()
 
-	info1 := sample.LegacyModuleInfo(modulePath1, "v1.2.1")
-	info2 := sample.LegacyModuleInfo(modulePath2, "v2.2.1-alpha.1")
+	info1 := sample.ModuleInfo(modulePath1, "v1.2.1")
+	info2 := sample.ModuleInfo(modulePath2, "v2.2.1-alpha.1")
 	makeList := func(path, major string, versions []string) *VersionList {
 		return &VersionList{
 			VersionListKey: VersionListKey{ModulePath: path, Major: major},
@@ -71,7 +71,7 @@
 
 	for _, tc := range []struct {
 		name        string
-		info        *internal.LegacyModuleInfo
+		info        *internal.ModuleInfo
 		modules     []*internal.Module
 		wantDetails *VersionsDetails
 	}{
@@ -291,7 +291,7 @@
 	}
 
 	for _, test := range tests {
-		mi := sample.LegacyModuleInfo(test.modulePath, sample.VersionString)
+		mi := sample.ModuleInfo(test.modulePath, sample.VersionString)
 		if got := pathInVersion(test.v1Path, mi); got != test.want {
 			t.Errorf("pathInVersion(%q, LegacyModuleInfo{...ModulePath:%q}) = %s, want %v",
 				test.v1Path, mi.ModulePath, got, test.want)
diff --git a/internal/postgres/details.go b/internal/postgres/details.go
index 12345b4..b107438 100644
--- a/internal/postgres/details.go
+++ b/internal/postgres/details.go
@@ -71,21 +71,21 @@
 // GetTaggedVersionsForPackageSeries returns a list of tagged versions sorted in
 // descending semver order. This list includes tagged versions of packages that
 // have the same v1path.
-func (db *DB) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.LegacyModuleInfo, error) {
+func (db *DB) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
 	return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
 // GetPseudoVersionsForPackageSeries returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order. This list includes
 // pseudo-versions of packages that have the same v1path.
-func (db *DB) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.LegacyModuleInfo, error) {
+func (db *DB) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
 	return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypePseudo})
 }
 
 // getPackageVersions returns a list of versions sorted in descending semver
 // order. The version types included in the list are specified by a list of
 // VersionTypes.
-func getPackageVersions(ctx context.Context, db *DB, pkgPath string, versionTypes []version.Type) (_ []*internal.LegacyModuleInfo, err error) {
+func getPackageVersions(ctx context.Context, db *DB, pkgPath string, versionTypes []version.Type) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.Wrap(&err, "DB.getPackageVersions(ctx, db, %q, %v)", pkgPath, versionTypes)
 
 	baseQuery := `
@@ -124,9 +124,9 @@
 	}
 	defer rows.Close()
 
-	var versionHistory []*internal.LegacyModuleInfo
+	var versionHistory []*internal.ModuleInfo
 	for rows.Next() {
-		var mi internal.LegacyModuleInfo
+		var mi internal.ModuleInfo
 		if err := rows.Scan(&mi.ModulePath, &mi.Version, &mi.CommitTime); err != nil {
 			return nil, fmt.Errorf("row.Scan(): %v", err)
 		}
@@ -152,20 +152,20 @@
 
 // GetTaggedVersionsForModule returns a list of tagged versions sorted in
 // descending semver order.
-func (db *DB) GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.LegacyModuleInfo, error) {
+func (db *DB) GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
 	return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
 // GetPseudoVersionsForModule returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order.
-func (db *DB) GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.LegacyModuleInfo, error) {
+func (db *DB) GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
 	return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypePseudo})
 }
 
 // getModuleVersions returns a list of versions sorted in descending semver
 // order. The version types included in the list are specified by a list of
 // VersionTypes.
-func getModuleVersions(ctx context.Context, db *DB, modulePath string, versionTypes []version.Type) (_ []*internal.LegacyModuleInfo, err error) {
+func getModuleVersions(ctx context.Context, db *DB, modulePath string, versionTypes []version.Type) (_ []*internal.ModuleInfo, err error) {
 	// TODO(b/139530312): get information for parent modules.
 	defer derrors.Wrap(&err, "getModuleVersions(ctx, db, %q, %v)", modulePath, versionTypes)
 
@@ -187,9 +187,9 @@
 		queryEnd = `LIMIT 10;`
 	}
 	query := fmt.Sprintf(baseQuery, versionTypeExpr(versionTypes), queryEnd)
-	var vinfos []*internal.LegacyModuleInfo
+	var vinfos []*internal.ModuleInfo
 	collect := func(rows *sql.Rows) error {
-		var mi internal.LegacyModuleInfo
+		var mi internal.ModuleInfo
 		if err := rows.Scan(&mi.ModulePath, &mi.Version, &mi.CommitTime); err != nil {
 			return err
 		}
diff --git a/internal/postgres/details_test.go b/internal/postgres/details_test.go
index 7e96b85..141525e 100644
--- a/internal/postgres/details_test.go
+++ b/internal/postgres/details_test.go
@@ -193,7 +193,7 @@
 		name, path, modulePath string
 		numPseudo              int
 		modules                []*internal.Module
-		wantTaggedVersions     []*internal.LegacyModuleInfo
+		wantTaggedVersions     []*internal.ModuleInfo
 	}{
 		{
 			name:       "want_releases_and_prereleases_only",
@@ -201,34 +201,26 @@
 			modulePath: modulePath1,
 			numPseudo:  12,
 			modules:    testModules,
-			wantTaggedVersions: []*internal.LegacyModuleInfo{
+			wantTaggedVersions: []*internal.ModuleInfo{
 				{
-					ModuleInfo: internal.ModuleInfo{
-						ModulePath: modulePath2,
-						Version:    "v2.1.0",
-						CommitTime: sample.CommitTime,
-					},
+					ModulePath: modulePath2,
+					Version:    "v2.1.0",
+					CommitTime: sample.CommitTime,
 				},
 				{
-					ModuleInfo: internal.ModuleInfo{
-						ModulePath: modulePath2,
-						Version:    "v2.0.1-beta",
-						CommitTime: sample.CommitTime,
-					},
+					ModulePath: modulePath2,
+					Version:    "v2.0.1-beta",
+					CommitTime: sample.CommitTime,
 				},
 				{
-					ModuleInfo: internal.ModuleInfo{
-						ModulePath: modulePath1,
-						Version:    "v1.0.0",
-						CommitTime: sample.CommitTime,
-					},
+					ModulePath: modulePath1,
+					Version:    "v1.0.0",
+					CommitTime: sample.CommitTime,
 				},
 				{
-					ModuleInfo: internal.ModuleInfo{
-						ModulePath: modulePath1,
-						Version:    "v1.0.0-alpha.1",
-						CommitTime: sample.CommitTime,
-					},
+					ModulePath: modulePath1,
+					Version:    "v1.0.0-alpha.1",
+					CommitTime: sample.CommitTime,
 				},
 			},
 		},
@@ -249,7 +241,7 @@
 		t.Run(tc.name, func(t *testing.T) {
 			defer ResetTestDB(testDB, t)
 
-			var wantPseudoVersions []*internal.LegacyModuleInfo
+			var wantPseudoVersions []*internal.ModuleInfo
 			for i := 0; i < tc.numPseudo; i++ {
 
 				pseudo := fmt.Sprintf("v0.0.0-201806111833%02d-d8887717615a", i+1)
@@ -261,12 +253,10 @@
 				// GetPseudoVersions should only return the 10 most recent pseudo versions,
 				// if there are more than 10 in the database
 				if i < 10 {
-					wantPseudoVersions = append(wantPseudoVersions, &internal.LegacyModuleInfo{
-						ModuleInfo: internal.ModuleInfo{
-							ModulePath: modulePath1,
-							Version:    fmt.Sprintf("v0.0.0-201806111833%02d-d8887717615a", tc.numPseudo-i),
-							CommitTime: sample.CommitTime,
-						},
+					wantPseudoVersions = append(wantPseudoVersions, &internal.ModuleInfo{
+						ModulePath: modulePath1,
+						Version:    fmt.Sprintf("v0.0.0-201806111833%02d-d8887717615a", tc.numPseudo-i),
+						CommitTime: sample.CommitTime,
 					})
 				}
 			}
@@ -308,7 +298,6 @@
 			if diff := cmp.Diff(tc.wantTaggedVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
 				t.Errorf("testDB.GetTaggedVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
 			}
-
 		})
 	}
 }
diff --git a/internal/proxydatasource/datasource.go b/internal/proxydatasource/datasource.go
index bcf6f83..e9acc9e 100644
--- a/internal/proxydatasource/datasource.go
+++ b/internal/proxydatasource/datasource.go
@@ -188,7 +188,7 @@
 
 // GetPseudoVersionsForModule returns versions from the the proxy /list
 // endpoint, if they are pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetPseudoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.LegacyModuleInfo, err error) {
+func (ds *DataSource) GetPseudoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.Wrap(&err, "GetPseudoVersionsForModule(%q)", modulePath)
 	return ds.listModuleVersions(ctx, modulePath, true)
 }
@@ -196,14 +196,14 @@
 // GetPseudoVersionsForPackageSeries finds the longest module path containing
 // pkgPath, and returns its versions from the proxy /list endpoint, if they are
 // pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.LegacyModuleInfo, err error) {
+func (ds *DataSource) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.Wrap(&err, "GetPseudoVersionsForPackageSeries(%q)", pkgPath)
 	return ds.listPackageVersions(ctx, pkgPath, true)
 }
 
 // GetTaggedVersionsForModule returns versions from the the proxy /list
 // endpoint, if they are tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.LegacyModuleInfo, err error) {
+func (ds *DataSource) GetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.Wrap(&err, "GetTaggedVersionsForModule(%q)", modulePath)
 	return ds.listModuleVersions(ctx, modulePath, false)
 }
@@ -211,7 +211,7 @@
 // GetTaggedVersionsForPackageSeries finds the longest module path containing
 // pkgPath, and returns its versions from the proxy /list endpoint, if they are
 // tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.LegacyModuleInfo, err error) {
+func (ds *DataSource) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.Wrap(&err, "GetTaggedVersionsForPackageSeries(%q)", pkgPath)
 	return ds.listPackageVersions(ctx, pkgPath, false)
 }
@@ -302,7 +302,7 @@
 // calls the proxy /list endpoint to list its versions. If pseudo is true, it
 // filters to pseudo versions.  If pseudo is false, it filters to tagged
 // versions.
-func (ds *DataSource) listPackageVersions(ctx context.Context, pkgPath string, pseudo bool) (_ []*internal.LegacyModuleInfo, err error) {
+func (ds *DataSource) listPackageVersions(ctx context.Context, pkgPath string, pseudo bool) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.Wrap(&err, "listPackageVersions(%q, %t)", pkgPath, pseudo)
 	ds.mu.RLock()
 	mods := ds.packagePathToModules[pkgPath]
@@ -324,13 +324,13 @@
 // calls the proxy /list endpoint to list its versions. If pseudo is true, it
 // filters to pseudo versions.  If pseudo is false, it filters to tagged
 // versions.
-func (ds *DataSource) listModuleVersions(ctx context.Context, modulePath string, pseudo bool) (_ []*internal.LegacyModuleInfo, err error) {
+func (ds *DataSource) listModuleVersions(ctx context.Context, modulePath string, pseudo bool) (_ []*internal.ModuleInfo, err error) {
 	defer derrors.Wrap(&err, "listModuleVersions(%q, %t)", modulePath, pseudo)
 	versions, err := ds.proxyClient.ListVersions(ctx, modulePath)
 	if err != nil {
 		return nil, err
 	}
-	var vis []*internal.LegacyModuleInfo
+	var vis []*internal.ModuleInfo
 	ds.mu.RLock()
 	defer ds.mu.RUnlock()
 	for _, vers := range versions {
@@ -341,17 +341,15 @@
 			continue
 		}
 		if v, ok := ds.versionCache[versionKey{modulePath, vers}]; ok {
-			vis = append(vis, &v.module.LegacyModuleInfo)
+			vis = append(vis, &v.module.ModuleInfo)
 		} else {
-			// In this case we can't produce s LegacyModuleInfo without fully processing
+			// In this case we can't produce ModuleInfo without fully processing
 			// the module zip, so we instead append a stub. We could further query
 			// for this version's /info endpoint to get commit time, but that is
 			// deferred as a potential future enhancement.
-			vis = append(vis, &internal.LegacyModuleInfo{
-				ModuleInfo: internal.ModuleInfo{
-					ModulePath: modulePath,
-					Version:    vers,
-				},
+			vis = append(vis, &internal.ModuleInfo{
+				ModulePath: modulePath,
+				Version:    vers,
 			})
 		}
 	}
diff --git a/internal/proxydatasource/datasource_test.go b/internal/proxydatasource/datasource_test.go
index 82eae66..7fdd25b 100644
--- a/internal/proxydatasource/datasource_test.go
+++ b/internal/proxydatasource/datasource_test.go
@@ -192,11 +192,11 @@
 	}
 	v110 := wantModuleInfo
 	v110.Version = "v1.1.0"
-	want := []*internal.LegacyModuleInfo{
-		{ModuleInfo: wantModuleInfo},
-		{ModuleInfo: v110},
+	want := []*internal.ModuleInfo{
+		&wantModuleInfo,
+		&v110,
 	}
-	ignore := cmpopts.IgnoreFields(internal.LegacyModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
+	ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
 	if diff := cmp.Diff(want, got, ignore); diff != "" {
 		t.Errorf("GetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
 	}
@@ -216,11 +216,11 @@
 	}
 	v110 := wantModuleInfo
 	v110.Version = "v1.1.0"
-	want := []*internal.LegacyModuleInfo{
-		{ModuleInfo: wantModuleInfo},
-		{ModuleInfo: v110},
+	want := []*internal.ModuleInfo{
+		&wantModuleInfo,
+		&v110,
 	}
-	ignore := cmpopts.IgnoreFields(internal.LegacyModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
+	ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
 	if diff := cmp.Diff(want, got, ignore); diff != "" {
 		t.Errorf("GetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
 	}