diff --git a/go.mod b/go.mod
index 12f9fc2..1856172 100644
--- a/go.mod
+++ b/go.mod
@@ -5,6 +5,7 @@
 require (
 	cloud.google.com/go/errorreporting v0.3.0
 	github.com/client9/misspell v0.3.4
+	golang.org/x/mod v0.7.0
 	honnef.co/go/tools v0.3.3
 	mvdan.cc/unparam v0.0.0-20230125043941-70a0ce6e7b95
 )
@@ -20,7 +21,6 @@
 	github.com/googleapis/gax-go/v2 v2.7.0 // indirect
 	go.opencensus.io v0.23.0 // indirect
 	golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e // indirect
-	golang.org/x/mod v0.7.0 // indirect
 	golang.org/x/net v0.5.0 // indirect
 	golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783 // indirect
 	golang.org/x/sync v0.1.0 // indirect
diff --git a/internal/version/version.go b/internal/version/version.go
new file mode 100644
index 0000000..aa2648a
--- /dev/null
+++ b/internal/version/version.go
@@ -0,0 +1,271 @@
+// Copyright 2023 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 version handles version types.
+package version
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"golang.org/x/mod/semver"
+)
+
+// Type defines the version types a module can have.
+// This must be kept in sync with the 'version_type' database enum.
+type Type string
+
+const (
+	// TypeRelease is a normal release.
+	TypeRelease = Type("release")
+
+	// TypePrerelease is a version with a prerelease.
+	TypePrerelease = Type("prerelease")
+
+	// TypePseudo appears to have a prerelease of the
+	// form <commit date>-<commit hash>.
+	TypePseudo = Type("pseudo")
+)
+
+const (
+	// Latest signifies the latest available version in requests to the
+	// proxy client.
+	Latest = "latest"
+
+	// Main represents the main branch.
+	Main = "main"
+
+	// Master represents the master branch.
+	Master = "master"
+)
+
+func (t Type) String() string {
+	return string(t)
+}
+
+var pseudoVersionRE = regexp.MustCompile(`^v[0-9]+\.(0\.0-|\d+\.\d+-([^+]*\.)?0\.)\d{14}-[A-Za-z0-9]+(\+incompatible)?$`)
+
+// IsPseudo reports whether a valid version v is a pseudo-version.
+// Modified from src/cmd/go/internal/modfetch.
+func IsPseudo(v string) bool {
+	return strings.Count(v, "-") >= 2 && pseudoVersionRE.MatchString(v)
+}
+
+// IsIncompatible reports whether a valid version v is an incompatible version.
+func IsIncompatible(v string) bool {
+	return strings.HasSuffix(v, "+incompatible")
+}
+
+// ParseType returns the Type of a given a version.
+func ParseType(version string) (Type, error) {
+	if !semver.IsValid(version) {
+		return "", fmt.Errorf("ParseType(%q): invalid semver", version)
+	}
+
+	switch {
+	case IsPseudo(version):
+		return TypePseudo, nil
+	case semver.Prerelease(version) != "":
+		return TypePrerelease, nil
+	default:
+		return TypeRelease, nil
+	}
+}
+
+// ForSorting returns a string that encodes version, so that comparing two such
+// strings follows SemVer precedence, https://semver.org clause 11. It assumes
+// version is valid. The returned string ends in '~' if and only if the version
+// does not have a prerelease.
+//
+// For examples, see TestForSorting.
+func ForSorting(version string) string {
+	bytes := make([]byte, 0, len(version))
+	prerelease := false // we are in the prerelease part
+	nondigit := false   // this part has a non-digit character
+	start := 1          // skip 'v'
+	last := len(version)
+
+	// Add the semver component version[start:end] to the result.
+	addPart := func(end int) {
+		if len(bytes) > 0 {
+			// ',' comes before '-' and all letters and digits, so it correctly
+			// imposes lexicographic ordering on the parts of the version.
+			bytes = append(bytes, ',')
+		}
+		if nondigit {
+			// Prepending the largest printable character '~' to a non-numeric
+			// part, along with the fact that encoded numbers never begin with a
+			// '~', (see appendNumericPrefix), ensures the semver requirement
+			// that numeric identifiers always have lower precedence than
+			// non-numeric ones.
+			bytes = append(bytes, '~')
+		} else {
+			bytes = appendNumericPrefix(bytes, end-start)
+		}
+		bytes = append(bytes, version[start:end]...)
+		start = end + 1 // skip over separator character
+		nondigit = false
+	}
+
+loop:
+	for i, c := range version[start:] {
+		p := i + 1
+		switch {
+		case c == '.': // end of a part
+			addPart(p)
+		case c == '-': // first one is start of prerelease
+			if !prerelease {
+				prerelease = true
+				addPart(p)
+			} else {
+				nondigit = true
+			}
+		case c == '+': // start of build; nothing after this matters
+			last = p
+			break loop
+
+		case c < '0' || c > '9':
+			nondigit = true
+		}
+	}
+	if start < last {
+		addPart(last)
+	}
+	if !prerelease {
+		// Make sure prereleases appear first.
+		bytes = append(bytes, '~')
+	}
+	return string(bytes)
+}
+
+// appendNumericPrefix appends a string representing n to dst.
+// n is the length of a digit string; the value we append is a prefix for the
+// digit string s such that
+//
+//	prefix1 + s1 < prefix2 + s2
+//
+// if and only if the integer denoted by s1 is less than the one denoted by s2.
+// In other words, prefix + s is a string that can be compared with other such
+// strings while preserving the ordering of the numbers.
+//
+// If n==1, there is no prefix. (Single-digit numbers are unchanged.)
+// Otherwise, the prefix is a sequence of lower-case letters encoding n.
+// Examples:
+//
+//	n    prefix
+//	1    <none>
+//	2    a
+//	27   z
+//	28   za
+//	53   zz
+//	54   zza
+//
+// This encoding depends on the ASCII properties that:
+// - digits are ordered numerically
+// - letters are ordered alphabetically
+// - digits order before letters (so "1" < "a10")
+func appendNumericPrefix(dst []byte, n int) []byte {
+	n--
+	for i := 0; i < n/26; i++ {
+		dst = append(dst, 'z')
+	}
+	if rem := n % 26; rem > 0 {
+		dst = append(dst, byte('a'+rem-1))
+	}
+	return dst
+}
+
+// Later reports whether v1 is later than v2, using semver but preferring
+// release versions to pre-release versions, and both to pseudo-versions.
+func Later(v1, v2 string) bool {
+	rel1 := semver.Prerelease(v1) == ""
+	rel2 := semver.Prerelease(v2) == ""
+	if rel1 && rel2 {
+		return semver.Compare(v1, v2) > 0
+	}
+	if rel1 != rel2 {
+		return rel1
+	}
+	// Both are pre-release.
+	pseudo1 := IsPseudo(v1)
+	pseudo2 := IsPseudo(v2)
+	if pseudo1 == pseudo2 {
+		return semver.Compare(v1, v2) > 0
+	}
+	return !pseudo1
+}
+
+// LatestVersion finds the latest version of a module using the same algorithm as the
+// Go command. It prefers tagged release versions to tagged pre-release
+// versions, and both of those to pseudo-versions. If versions is empty, LatestVersion
+// returns the empty string.
+//
+// hasGoMod should report whether the version it is given has a go.mod file.
+// LatestVersion returns the latest incompatible version only if the latest compatible
+// version does not have a go.mod file.
+//
+// The meaning of latest is defined at
+// https://golang.org/ref/mod#version-queries. That definition does not deal
+// with retractions, or with a subtlety involving incompatible versions. The
+// actual definition is embodied in the go command's queryMatcher.filterVersions
+// method. This function is a re-implementation and specialization of that
+// method at Go version 1.16
+// (https://go.googlesource.com/go/+/refs/tags/go1.16/src/cmd/go/internal/modload/query.go#441).
+func LatestVersion(versions []string, hasGoMod func(v string) (bool, error)) (v string, err error) {
+	latest := LatestOf(versions)
+	if latest == "" {
+		return "", nil
+	}
+
+	// If the latest is a compatible version, use it.
+	if !IsIncompatible(latest) {
+		return latest, nil
+	}
+	// The latest version is incompatible. If there is a go.mod file at the
+	// latest compatible tagged version, assume the module author has adopted
+	// proper versioning, and use that latest compatible version. Otherwise, use
+	// this incompatible version.
+	latestCompat := LatestOf(RemoveIf(versions, func(v string) bool { return IsIncompatible(v) || IsPseudo(v) }))
+	if latestCompat == "" {
+		// No compatible versions; use the latest (incompatible) version.
+		return latest, nil
+	}
+	latestCompatHasGoMod, err := hasGoMod(latestCompat)
+	if err != nil {
+		return "", err
+	}
+	if latestCompatHasGoMod {
+		return latestCompat, nil
+	}
+	return latest, nil
+}
+
+// LatestOf returns the latest version of a module from a list of versions, using
+// the go command's definition of latest: semver is observed, except that
+// release versions are preferred to prerelease, and both are preferred to pseudo-versions.
+// If versions is empty, the empty string is returned.
+func LatestOf(versions []string) string {
+	if len(versions) == 0 {
+		return ""
+	}
+	latest := versions[0]
+	for _, v := range versions[1:] {
+		if Later(v, latest) {
+			latest = v
+		}
+	}
+	return latest
+}
+
+// RemoveIf returns a copy of s that omits all values for which f returns true.
+func RemoveIf(s []string, f func(string) bool) []string {
+	var r []string
+	for _, x := range s {
+		if !f(x) {
+			r = append(r, x)
+		}
+	}
+	return r
+}
diff --git a/internal/version/version_test.go b/internal/version/version_test.go
new file mode 100644
index 0000000..ddf01e9
--- /dev/null
+++ b/internal/version/version_test.go
@@ -0,0 +1,258 @@
+// Copyright 2023 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 version
+
+import (
+	"testing"
+
+	"golang.org/x/mod/semver"
+)
+
+func TestForSorting(t *testing.T) {
+	for _, test := range []struct {
+		in, want string
+	}{
+		{"v1.2.3", "1,2,3~"},
+		{"v12.48.301", "a12,a48,b301~"},
+		{"v0.9.3-alpha.1", "0,9,3,~alpha,1"},
+		{"v1.2.3-rc.20150901.-", "1,2,3,~rc,g20150901,~-"},
+		{"v1.2.3-alpha.789+build", "1,2,3,~alpha,b789"},
+	} {
+		got := ForSorting(test.in)
+		if got != test.want {
+			t.Errorf("ForSorting(%s) = %s, want %s", test.in, got, test.want)
+		}
+	}
+}
+
+func TestForSortingOrder(t *testing.T) {
+	// A list of valid semantic versions, in order.
+	semvers := []string{
+		"v0.0.0-20180713131340-b395d2d6f5ee",
+		"v0.0.0-20190124233150-8f7fa2680c82",
+		"v0.0.0",
+		"v0.0.1",
+		"v0.1.0",
+		"v1.0.0-alpha",
+		"v1.0.0-alpha.1",
+		"v1.0.0-alpha.beta",
+		"v1.0.0-beta",
+		"v1.0.0-beta.2",
+		"v1.0.0-beta.11",
+		"v1.0.0-rc.1",
+		"v1.0.0",
+		"v1.2.0",
+		"v1.11.0",
+		"v1.12.0-alph.1",
+		"v1.12.0-alpha",
+		// These next two would order incorrectly if we used '.' as a separator, because
+		// '.' comes after '-'.
+		"v2.0.0-z.a",
+		"v2.0.0-z-",
+		// These next two would sort incorrectly if we did not prepend non-numeric components
+		// with a '~'.
+		"v2.1.0-a.1",
+		"v2.1.0-a.-",
+	}
+
+	// Check that the test has the ordering right according to the semver package.
+	for i := range semvers {
+		if !semver.IsValid(semvers[i]) {
+			t.Fatalf("test is broken: bad semver: %s", semvers[i])
+		}
+		if i > 0 {
+			if semver.Compare(semvers[i-1], semvers[i]) >= 0 {
+				t.Fatalf("test is broken: %s is not less than %s", semvers[i-1], semvers[i])
+			}
+		}
+	}
+
+	// Check that ForSorting produces the correct ordering.
+	var prev string
+	for _, v := range semvers {
+		got := ForSorting(v)
+		if prev != "" && prev >= got {
+			t.Errorf("%s: %s >= %s, want less than", v, prev, got)
+		}
+		prev = got
+	}
+}
+
+func TestAppendNumericPrefix(t *testing.T) {
+	for _, test := range []struct {
+		n    int
+		want string
+	}{
+		{1, ""},
+		{2, "a"},
+		{3, "b"},
+		{26, "y"},
+		{53, "zz"},    // 53-1 = 26*2
+		{100, "zzzu"}, // 100-1 = 26*3 + 21
+	} {
+		got := string(appendNumericPrefix(nil, test.n))
+		if got != test.want {
+			t.Errorf("%d: got %s, want %s", test.n, got, test.want)
+		}
+	}
+}
+
+func TestParseVersionType(t *testing.T) {
+	testCases := []struct {
+		name, version   string
+		wantVersionType Type
+		wantErr         bool
+	}{
+		{
+			name:            "pseudo major version",
+			version:         "v1.0.0-20190311183353-d8887717615a",
+			wantVersionType: TypePseudo,
+		},
+		{
+			name:            "pseudo prerelease version",
+			version:         "v1.2.3-pre.0.20190311183353-d8887717615a",
+			wantVersionType: TypePseudo,
+		},
+		{
+			name:            "pseudo minor version",
+			version:         "v1.2.4-0.20190311183353-d8887717615a",
+			wantVersionType: TypePseudo,
+		},
+		{
+			name:            "pseudo version invalid",
+			version:         "v1.2.3-20190311183353-d8887717615a",
+			wantVersionType: TypePrerelease,
+		},
+		{
+			name:            "valid release",
+			version:         "v1.0.0",
+			wantVersionType: TypeRelease,
+		},
+		{
+			name:            "valid prerelease",
+			version:         "v1.0.0-alpha.1",
+			wantVersionType: TypePrerelease,
+		},
+		{
+			name:            "invalid version",
+			version:         "not_a_version",
+			wantVersionType: "",
+			wantErr:         true,
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+			if gotVt, err := ParseType(test.version); (test.wantErr == (err != nil)) && test.wantVersionType != gotVt {
+				t.Errorf("parseVersionType(%v) = %v, want %v", test.version, gotVt, test.wantVersionType)
+			}
+		})
+	}
+}
+
+func TestLatestOf(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		versions []string
+		want     string
+	}{
+		{
+			name:     "highest release",
+			versions: []string{"v1.2.3", "v1.0.0", "v1.9.0-pre"},
+			want:     "v1.2.3",
+		},
+		{
+			name:     "highest pre-release if no release",
+			versions: []string{"v1.2.3-alpha", "v1.0.0-beta", "v1.9.0-pre"},
+			want:     "v1.9.0-pre",
+		},
+		{
+			name:     "prefer pre-release to pseudo",
+			versions: []string{"v1.0.0-20180713131340-b395d2d6f5ee", "v0.0.0-alpha"},
+			want:     "v0.0.0-alpha",
+		},
+
+		{
+			name:     "highest pseudo if no pre-release or release",
+			versions: []string{"v0.0.0-20180713131340-b395d2d6f5ee", "v0.0.0-20190124233150-8f7fa2680c82"},
+			want:     "v0.0.0-20190124233150-8f7fa2680c82",
+		},
+		{
+			name:     "use incompatible",
+			versions: []string{"v1.2.3", "v1.0.0", "v2.0.0+incompatible"},
+			want:     "v2.0.0+incompatible",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got := LatestOf(test.versions)
+			if got != test.want {
+				t.Errorf("got %s, want %s", got, test.want)
+			}
+		})
+	}
+}
+
+func TestLatest(t *testing.T) {
+	pseudo := "v0.0.0-20190124233150-8f7fa2680c82"
+	for _, test := range []struct {
+		name     string
+		versions []string
+		hasGoMod func(string) (bool, error)
+		want     string
+	}{
+		{
+			name:     "empty",
+			versions: nil,
+			want:     "",
+		},
+		{
+			name:     "tagged release",
+			versions: []string{pseudo, "v0.1.0", "v1.2.3-pre"},
+			want:     "v0.1.0",
+		},
+		{
+			name:     "tagged pre-release",
+			versions: []string{pseudo, "v1.2.3-pre"},
+			want:     "v1.2.3-pre",
+		},
+		{
+			name:     "pseudo",
+			versions: []string{pseudo},
+			want:     pseudo,
+		},
+		{
+			name:     "incompatible with go.mod",
+			versions: []string{"v2.0.0+incompatible", "v1.2.3"},
+			want:     "v1.2.3",
+		},
+		{
+			name:     "incompatible without go.mod",
+			versions: []string{"v2.0.0+incompatible", "v1.2.3"},
+			hasGoMod: func(v string) (bool, error) { return false, nil },
+			want:     "v2.0.0+incompatible",
+		},
+		{
+			name: "incompatible without tagged go.mod",
+			// Although the latest compatible version has a go.mod file,
+			// it is not a tagged version.
+			versions: []string{pseudo, "v2.0.0+incompatible"},
+			want:     "v2.0.0+incompatible",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+
+			if test.hasGoMod == nil {
+				test.hasGoMod = func(v string) (bool, error) { return true, nil }
+			}
+			got, err := LatestVersion(test.versions, test.hasGoMod)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got != test.want {
+				t.Errorf("got %q, want %q", got, test.want)
+			}
+		})
+	}
+}